#include<iostream>
#include<cstring>
#include<vector>
#include<cstdio>
#include<algorithm>
#include<iomanip>
#define MAX_N 1234
#define MAX_D 25
using namespace std;

int father[MAX_N];
int n;

int popu[MAX_N];

struct edge {
    int to;
    double cost;

    edge(int t, double c) : to(t), cost(c) { }

    edge() { }
};

struct road {
    int from, to;
    double cost;

    road(int f, int t, double c) : from(f), to(t), cost(c) { }

    road() { }
};

bool cmp(road a,road b) {
    if (a.cost == b.cost)
        return popu[a.from] + popu[a.to] > popu[b.from] + popu[b.to];
    return a.cost < b.cost;
}

road ro[MAX_N*MAX_N];
int tot=0;
vector<edge> G[MAX_N];
double B;

int depth[MAX_N];
int ancestor[MAX_N][25];
double maxEdge[MAX_N][25];

struct Point {
    double x, y;

    Point(double xx, double yy) : x(xx), y(yy) { }

    Point() { }

    double dis(Point a) {
        return sqrt((x - a.x) * (x - a.x) + (y - a.y) * (y - a.y));
    }
};

Point po[MAX_N];

void init() {
    for (int i = 0; i <= n; i++)
        father[i] = i;
    for (int i = 0; i <= n; i++)G[i].clear();
    tot = 0;
    B = 0;
    memset(depth, 0, sizeof(depth));
    memset(ancestor, 0, sizeof(ancestor));
    memset(maxEdge, 0, sizeof(maxEdge));
}

int Find(int x){
    if(x==father[x])return x;
    return father[x]=Find(father[x]);
}

void unionSet(int x,int y) {
    int u = Find(x), v = Find(y);
    if (u == v)return;
    father[u] = v;
}

bool Same(int x,int y){
    return Find(x)==Find(y);
}

void Kruskal() {
    sort(ro + 1, ro + tot + 1, cmp);
    for (int i = 1; i <= tot; i++) {
        int u = ro[i].from, v = ro[i].to;
        if (Same(u, v))continue;
        unionSet(u, v);
        G[u].push_back(edge(v,ro[i].cost));
        G[v].push_back(edge(u,ro[i].cost));
        B += ro[i].cost;
    }
}

void dfs(int u,int p) {
    for (int i = 0; i < G[u].size(); i++) {
        int v = G[u][i].to;
        double c = G[u][i].cost;
        if (v == p)continue;
        depth[v] = depth[u] + 1;
        ancestor[v][0] = u;
        maxEdge[v][0] = c;
        dfs(v, u);
    }
}

void getAncestor() {
    for (int j = 1; j < MAX_D; j++) {
        for (int i = 1; i <= n; i++) {
            ancestor[i][j] = ancestor[ancestor[i][j - 1]][j - 1];
            maxEdge[i][j] = max(maxEdge[i][j - 1], maxEdge[ancestor[i][j - 1]][j - 1]);
        }
    }
}

double LCA(int u,int v) {
    double res = -1;
    if (depth[u] < depth[v])swap(u, v);
    for (int i = MAX_D - 1; i >= 0; i--) {
        if (depth[ancestor[u][i]] >= depth[v]) {
            res = max(res, maxEdge[u][i]);
            u = ancestor[u][i];
            if (depth[u] == depth[v])break;
        }
    }
    if (u == v)return res;
    for (int i = MAX_D - 1; i >= 0; i--) {
        if (ancestor[u][i] != ancestor[v][i]) {
            res = max(res, max(maxEdge[u][i], maxEdge[v][i]));
            u = ancestor[u][i];
            v = ancestor[v][i];
        }
    }
    return max(res, max(maxEdge[u][0], maxEdge[v][0]));
}

int T;

int main() {
    cin.sync_with_stdio(false);
    cin >> T;
    while (T--) {
        cin >> n;
        init();
        for (int i = 1; i <= n; i++)
            cin >> po[i].x >> po[i].y >> popu[i];
        for (int i = 1; i <= n; i++)
            for (int j = i + 1; j <= n; j++)
                ro[++tot] = road(i, j, po[i].dis(po[j]));
        Kruskal();
        depth[1] = 1;
        dfs(1, 0);
        getAncestor();
        double ans = -1;
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= n; j++)
                ans = max(ans, (popu[i] + popu[j]) / (B - LCA(i, j)));
        cout << setprecision(2) << fixed << ans << endl;
    }
    return 0;
}