Go: package main

import (
	"fmt"
	"math"
)

func main() {
	n := scanInt()
	for i := 0; i < n; i++ {
		circleTriangle()
	}
}

func scanInt() int {
	var n int
	fmt.Scanf("%d", &n)
	return n
}

func circleTriangle() {
	var x1, y1, x2, y2, x3, y3 float64
	fmt.Scanf("%f%f%f%f%f%f", &x1, &y1, &x2, &y2, &x3, &y3)
	a := 2 * (x1 - x2)
	b := 2 * (y1 - y2)
	c := 2 * (x1 - x3)
	d := 2 * (y1 - y3)
	e := x1*x1 - x2*x2 + y1*y1 - y2*y2
	f := x1*x1 - x3*x3 + y1*y1 - y3*y3

	px := (d*e - b*f) / (a*d - b*c)
	py := (a*f - c*e) / (a*d - b*c)

	r := math.Sqrt((x1-px)*(x1-px) + (y1-py)*(y1-py))
	fmt.Printf("%.3f %.3f %.3f\n", px, py, r)
}

C++: #include <iostream>
#include <cmath>
#include <cstdio>
#include <string>
#include <sstream>

using namespace std;

long double sisya(long double a) {
	a *= 1000.0;
	//cout << a << endl;
	a += 0.5;
	a = (int)a;
	a /= 1000.0;
	return a; 
}

