#include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
using namespace std;
using ll = long long;
using vec = vector<ll>;
using vect = vector<double>;
using Graph = vector<vector<ll>>;
#define loop(i, n) for (ll i = 0; i < n; i++)
#define Loop(i, m, n) for (ll i = m; i < n; i++)
#define pool(i, n) for (ll i = n; i >= 0; i--)
#define Pool(i, m, n) for (ll i = n; i >= m; i--)
#define mod 1000000007ll
#define setbit bitset<8>
#define flagcount __builtin_popcount
#define flag(x) (1 << x)
#define flagadd(bit, x) bit |= flag(x)
#define flagpop(bit, x) bit &= ~flag(x)
#define flagon(bit, i) bit &flag(i)
#define flagoff(bit, i) !(bit & (1 << i))
#define all(v) v.begin(), v.end()
#define low2way(v, x) lower_bound(all(v), x)
#define high2way(v, x) upper_bound(all(v), x)
#define count2way(v, x) high2way(v, x) - low2way(v, x)
#define lower(v, x) low2way(v, x) - v.begin()       //1番左が0、もし見つから無いならｎを出力
#define higher(v, x) high2way(v, x) - v.begin() - 1 //1番左が0、もし見つからないならn-1を出力（注意）
#define putout(a) cout << a << endl
#define putout2(a, b) \
    putout(a);        \
    putout(b)
#define putout3(a, b, c) \
    putout(a);           \
    putout(b);           \
    putout(c)
#define putout4(a, b, c, d) \
    putout(a);              \
    putout(b);              \
    putout(c);              \
    putout(d)
#define putout5(a, b, c, d, e) \
    putout(a);                 \
    putout(b);                 \
    putout(c);                 \
    putout(d);                 \
    putout(e)
#define Gput(a, b) G[a].push_back(b)
#define cin1(a) cin >> a
#define cin2(a, b) cin >> a >> b
#define cin3(a, b, c) cin >> a >> b >> c
#define cin4(a, b, c, d) cin >> a >> b >> c >> d
#define cin5(a, b, c, d, e) cin >> a >> b >> c >> d >> e
#define Sum(v) accumulate(all(v), 0ll)
#define gcd(x, y) __gcd(x, y)
ll ctoi(char c)
{
    if (c >= '0' && c <= '9')
    {
        return c - '0';
    }
    return 0;
}
template <typename T>
T lcm(T x, T y)
{
    T z = gcd(x, y);
    return x * y / z;
}
template <typename T>
bool primejudge(T n)
{
    if (n < 2)
        return false;
    else if (n == 2)
        return true;
    else if (n % 2 == 0)
        return false;
    double sqrtn = sqrt(n);
    for (T i = 3; i < sqrtn + 1; i++)
    {
        if (n % i == 0)
        {
            return false;
        }
        i++;
    }
    return true;
}
template <typename T>
T modinv(T a, T m)
{
    T b = m, u = 1, v = 0;
    while (b)
    {
        T t = a / b;
        a -= t * b;
        swap(a, b);
        u -= t * v;
        swap(u, v);
    }
    u %= m;
    if (u < 0)
        u += m;
    return u;
}
//場合によって使い分ける
//const ll dx[4]={1,0,-1,0};
//const ll dy[4]={0,1,0,-1};
const ll dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
//多次元配列の宣言法
//vector<vector<ll>> field(h, vector<ll>(w));
template <class T>
inline void chmax(T &a, T b)
{
    if (a < b)
        a = b;
}
template <class T>
inline void chmin(T &a, T b)
{
    if (a > b)
        a = b;
}
/*
ライブラリをここに置いてコメントを削除
*/
//円周率
static const double pi = 3.141592653589793;
//幾何の問題で入力が多い時に使用
#define scan(x) scanf("%ld", &x)

