#include <vector>
#include <algorithm>
#include <cstring>
#include <fstream>
#include <queue>

using namespace std;

ifstream fin("revolta.in");
ofstream fout("revolta.out");

const int dim = 100005;

vector<int> g[dim];

int vis[dim], parent[dim], dp[dim], dpl[dim], dpr[dim];

bool onDiam[dim];

queue<int> que;

vector<int> diam;

int bfs(int s) {

	memset(vis, 0, sizeof vis);
	memset(parent, -1, sizeof parent);

	vis[s] = 1;
	que.push(s);

	int maxim = 1, nMax = s;
	while (!que.empty()) {

		int x = que.front();
		que.pop();

		for (int it : g[x]) {
			if (vis[it])
				continue;
			vis[it] = vis[x] + 1;
			if (vis[it] > maxim)
				maxim = vis[it], nMax = it;
			parent[it] = x;
			que.push(it);
		}

	}

	return nMax;

}

void dfs(int x) {

	vis[x] = 1;
	for (int it : g[x]) {

		if (vis[it])
			continue;
		dfs(it);
		dp[x] = max(dp[x], 1 + dp[it]);
	}

}

int main() {

	int t;
	fin >> t;

	while (t--) {

		int n;
		fin >> n;

		for (int i = 1; i <= n; ++i)
			g[i].clear();

		for (int i = 1; i < n; ++i) {

			int x, y;
			fin >> x >> y;

			g[x].push_back(y);
			g[y].push_back(x);

		}

		int b = bfs(bfs(0));

		diam.clear();
		memset(vis, 0, sizeof vis);
		while (b != -1) {
			diam.push_back(b);
			onDiam[b] = true;
			vis[b] = 1;
			b = parent[b];
		}

		memset(dp, 0, sizeof dp);
		for (int x : diam) {
			dfs(x);
		}

		int maxim = 0;
		for (int i = 1; i < (int)diam.size(); ++i) {

			maxim = max(maxim, i - 1 + dp[diam[i - 1]]);
			dpl[i] = maxim;

		}

		maxim = 0;
		for (int i = (int)diam.size() - 1; i > 0; --i) {

			maxim = max(maxim, (int)diam.size() - i - 1 + dp[diam[i]]);
			dpr[i] = maxim;

		}

		int sol = diam.size() - 1;
		for (int i = 1; i < (int)diam.size(); ++i) {

			if (dpl[i] == dpr[i] && dpl[i] % 2 == 0)
				sol = min(sol, dpl[i] + 1);
			else if (dpl[i] == dpr[i])
				sol = min(sol, dpl[i] + 2);
			else
				sol = min(sol, max(dpl[i], dpr[i]));

		}

		fout << sol << '\n';

	}

	return 0;

}

//Trust me, I'm the Doctor!