#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector,fast-math")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//#pragma comment(linker, "/stack:200000000")
 
#include <bits/stdc++.h>
 
using namespace std;
 
typedef long long ll;
typedef unsigned long long ull;
typedef double ld;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef pair<ld,ld> pdd;
 
#define X first
#define Y second
 
//#include <boost/unordered_map.hpp>
//using namespace boost;
 
/*
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> rbtree;
rbtree T;
*/
 
using i32 = int;
using i64 = long long;
using u8 = unsigned char;
using u32 = unsigned;
using u64 = unsigned long long;
using f64 = double;
using f80 = long double;
//using i128 = __int128_t;
//using u128 = __uint128_t;
//using i128 = i64;
//using u128 = u64;
 
ll power(ll a, ll b, ll p)
{
    if (!b) return 1;
    ll t = power(a, b/2, p);
    t = t*t%p;
    if (b&1) t = t*a%p;
    return t;
}
 
ll exgcd(ll a, ll b, ll &x, ll &y)
{
    if (b == 0)
    {
        x = 1;
        y = 0;
        return a;
    }
    ll px, py;
    ll d = exgcd(b, a%b, px, py);
    x = py;
    y = px-a/b*py;
    return d;
}
 
template<class T>
inline void freshmin(T &a, const T &b)
{
    if (a > b) a = b;
}
 
template<class T>
inline void freshmax(T &a, const T &b)
{
    if (a < b) a = b;
}

template<class T>
void print(const T &a)
{
    for (auto x : a) printf("%d ", x); puts("");
}

const int MAXN = 820;
const int MAXM = MAXN*MAXN;
const ld INF = 1e30;
//const int MOD = 998244353;
const int MOD = 2520;
const int INV2 = (MOD+1)/2;

int n;
struct node
{
    int x1, y1, x2, y2;
}e[MAXN];
vector<int> px, py;
int sx, sy, tx, ty;

void get_rank(int &x, const vector<int> &px)
{
    x = lower_bound(px.begin(), px.end(), x)-px.begin()+1;
}

int r, c;
int a[MAXN][MAXN];

int place(int x, int y)
{
    return (x-1)*c+y;
}

int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};

int N;
vector<pair<int, ld> > w[MAXM];

ld dis[MAXM];

ld solve(int S, int T)
{
    for (int i = 1; i <= N; ++ i)
        dis[i] = INF;
    dis[S] = 0;
    priority_queue<pair<ld, int>, vector<pair<ld, int>>, greater<pair<ld, int>>> Q;
    Q.push({0, S});
    while (!Q.empty())
    {
        int x = Q.top().Y;
        ld d = Q.top().X;
        Q.pop();
        if (dis[x] != d) continue;
        for (auto e : w[x])
        {
            int y = e.X;
            ld z = e.Y;
            if (dis[y] > d+z)
            {
                dis[y] = d+z;
                Q.push({dis[y], y});
            }
        }
    }
    return dis[T];
}

int main()
{
    
    int T;
    scanf("%d", &T);
    while (T --)
    {
        scanf("%d", &n);
        px.clear();
        py.clear();
        for (int i = 1; i <= n; ++ i)
        {
            scanf("%d%d%d%d", &e[i].x1, &e[i].y1, &e[i].x2, &e[i].y2);
            /*
            e[i].x1 *= 2;
            e[i].y1 *= 2;
            e[i].x2 *= 2;
            e[i].y2 *= 2;
            */
            px.push_back(e[i].x1);
            py.push_back(e[i].y1);
            px.push_back(e[i].x2);
            py.push_back(e[i].y2);
        }
        scanf("%d%d%d%d", &sx, &sy, &tx, &ty);
        px.push_back(sx);
        py.push_back(sy);
        px.push_back(tx);
        py.push_back(ty);
        sort(px.begin(), px.end());
        px.erase(unique(px.begin(), px.end()), px.end());
        sort(py.begin(), py.end());
        py.erase(unique(py.begin(), py.end()), py.end());
        r = px.size();
        c = py.size();
        for (int i = 0; i <= 2*r+1; ++ i)
            for (int j = 0; j <= 2*c+1; ++ j)
                a[i][j] = 0;
        for (int i = 1; i <= n; ++ i)
        {
            get_rank(e[i].x1, px);
            get_rank(e[i].y1, py);
            get_rank(e[i].x2, px);
            get_rank(e[i].y2, py);
            int x1 = e[i].x1*2, y1 = e[i].y1*2, x2 = e[i].x2*2, y2 = e[i].y2*2;
            a[x1][y1] ++;
            a[x1][y2+1] --;
            a[x2+1][y1] --;
            a[x2+1][y2+1] ++;
        }
        get_rank(sx, px);
        get_rank(sy, py);
        get_rank(tx, px);
        get_rank(ty, py);
        for (int i = 1; i <= 2*r; ++ i)
            for (int j = 1; j <= 2*c; ++ j)
                a[i][j] = a[i-1][j]+a[i][j-1]-a[i-1][j-1]+a[i][j];
        N = r*c;
        for (int i = 1; i <= N; ++ i)
            w[i].clear();
        for (int i = 1; i <= r; ++ i)
            for (int j = 1; j <= c; ++ j)
            {
                for (int k = 0; k < 4; ++ k)
                {
                    int x = i+dx[k], y = j+dy[k];
                    if (1 <= x && x <= r && 1 <= y && y <= c)
                    {
                        ld d = abs(px[x-1]-px[i-1])+abs(py[y-1]-py[j-1]);
                        int k = min({a[i*2][j*2], a[x*2][y*2], a[i+x][j+y]});
                        w[place(i, j)].push_back({place(x, y), d/(k+1)});
                    }
                }
            }
        ld ans = solve(place(sx, sy), place(tx, ty));
        printf("%.5f\n", ans);
    }
    
    return 0;
}