#include <cstdio>
#include <vector>
#include <queue>

#define maxN 100001

using namespace std;

int Tt;
int N;
int Nr[maxN];
int Niv[maxN];
int Nmax[maxN];
int T[maxN];
int Bfq[maxN];

class comp
{
    public:
        bool operator()(int a, int b)
        {
            if(Nr[a] == Nr[b])
                return Nmax[a] > Nmax[b];

            else
                return Nr[a] < Nr[b];
        }
};

vector <int> V[maxN];
priority_queue<int, vector <int>, comp> pq;

void bf_niv()
{
    int i, j, n, st, end;

    Bfq[1] = 1;
    st = end = 1;

    while(st <= end)
    {
        n = V[Bfq[st]].size();

        for(i=0; i<n; ++i)
        {
            Niv[V[Bfq[st]][i]] = Niv[Bfq[st]] + 1;
            Bfq[++end] = V[Bfq[st]][i];
        }

        ++ st;
    }

    for(i=end; i>=1; --i)
    {
        n = V[Bfq[i]].size();

        if(!n)
        {
            Nmax[Bfq[i]] = Niv[Bfq[i]];
            Nr[Bfq[i]] = 1;
        }
        else
        {
            Nmax[Bfq[i]] = 0;
            Nr[Bfq[i]] = 1;
            
//            for(j=0; j<n; ++j)
//            {
//                if(Nmax[V[Bfq[i]][j]] > Nmax[Bfq[i]])
//                    Nmax[Bfq[i]] = Nmax[V[Bfq[i]][j]];
//                Nr[Bfq[i]] += Nr[V[Bfq[i]][j]];
//            }
        }
    }
}

void bfs()
{
    int nod, i, k, n, st, end, x;

    st = end = 1;
    Bfq[1] = 1;

    while(st <= end)
    {
        nod = Bfq[st];
        ++ st;

        n = V[nod].size();

        for(i=0; i<n; ++i)
            pq.push(V[nod][i]);

        k = 1;

        while(pq.empty() == false)
        {
            x = pq.top();
            pq.pop();
            Bfq[++end] = x;

            T[x] = T[nod] + k;
            ++ k;    
        }
    }
}

int main()
{
    freopen("zvon.in", "rt", stdin);
    freopen("zvon.out", "wt", stdout);

    int i, a, b;

    for(scanf("%d", &Tt); Tt; --Tt)
    {
        for(scanf("%d", &N), i=1; i<N; ++i)
        {
            scanf("%d %d", &a, &b);
            V[a].push_back(b);
        }    

        Niv[1] = 0;
        bf_niv();
        bfs();

        int sol = 0;

        for(i=1; i<=N; ++i)
        {
            sol = T[i] > sol ? T[i] : sol;
            T[i] = 0;
            V[i].clear();
        }

        printf("%d\n", sol);
    }

    fclose(stdin);
    fclose(stdout);

    return 0;
}