#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <sstream>
#include <queue>
#include <deque>
#include <bitset>
#include <iterator>
#include <list>
#include <stack>
#include <map>
#include <set>
#include <functional>
#include <numeric>
#include <utility>
#include <limits>
#include <time.h>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>

using namespace std;

int N;
int n_computers;
int interconnected;
int successful_answers, unsuccessful_answers;
int computer_i, computer_j;
char question_type;
string s;

class UnionFind {
  private:
    vector<int> p, rank;
    int num_sets;

  public:
    UnionFind() {  }

    int find_set(int i) {
      return (p[i] == i) ? i : (p[i] = find_set(p[i]));
    }

    int is_same_set(int i, int j) {
      return find_set(i) == find_set(j);
    }

    void unite(int i, int j) {
      if (is_same_set(i, j)) {
        return;
      }

      num_sets--;
      int x = find_set(i);
      int y = find_set(j);

      if  (rank[x] > rank[y]) {
        p[y] = x;
      } else {
        p[x] = y;

        if (rank[x] == rank[y]) {
          rank[y]++;
        }
      }
    }

    int num_disjoint_sets() {
      return num_sets;
    }

    void set(int num) {
      num_sets = num;
      rank.assign(num+1, 0);
      p.assign(num+1, 0);

      for (int i = 0; i <= num; i++) {
        p[i] = i;
      }
    }

    void clear() {
      rank.clear();
      p.clear();
    }

};

int main() {
  UnionFind union_set;
  scanf("%d\n", &N);

  while (N--) {
    successful_answers = 0;
    unsuccessful_answers = 0;

    scanf("%d\n", &n_computers);
    union_set.set(n_computers);

    while (1) {
      if(!getline(cin,s) || s.empty()) break;
      sscanf(s.c_str(),"%c %d %d", &question_type, &computer_i, &computer_j);

      if (question_type == 'c') {
        //printf("i: %d, j: %d\n", computer_i, computer_j);
        //printf("before x: %d, y: %d\n", union_set.find_set(computer_i), union_set.find_set(computer_j));
        union_set.unite(computer_i, computer_j);
        //printf("before y: %d, y: %d\n", union_set.find_set(computer_i), union_set.find_set(computer_j));
      } else {
        interconnected = union_set.is_same_set(computer_i, computer_j);

        if (interconnected) {
          successful_answers++;
        } else {
          unsuccessful_answers++;
        }
      }
    }

    printf("%d,%d", successful_answers, unsuccessful_answers);
    if (N) {
      printf("\n\n");
    }
    union_set.clear();
  }

  return 0;
}