#include <iostream>
#include <sstream>
#include <string>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cassert>

using namespace std;

#define FOR(i,k,n) for(int i=(k); i<(int)(n); ++i)
#define REP(i,n) FOR(i,0,n)
#define FORIT(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)

template<class T> void debug(T begin, T end){ for(T i = begin; i != end; ++i) cerr<<*i<<" "; cerr<<endl; }
inline bool valid(int x, int y, int W, int H){ return (x >= 0 && y >= 0 && x < W && y < H); }

typedef long long ll;
const int INF = 100000000;
const double EPS = 1e-8;
const int MOD = 1000000007;
int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
#include <complex>
typedef complex<double> Point;

// 誤差を加味した符号判定
int sign(double a){
  if(a > EPS) return +1;
  if(a < -EPS) return -1;
  return 0;
}

// 誤差を加味した同一判定
bool equal(double a, double b){ 
  return abs(b - a) < EPS;
}
bool operator==(const Point& a, const Point& b){
  return equal(a.real(), b.real()) && equal(a.imag(), b.imag());
}

// 比較演算子
namespace std{
  bool operator < (const Point& a, const Point& b) {
    return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
  }
}

// 内積・外積
double dot(Point a, Point b){
  return real(conj(a) * b);
}
double cross(Point a, Point b){
  return imag(conj(a) * b);
}
// 点の進行方向
int ccw(Point a, Point b, Point c) {
  b -= a; c -= a;
  if (cross(b, c) > EPS)   return +1; // 反時計回り
  if (cross(b, c) < -EPS)   return -1; // 時計回り
  if (dot(b, c) < 0)     return +2; // c--a--b の順番で一直線上
  if (norm(b) < norm(c)) return -2; // a--b--c の順番で一直線上
  return 0;                         // a--c--b の順番で一直線上(またはb == c)
}
struct Line : public vector<Point> {
  Line(const Point& a, const Point& b) {
    push_back(a); push_back(b);
  }
  Point vector() const {
    return back() - front();
  }
};

// 二つの線分の交差判定
bool intersectSS(const Line& s, const Line& t) {
  return ccw(s[0], s[1], t[0]) * ccw(s[0], s[1], t[1]) <= 0 &&
         ccw(t[0], t[1], s[0]) * ccw(t[0], t[1], s[1]) <= 0;
}

typedef vector<Point> Polygon;

// Polygonの要素へのアクセス
Point curr(const Polygon& a, int x){ return a[x]; }
Point next(const Polygon& a, int x){ return a[(x + 1) % a.size()]; }
Point prev(const Polygon& a, int x){ return a[(x - 1 + a.size()) % a.size()]; }

// 点が多角形のどこにあるのか判定する
enum { OUT, ON, IN };
int contains(const Polygon& P, const Point& p){
  // 点pから半直線をひき、辺と交差する回数を数える
  bool in = false;
  REP(i, P.size()){
    Point a = curr(P, i) - p;
    Point b = next(P, i) - p;
    if(a.imag() > b.imag()) swap(a, b);
    // aからbの直線がy=0と交わり、その交点は原点の右側である
    if(a.imag() <= 0 && 0 < b.imag() && cross(a, b) < 0){ 
      in = !in;
    }
    if(cross(a, b) == 0 && dot(a, b) <= 0) return ON;
  }
  return in ? IN : OUT;
}

bool overlap(Polygon P, Polygon Q){
  REP(i, P.size()){
    if(contains(Q, P[i]) != OUT) return true;
  }
  REP(i, Q.size()){
    if(contains(P, Q[i]) != OUT) return true;
  }
  REP(i, P.size()) REP(j, Q.size()){
    Line l = Line(curr(P, i), next(P, i));
    Line m = Line(curr(Q, j), next(Q, j));
    if(intersectSS(l, m)) return true;
  }
  return false;
}
// UnionFind (Spaghetti source)
struct UnionFind {
  vector<int> data;
  UnionFind(int N) : data(N, -1) { }
  // xとyを併合する
  bool uni(int x, int y) {
    x = root(x); y = root(y);
    if (x != y) {
      if (data[x] > data[y]) swap(x, y);
      data[x] += data[y]; data[y] = x;
    }
    return x != y;
  }
  // xとyが同じ集合にあるか判定する
  bool same(int x, int y) {
    return root(x) == root(y);
  }
  // xを含む集合の要素数を求める
  int size(int x) {
    return -data[root(x)];
  }

  int root(int x) {
    return data[x] < 0 ? x : data[x] = root(data[x]);
  }
};
int main(){
  int N;
  while(cin >> N && N){
    REP(iter, N){
      int M; cin >> M;
      vector<Polygon> square(M);
      REP(i, M) {
        square[i] = Polygon(4);
        REP(j, 4){
          Point p; 
          cin >> p.real() >> p.imag();
          square[i][3 - j] = p;
        }
      }
      int ans = M;
      UnionFind uf(M);
      REP(i, M) FOR(j, i + 1, M){
        if(overlap(square[i], square[j])){
          if(uf.uni(i, j)) ans--;
        }
      }
      cout << ans << endl;
    }
  }
  return 0;
}

Measured memory_bytes: 1268