#include <bits/stdc++.h>

#define rep(i, n) for (int i = 0; i < int(n); i++)
#define rrep(i, n) for (int i = int(n) - 1; i >= 0; i--)
#define reps(i, n) for (int i = 1; i <= int(n); i++)
#define rreps(i, n) for (int i = int(n); i >= 1; i--)
#define repc(i, n) for (int i = 0; i <= int(n); i++)
#define rrepc(i, n) for (int i = int(n); i >= 0; i--)
#define repi(i, a, b) for (int i = int(a); i < int(b); i++)
#define repic(i, a, b) for (int i = int(a); i <= int(b); i++)
#define each(x, y) for (auto &x : y)
#define all(a) (a).begin(), (a).end()
#define bit(b) (1ll << (b))

using namespace std;

using i32 = int;
using i64 = long long;
using u64 = unsigned long long;
using f80 = long double;
using vi32 = vector<i32>;
using vi64 = vector<i64>;
using vu64 = vector<u64>;
using vf80 = vector<f80>;
using vstr = vector<string>;

inline void yes() { cout << "Yes" << '\n'; exit(0); }
inline void no() { cout << "No" << '\n'; exit(0); }
inline i64 gcd(i64 a, i64 b) { if (min(a, b) == 0) return max(a, b); if (a % b == 0) return b; return gcd(b, a % b); }
inline i64 lcm(i64 a, i64 b) { return a / gcd(a, b) * b; }
inline u64 xorshift() { static u64 x = 88172645463325252ull; x = x ^ (x << 7); return x = x ^ (x >> 9); }
void solve(); int main() { ios::sync_with_stdio(0); cin.tie(0); cout << fixed << setprecision(3); solve(); return 0; }
template <typename T> class pqasc : public priority_queue<T, vector<T>, greater<T>> {};
template <typename T> class pqdesc : public priority_queue<T, vector<T>, less<T>> {};
template <typename T> inline void amax(T &x, T y) { if (x < y) x = y; }
template <typename T> inline void amin(T &x, T y) { if (x > y) x = y; }
template <typename T> inline T power(T x, i64 n, T e = 1) { T r = e; while (n > 0) { if (n & 1) r *= x; x *= x; n >>= 1; } return r; }
template <typename T> istream& operator>>(istream &is, vector<T> &v) { each(x, v) is >> x; return is; }
template <typename T> ostream& operator<<(ostream &os, vector<T> &v) { rep(i, v.size()) { if (i) os << ' '; os << v[i]; } return os; }
template <typename T, typename S> istream& operator>>(istream &is, pair<T, S> &p) { is >> p.first >> p.second; return is; }
template <typename T, typename S> ostream& operator<<(ostream &os, pair<T, S> &p) { os << p.first << ' ' << p.second; return os; }

template <typename T>
struct Matrix {
  vector<vector<T>> v;
  int r, c;
  Matrix(int r, int c, T d) : r(r), c(c) {
    v = vector<vector<T>>(r, vector<T>(c, d));
  }
  Matrix(vector<vector<T>> v) : v(v) {
    r = v.size();
    c = v[0].size();
  }
  vector<T>& operator[](int x) {
    return v[x];
  }
  Matrix<T> operator*=(Matrix<T> that) {
    assert(c == that.r);
    auto ret = Matrix<T>(r, that.c, 0);
    rep(i, r) rep(j, that.c) rep(k, c) {
      ret[i][j] += v[i][k] * that[k][j];
    }
    return *this = ret;
  }
  Matrix<T> operator*(Matrix<T> that) {
    return *this *= that;
  }
  Matrix<T> pow(i64 n) {
    assert(r == c);
    auto e = Matrix<T>(r, c, 0);
    rep(i, r) e[i][i] = 1;
    return power(*this, n, e);
  }
};

void solve() {
  function<f80(f80)> rnd = [](f80 x) {
    return round(x * 1000) / 1000;
  };
  int n; cin >> n;
  while (n--) {
    f80 x[3], y[3];
    rep(i, 3) cin >> x[i] >> y[i];
    auto a = Matrix<f80>({{
      - power(x[0], 2) - power(y[0], 2),
      - power(x[1], 2) - power(y[1], 2),
      - power(x[2], 2) - power(y[2], 2),
    }});
    f80 r = 1 / (
      x[0]*y[1] + x[1]*y[2] + x[2]*y[0] - x[2]*y[1] - x[1]*y[0] - x[0]*y[2]
    );
    auto xx = Matrix<f80>({
      { y[1] - y[2], x[2] - x[1], x[1]*y[2] - x[2]*y[1] },
      { y[2] - y[0], x[0] - x[2], x[2]*y[0] - x[0]*y[2] },
      { y[0] - y[1], x[1] - x[0], x[0]*y[1] - x[1]*y[0] },
    });
    rep(i, 3) rep(j, 3) xx[i][j] *= r;
    auto ans = a * xx;

    auto p = -ans[0][0] / 2;
    auto q = -ans[0][1] / 2;
    auto s = sqrt(power(p, 2) + power(q, 2) - ans[0][2]);
    cout << p << " " << q << " " << s << '\n';
  }
}



Measured memory_bytes: 3276