//誤差チェッカー
#define EPS (1e-10)
#define equals(a, b) (fabs((a) - (b)) < EPS)
//点を表わす構造体
struct Point
{
public:
    double x, y;
    Point(double _x, double _y) : x(_x), y(_y) {}
    /*
    以下ベクトルに対する演算子の定義
    +:ベクトルの足し算
    -:ベクトルの引き算
    *:スカラー倍
    /:スカラーの逆数倍
    */
    Point operator+(const Point p) { return Point(x + p.x, y + p.y); }
    Point operator-(const Point p) { return Point(x - p.x, y - p.y); }
    Point operator*(const double k) { return Point(x * k, y * k); }
    Point operator/(const double k) { return Point(x / k, y / k); }
    double abs() { return sqrt(norm()); }
    double norm() { return x * x + y * y; }
    //ベクトルの比較(x軸方向のベクトルから比較)
    bool operator<(const Point &p) const
    {
        return x != p.x ? x < p.x : y < p.y;
    }
    bool operator>(const Point &p) const
    {
        return x != p.x ? x > p.x : y > p.y;
    }
    bool operator==(const Point &p) const
    {
        return equals(x, p.x) && equals(y, p.y);
    }
    bool operator!=(const Point &p) const
    {
        return (!equals(x, p.x)) || (!equals(y, p.y));
    }
};
//ベクトルとして扱う場合
typedef Point Vector;
//線分を表わす構造体
struct Segment
{
    Point p1, p2;
    Segment(Point _p1, Point _p2) : p1(_p1), p2(_p2) {}
};
//直線として扱う場合
typedef Segment Line;
//ベクトルのノルム
double norm(Vector a)
{
    return a.x * a.x + a.y * a.y;
}
//ベクトルの大きさ
double abs(Vector a)
{
    return sqrt(norm(a));
}
//ベクトルの内積
double dot(Vector a, Vector b)
{
    return a.x * b.x + a.y * b.y;
}
//ベクトルの外積
double cross(Vector a, Vector b)
{
    return a.x * b.y - a.y * b.x;
}
//内積≓0かどうかによるベクトルの直交判定(様々な引数で答えられるように複数用意)
bool Orthogonal(Vector a, Vector b)
{
    return equals(dot(a, b), 0.0);
}
bool Orthogonal(Point a1, Point a2, Point b1, Point b2)
{
    return Orthogonal(a1 - a2, b1 - b2);
}
bool Orthogonal(Segment s1, Segment s2)
{
    return equals(dot(s1.p2 - s1.p1, s2.p2 - s2.p1), 0.0);
}
//外積≓0かどうかによるベクトルの平行判定(様々な引数で答えられるように複数用意)
bool Parallel(Vector a, Vector b)
{
    return equals(cross(a, b), 0.0);
}
bool Parallel(Point a1, Point a2, Point b1, Point b2)
{
    return Parallel(a1 - a2, b1 - b2);
}
bool Parallel(Segment s1, Segment s2)
{
    return equals(cross(s1.p2 - s1.p1, s2.p2 - s2.p1), 0.0);
}
//直線sに対して点ｐから垂線を引いたときの交点x(直線sに対する点pの射影)を求める
Point Project(Line s, Point p)
{
    Vector base = s.p2 - s.p1, hypo = p - s.p1;
    double scalar = (dot(base, hypo) / norm(base));
    return s.p1 + base * scalar;
}
//直線sに対して点pと線対称の位置にある点p'を求める
Point Reflect(Line s, Point p)
{
    return p + (Project(s, p) - p) * 2.0;
}
//点と点の距離
double GetDist(Point a, Point b)
{
    return abs(a - b);
}
//直線と点の距離
double GetDistLP(Line l, Point p)
{
    return abs(Project(l, p) - p);
}
//線分と点の距離
double GetDistSP(Segment s, Point p)
{
    if (dot(s.p2 - s.p1, p - s.p1) < 0.0)
        return abs(p - s.p1);
    if (dot(s.p1 - s.p2, p - s.p2) < 0.0)
        return abs(p - s.p2);
    return GetDistLP(s, p);
}
//Counter-Clockwise(AOJ:CGL_1_Cより)
static const int COUNTER_CLOCKWISE = 1; //反時計回り
static const int CLOCKWISE = -1;        //時計回り
static const int ONLINE_BACK = 2;       //線分の後ろにある
static const int ONLINE_FRONT = -2;     //線分の前にある
static const int ON_SEGMENT = 0;        //線分上にある
//線分p0p1と点p2の位置関係を求める
int CCW(Point p0, Point p1, Point p2)
{
    Vector a = p1 - p0, b = p2 - p0; //a:p0->p1,b:p0->p2
    if (cross(a, b) > EPS)
        return COUNTER_CLOCKWISE; //外積が正なら反時計回り(sinθ>0)
    if (cross(a, b) < -EPS)
        return CLOCKWISE; //外積が負なら時計回り(sinθ<0)
    if (dot(a, b) < -EPS)
        return ONLINE_BACK; //外積が0かつ内積が負(cosθ<0)
    if (a.norm() < b.norm())
        return ONLINE_FRONT; //p2がp0p1に含まれないときp0p2=p0p1+p1p2となり|a|^2<|b|^2が成立
    return ON_SEGMENT;       //最後にp0p2p1が残る
}
//2本の線分の交差判定(点と線分で2種類用意)
bool Intersect(Point p1, Point p2, Point p3, Point p4)
{
    return (CCW(p1, p2, p3) * CCW(p1, p2, p4) <= 0 && CCW(p3, p4, p1) * CCW(p3, p4, p2) <= 0);
}
bool Intersect(Segment s1, Segment s2)
{
    return Intersect(s1.p1, s1.p2, s2.p1, s2.p2);
}
//線分と線分の距離
double GetDist(Segment s1, Segment s2)
{
    //線分が交差していた場合、距離は0.0
    if (Intersect(s1, s2))
        return 0.0;
    return min(min(GetDistSP(s1, s2.p1), GetDistSP(s1, s2.p2)), min(GetDistSP(s2, s1.p1), GetDistSP(s2, s1.p2)));
}
//座標cを中心とする半径rの円を表わす構造体
struct Circle
{
public:
    Point c;
    double r;
    Circle(Point _c, double _r) : c(_c), r(_r) {}
};

//多角形は点の列として扱う
typedef vector<Point> Polygon;
int main()
{
    cout << fixed << setprecision(30);
    /*
    double a1, a2, b1, b2;
    cin >> a1 >> a2 >> b1 >> b2;
    Point p1(a1, a2), p2(b1, b2);
    Segment s(p1, p2);
    */
    ll q;
    cin >> q;
    loop(i, q)
    {
        vector<double> p(8);
        loop(j, 8) cin >> p[j];
        Point p1(p[0], p[1]), p2(p[2], p[3]);
        Point p3(p[4], p[5]), p4(p[6], p[7]);
        Segment s1(p1, p2), s2(p3, p4);
        putout(GetDist(s1, s2));
    }
    return 0;
}


Measured memory_bytes: 3296