long double ll(long double x1, long double y1, long double x2, long double y2) {
	return ((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
}

int main() {
	int n;
	cin >> n;
	for (int i = 0; i < n; i++) {
		long double dd[3][2];
		for (int j = 0; j < 3; j++) {
			cin >> dd[j][0] >> dd[j][1];
		}
		long double k[3];
		k[0] = ll(dd[1][0],dd[1][1],dd[2][0],dd[2][1]);
		k[1] = ll(dd[2][0],dd[2][1],dd[0][0],dd[0][1]);
		k[2] = ll(dd[0][0],dd[0][1],dd[1][0],dd[1][1]);
		long double S, X, Y, R;
		S = ((dd[1][0]-dd[0][0])*(dd[2][1]-dd[0][1])-(dd[1][1]-dd[0][1])*(dd[2][0]-dd[0][0]))*((dd[1][0]-dd[0][0])*(dd[2][1]-dd[0][1])-(dd[1][1]-dd[0][1])*(dd[2][0]-dd[0][0]))/4.0;
		X = (k[0]*(k[1]+k[2]-k[0])*dd[0][0]+k[1]*(k[2]+k[0]-k[1])*dd[1][0]+k[2]*(k[0]+k[1]-k[2])*dd[2][0])/(16.0*S);
		Y = (k[0]*(k[1]+k[2]-k[0])*dd[0][1]+k[1]*(k[2]+k[0]-k[1])*dd[1][1]+k[2]*(k[0]+k[1]-k[2])*dd[2][1])/(16.0*S);
		R = sqrt(ll(X, Y, dd[0][0], dd[0][1]));
		X = sisya(X);
		Y = sisya(Y);
		R = sisya(R);
		printf("%.3f %.3f %.3f\n", X, Y, R);
	}
	return 0;
}

C++: #include <iostream>
#include <map>
#include <vector>
#include <cmath>
#include <iomanip>
#include <string>
#include <queue>
#include <algorithm>
#include <cctype>
#include <cstdio>
#define shosu(x) fixed<<setprecision(x)
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
typedef pair<double,double> pdd;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<P> vp;
typedef vector<vp> vvp;
typedef pair<int,P> pip;
typedef vector<pip> vip;
const int inf=1<<30;
const double pi=acos(-1);
const double eps=1e-8;

struct point{
	double x,y;
	point operator+(point Gep){
		return point{x+Gep.x,y+Gep.y};
	}
	point operator-(point Gep){
		return point{x-Gep.x,y-Gep.y};
	}
	point operator*(double Gex){
		return point{x*Gex,y*Gex};
	}
	point operator/(double Gex){
		if(!Gex) return point{0,0}; 
		return point{x/Gex,y/Gex};
	}
	bool operator==(point Gep){
		return fabs(x-Gep.x)<eps&&fabs(y-Gep.y)<eps;
	}
};

class Geom{
	private:
	vector<point> Ge;
	vector<pair<point,point> > Geseg,Geline;
	public:
	void line_push(point Gex,point Gey){
		Geline.push_back(make_pair(Gex,Gey));
	}
	void seg_push(point Gex,point Gey){
		Geseg.push_back(make_pair(Gex,Gey));
	}
	void point_push(point Gex){
		Ge.push_back(Gex);
	}
	point DIP(pair<point,point> Gex,pdd Gey){
		double Gea=Gey.first,Geb=Gey.second;
		point Ge1=Gex.first,Ge2=Gex.second;
		return (Ge1*Geb+Ge2*Gea)/(Gea+Geb);
	}
	point POI(pair<point,point>Gex,pair<point,point> Gey){
		pair<point,point> Ge1(PRO(Gex,Gey.first),PRO(Gex,Gey.second));
		pdd Ger(EXTLEN(Gey.first,Ge1.first),EXTLEN(Gey.second,Ge1.second));
		return DIP(Ge1,Ger);
	}
	double IP(point Gex,point Gey){
		return Gex.x*Gey.x+Gex.y*Gey.y;
	}
	double CP(point Gex,point Gey){
		return Gex.x*Gey.y-Gey.x*Gex.y;
	}
	double LEN(point Gex){
		return sqrt(Gex.x*Gex.x+Gex.y*Gex.y);
	}
	double EXTLEN(point Gex,point Gey){
		return LEN(Gex-Gey);
	}
/*	double SLEN(pair<point,point> Gex,pair<point,point> Gey){
		double Getmp=PJUD(Gex,Gey);
		if(Getmp==inf) return 0;
		point Ge1=Gex.first,Ge2=Gex.second,Ge3=Gey.first,Ge4=Gey.second;
		if(Getmp==-1) return min(min(EXTLEN(Ge1,Ge3),EXTLEN(Ge1,Ge4)),min(EXTLEN(Ge2,Ge3),EXTLEN(Ge2,Ge4)));
		if()
	}*/
	double HELON(point Gex,point Gey,point Gez){
		double Gea=EXTLEN(Gex,Gey),Geb=EXTLEN(Gey,Gez),Gec=EXTLEN(Gey,Gez);
		double Ges=(Gea+Geb+Gec)/2;
		return sqrt(Ges*(Ges-Gea)*(Ges-Geb)*(Ges-Gec));
	}
	point PRO(pair<point,point> Gea,point Gex){
		point Ge1=Gex-Gea.second,Ge2=Gea.first-Gea.second;
		return Ge2*(IP(Ge1,Ge2)/(LEN(Ge2)*LEN(Ge2)))+Gea.second;
	}
	point REF(pair<point,point> Gea,point Gex){
		point Ge1=PRO(Gea,Gex);
		return Ge1*2-Gex;
	}
	point REVO(point Gex,point Ger,double Gey){
		point Getmp=Gex-Ger;
		return point{Getmp.x*cos(Gey)-Getmp.y*sin(Gey)+Ger.x,Getmp.x*sin(Gey)+Getmp.y*cos(Gey)+Ger.y};
	}
	point CIR(point Gex,point Gey,point Gez){
		point Ge1=(Gex+Gey)/2,Ge2=(Gey+Gez)/2;
		pair<point,point> Gea(REVO(Gex,Ge1,pi/2),REVO(Gey,Ge1,pi/2)),Geb(REVO(Gey,Ge2,pi/2),REVO(Gez,Ge2,pi/2));
		return POI(Gea,Geb);
	}
	int PJUD(point Gea,point Geb,point Gex){
		if(Gea==Geb||Gex==Geb) return 0;
		point Ge1=Gea-Gex,Ge2=Geb-Gex;
		double Getmp=CP(Ge1,Ge2);
		if(Getmp>eps) return 1;
		if(Getmp<-eps) return 2;
		if(IP(Ge1,Ge2)<eps) return 3;
		if(LEN(Ge1)<LEN(Ge2)) return 4;
		return 5;
	}
	int SJUD(pair<point,point> Gex,pair<point,point> Gey){
		if(four_JUD(Gex.first,Gex.second,Gey.first,Gey.second)){
			int Ge1=PJUD(Gex.first,Gey.first,Gex.second),Ge2=PJUD(Gex.first,Gey.second,Gex.second),Ge3=PJUD(Gey.first,Gex.first,Gey.second),Ge4=PJUD(Gey.first,Gex.second,Gey.second);
			if((Ge1==3||Ge1==4)&&(Ge2==3||Ge2==4)&&(Ge3==3||Ge3==4)&&(Ge4==3||Ge4==4)) return -1;
			return inf;
		}
		if(LJUD(Gex,Gey)==2) return 0;
		point Getmp=POI(Gex,Gey);
		int Ge1=PJUD(Gex.first,Getmp,Gex.second),Ge2=PJUD(Gey.first,Getmp,Gey.second);
		if((!Ge1||Ge1==5)&&(!Ge2||Ge2==5)) return 1;
		return 0;
	}
	int LJUD(pair<point,point> Gex,pair<point,point> Gey){
		point Ge1=Gex.first-Gex.second,Ge2=Gey.first-Gey.second;
		if(!CP(Ge1,Ge2)) return 2;
		if(!IP(Ge1,Ge2)) return 1;
		return 0;
	}
	bool four_JUD(point Gea,point Geb,point Gec,point Ged){
		int Ge1=PJUD(Gea,Geb,Gec),Ge2=PJUD(Gea,Geb,Ged);
		if(Ge1!=1&&Ge1!=2&&Ge2!=1&&Ge2!=2) return 1;
		return 0;
	}
/*	double AREA(){
		double Geans=0;
		for(int i=1;i<Ge.size()-1;i++){
			Geans+=HELON(Ge[0],Ge[i],Ge[i+1]);
		}
		return Geans;
	}*/
	pair<point,point> line_open(int Gex){
		return Geline[Gex];
	}
	point point_open(int Gex){
		return Ge[Gex];
	}
	pair<point,point> seg_open(int Gex){
		return Geseg[Gex];
	}
};

int q;

int main(){
	cout<<shosu(3);
	cin>>q;
	for(int i=0;i<q;i++){
		Geom geo;
		for(int j=0;j<3;j++){
			double x,y;
			cin>>x>>y;
			geo.point_push(point{x,y});
		}
		point ans=geo.CIR(geo.point_open(0),geo.point_open(1),geo.point_open(2));
//		cout<<ans.x<<' '<<ans.y<<' '<<geo.EXTLEN(geo.point_open(0),ans)<<endl;
		printf("%.3f %.3f %.3f\n",ans.x,ans.y,geo.EXTLEN(geo.point_open(0),ans));
	}
}