#include <stdio.h>
#include <vector>
#include <algorithm>
#include <utility>
using namespace std;

#define in "zvon.in"
#define out "zvon.out"
#define dim 100067
#define K L[nod].size()

int T, N, Q;
int aux;
vector<int> L[dim];
int Tmin[dim], R[dim];

struct Compare {
       bool operator() (int i, int j)
       {
            return R[i] > R[j];
       }
};

inline int Maxim(int a, int b ) { return a > b ? a : b; }

void DF_Solve(int);
void Qsort(int,int);

int main()
{
    int X, Y, poz;
    char linie[101];
    
    freopen(in,"r",stdin);
    freopen(out,"w",stdout);
    
    scanf("%d", &T);
    for ( ; T > 0; T-- )
    {
        scanf("%d", &N);
        for ( int i = 1; i <= N; i++ ) L[i].clear(), Tmin[i] = 0; 
        
        for ( int i = 1; i < N; i++ )
        {
            scanf("%d%d", &X, &Y);
            L[X].push_back(Y);
        }
        
        DF_Solve(1);
        
       // for ( int i = 1; i <= N; i++ );
            //printf("%d %d\n", i, Tmin[i] );
        
        printf("%d\n", Tmin[1]);
    }
}

void DF_Solve(int nod)
{
     if ( L[nod].size() == 0 ) 
     {
          Tmin[nod] = 0;
          return;
     }
     
     for ( int i = 0; i < K; i++ )
     {
         DF_Solve(L[nod][i]);
         
         //R[i+1] = Tmin[L[nod][i]];
         
         //if ( nod == 12 ) printf("%d ", R[i+1]);
     }
     
     for ( int i = 0; i < K; i++ )
         R[i+1] = Tmin[L[nod][i]];
     
     sort( R+1, R+K+1 );
     
     for ( int i = 1; i <= K; i++ )
     {
        // if ( nod == 12 ) printf("%d %d\n", Tmin[13], R[K-i+1]);
         Tmin[nod] = Maxim( Tmin[nod], i+R[K-i+1] ); 
     }
}
/*
void Qsort(int st, int dr)
{
     int i = st-1, j = dr+1, pivot = R[st];
     
     while ( i <= j )
     {
           do { i++; } while ( R[i] > pivot );
           do { j--; } while ( R[j] < pivot );
           
           if ( i < j ) swap(R[i],R[j]);
     }  
     
     if ( st < j ) Qsort(st,j);
     if ( i < dr ) Qsort(i,dr);
}

/*
void DF(int nod)
{
     if ( L[nod].size() == 0 ) Vec[nod] = 0; 
     
     for ( int i = 0; i < L[nod].size(); i++ )
     {
         DF(L[nod][i]);
         
         Vec[nod] += Vec[L[nod][i]] + 1;
     }
}

void Solve(int nod, int timp)
{
     if ( Q < timp ) Q = timp;
     
     for ( int i = 0; i < L[nod].size(); i++ )
     {
         Solve(L[nod][i],timp+1+i);
     }
}*/