#include
#include
#include
#include

#define MAXSIZE 150
#define INT_MAX 210000000
#define INFINITE INT_MAX

using namespace std;

struct AXIS
{
double xPos;
double yPos;
};

struct DistanceTerm
{
int fromIndex;
int toIndex;
double distance;
};

void InitVariable();
void GetDataFromUser( AXIS* artic, int numOfArtic );
void SetLengthTableData( AXIS *artic, int numOfAtic );
double Distance( AXIS& first, AXIS& second );
void PrintAnswerByMST( int numOfArtic );

bool compare( DistanceTerm first, DistanceTerm second )
{
if( first.distance < second.distance )
return true;

return false;

}

double g_ArticLength[ MAXSIZE ][ MAXSIZE ];
DistanceTerm g_DistanceTerm[ MAXSIZE * MAXSIZE ];
int g_MSTTableInex = 0;
int main()
{
int numOfCase = 0;
int tryOfCase = 0;

AXIS artic[ MAXSIZE ];
cin >> numOfCase;

while( tryOfCase != numOfCase )
{
    int numOfArtic = 0;


    cin >> numOfArtic;

    InitVariable(); 
    GetDataFromUser( artic, numOfArtic );
    SetLengthTableData( artic, numOfArtic );
    PrintAnswerByMST( numOfArtic );

    tryOfCase++;
}

}

void InitVariable()
{
for( int i = 0 ; i < MAXSIZE; i++ )
for( int j = 0 ; j < MAXSIZE; j++ )
{
g_ArticLength[ i ][ j ] = INFINITE;
}

g_MSTTableInex = 0;

}

void GetDataFromUser( AXIS* artic, int numOfArtic )
{

int curPositionIndex = 0;

    while( curPositionIndex != numOfArtic )
    {
        cin >> artic[ curPositionIndex ].xPos >> artic[ curPositionIndex ].yPos;
        curPositionIndex++;
    }

}

double Distance( AXIS& first, AXIS& second )
{
return sqrt( pow( first.xPos - second.xPos, 2 ) +
pow( first.yPos - second.yPos, 2 ) );
}

void SetLengthTableData( AXIS *artic, int numOfArtic )
{
int termIndex = 0;

for( int i = 0 ; i < numOfArtic; i++ )
        for( int j  = 0 ; j < numOfArtic; j++ )
        {
    //      g_ArticLength[ i ][ j ] = g_ArticLength[ j ][ i ] = Distance( artic[ i ], artic[ j ] );
            if( i != j )
            {
                g_DistanceTerm[ g_MSTTableInex ].fromIndex = i;
                g_DistanceTerm[ g_MSTTableInex ].toIndex = j;
                g_DistanceTerm[ g_MSTTableInex ].distance = Distance( artic[ i ], artic[ j ] );
                g_MSTTableInex++;
            }
        }

    sort( g_DistanceTerm, g_DistanceTerm + g_MSTTableInex , compare );

//  for( int i = 0 ; i <  g_MSTTableInex  ; i++ )
    //  cout << g_DistanceTerm[ i ].fromIndex <<" " << g_DistanceTerm[ i ].toIndex << " " <<g_DistanceTerm[ i ].distance << endl;

}

int FindNextNode( bool *visited, int sPos, int numOfArtic )
{
int nextNode = 0;
int minValue = INFINITE;

for( int i = 0 ; i < g_MSTTableInex ; i++ )
{
    if( ( sPos == g_DistanceTerm[ i ].fromIndex ) && (!visited[ g_DistanceTerm[i].toIndex ] ) )
    {
        if( minValue > g_DistanceTerm[i].distance )
        {
            minValue = g_DistanceTerm[i].distance;
            nextNode = i;
        }
    }
}

visited[ g_DistanceTerm[ nextNode ].toIndex ] = true;
return nextNode;

}

void PrintAnswerByMST( int numOfArtic )
{
bool visited[ MAXSIZE ];

for( int i = 0 ; i < MAXSIZE ;i++ )
{
    visited[ i ] = false;
}

int sPos = 0;
double answer = -1;

visited[ 0 ] = true;

while( true )
{
    bool allPathVisited = true;


    for( int i = 0 ; i < numOfArtic ; i++ )
    {
        if( visited[ i ] == false )
        {
            allPathVisited = false;
            break;
        }
    }

    if( allPathVisited )
    {
        break;
    }

    int nextNode= FindNextNode( visited, sPos, numOfArtic );

//  cout << nextValue << endl;

    if( answer < g_DistanceTerm[ nextNode ].distance )
    {
        answer =  g_DistanceTerm[ nextNode ].distance;
    }

    sPos = g_DistanceTerm[ nextNode ].toIndex;
}

cout.setf(ios::fixed);
cout.precision(2);
cout << answer << endl;

}