#include<iostream>
#include<algorithm>
#include<cmath>
#include<iomanip>
using namespace std;

static const int COUNTER_CLOCKWISE = 1; //??????????????¨??????
static const int CLOCKWISE = -1;
static const int ON_SEGMENT = 0;
static const int ONLINE_FRONT = 2;
static const int ONLINE_BACK = -2;
const double EPS = 1e-10;

bool equals(double a, double b) {
	return fabs(a - b) < EPS;
}

class Point {
public:
	double x, y;

	Point(double x = 0, double y = 0): x(x), y(y) {}

	Point operator + (Point p) {
		return Point(x + p.x, y + p.y);
	}
	Point operator - (Point p) {
		return Point(x - p.x, y - p.y);
	}
	Point operator * (double k) {
		return Point(k * x, k * y);
	}
	Point operator / (double k) {
		return Point(x / k, y / k);
	}

	double norm() {
		return x * x + y * y;
	}
	double abs() {
		return sqrt(norm());
	}

	bool operator < (const Point &p) const {
		return x != p.x ? x < p.x : y < p.y;
	}

	bool operator == (const Point &p) const {
		return fabs(x - p.x) < EPS && fabs(y - p.y) < EPS;
	}
};

typedef Point Vector;

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;
}

class Segment {
public:
	Point p1, p2;
	Segment(Point p1, Point p2): p1(p1), p2(p2) {};

	Point project(Point p) {
		Vector a = Vector(p.x - p1.x, p.y - p1.y);
		Vector b = Vector(p2.x - p1.x, p2.y - p1.y);
		return p1 + p2 * (dot(a, b) / b.norm());
	}

	Point refrect(Point p) {
		Point pro = project(p);
		return pro * 2 - p;
	}

	double distance(Point p) {
		Vector a = Vector((p - p1).x, (p - p1).y);
		Vector b = Vector((p2 - p1).x, (p2 - p1).y);
		Vector c = Vector((p - p2).x, (p - p2).y);
		Vector d = Vector((p1 - p2).x, (p1 - p2).y);
		if (dot(a, b) < 0) return (p - p1).abs();
		else if (dot(c, d) < 0) return (p - p2).abs();
		else return fabs(cross(a, b)) / b.abs();
	}
};

int check(Vector v0, Vector v1) { 
	double c = cross(v0, v1);
	if (equals(c, 0)) {
		if (dot(v0, v1) < 0) return ONLINE_BACK;
		else if (v1.norm() > v0.norm()) return ONLINE_FRONT;
		else return ON_SEGMENT;
	} else if (c > 0) {
		return COUNTER_CLOCKWISE;
	} else {
		return CLOCKWISE;
	}
}

int intersect(Segment s1, Segment s2) { 
	Point p1 = s1.p1, p2 = s1.p2, p3 = s2.p1, p4 = s2.p2;
	Vector v0 = Vector((p2 - p1).x, (p2 - p1).y);
	Vector v1 = Vector((p3 - p1).x, (p3 - p1).y);
	Vector v2 = Vector((p4 - p1).x, (p4 - p1).y);
	Vector v3 = Vector((p4 - p3).x, (p4 - p3).y);
	Vector v4 = Vector((p1 - p3).x, (p1 - p3).y);
	Vector v5 = Vector((p2 - p3).x, (p2 - p3).y);
	if (check(v0, v1) * check(v0, v2) <= 0 && check(v3, v4) * check(v3, v5) <= 0) return 1;
	return 0;
}

double sDistance(Segment s1, Segment s2) {
	Point p1 = s1.p1, p2 = s1.p2, p3 = s2.p1, p4 = s2.p2;
	if (intersect(s1, s2)) return 0;
	double d1 = s1.distance(p3);
	double d2 = s1.distance(p4);
	double d3 = s2.distance(p1);
	double d4 = s2.distance(p2);
	return min(min(d1, d2), min(d3, d4));
}

int main() {
	int q;
	cin >> q;
	int x0, y0, x1, y1, x2, y2, x3, y3;
	for (int i = 0; i < q; i++) {
		cin >> x0 >> y0 >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
		Segment s1 = Segment(Point(x0, y0), Point(x1, y1));
		Segment s2 = Segment(Point(x2, y2), Point(x3, y3));
		cout << fixed << setprecision(10) << sDistance(s1, s2) << endl;
	}
	return 0;
}

Measured memory_bytes: 1240