from collections import deque

def bfs_farthest(start, adj):
    visited = [-1] * len(adj)
    queue = deque()
    queue.append(start)
    visited[start] = 0
    farthest_node = start

    while queue:
        current = queue.popleft()
        for neighbor in adj[current]:
            if visited[neighbor] == -1:
                visited[neighbor] = visited[current] + 1
                queue.append(neighbor)
                if visited[neighbor] > visited[farthest_node]:
                    farthest_node = neighbor
    return farthest_node, visited[farthest_node]

def compute_optimal_ttl(n, edges):
    # Build adjacency list
    adj = [[] for _ in range(n)]
    for a, b in edges:
        adj[a].append(b)
        adj[b].append(a)

    # First BFS to find farthest from node 0
    far_node, _ = bfs_farthest(0, adj)
    # Second BFS from far_node to get tree diameter
    _, diameter = bfs_farthest(far_node, adj)
    # Minimum TTL is radius = ceil(diameter / 2)
    return (diameter + 1) // 2

def main():
    import sys
    input = sys.stdin.read
    data = input().split()

    idx = 0
    t = int(data[idx])
    idx += 1

    results = []

    for _ in range(t):
        n = int(data[idx])
        idx += 1
        edges = []
        for _ in range(n - 1):
            a = int(data[idx])
            b = int(data[idx + 1])
            edges.append((a, b))
            idx += 2
        result = compute_optimal_ttl(n, edges)
        results.append(str(result))

    print('\n'.join(results))

if __name__ == "__main__":
    main()