#include<bits/stdc++.h>
using namespace std;
#define int int64_t
const int nax = 3e5 + 10;
const int INF = 1e12;

int n;
int a[nax];

struct Node {
    int f[2][2];

    Node(int i = 0) : f{} {
        f[0][0] = a[i]; /**no segment outside i*/
        f[0][1] = a[i] + a[i + 1];     /** segments covered i-> goto i + 1, we will used left-based and consider only left value*/
        f[1][0] =  -INF;     /** as previously mentioned, we will consider only left-based cover*/
        f[1][1] = INF; /**impossible scenarion*/
    }

    int *operator [](int r) {
        return f[r];
    }

    Node operator +(Node &other) {
        Node res;

//        cout << "A ";
//        for (int x = 0 ; x < 2 ; ++ x, cout << '\n')
//        for (int y = 0 ; y < 2 ; ++ y) cout << f[x][y] << ' ';
//        cout << '\n';
//        cout << "B ";
//        for (int x = 0 ; x < 2 ; ++ x, cout << '\n')
//        for (int y = 0 ; y < 2 ; ++ y) cout << other[x][y] << ' ';
//        cout << '\n';
        for (int x = 0 ; x < 2 ; ++ x)
        for (int y = 0 ; y < 2 ; ++ y) {
            res[x][y] = INF;
            for (int k = 0 ; k < 2 ; ++ k) {
                res[x][y] = min(res[x][y], max(f[x][k], other[k][y]));
            }
        }
//        cout << "B ";
//        for (int x = 0 ; x < 2 ; ++ x, cout << '\n')
//        for (int y = 0 ; y < 2 ; ++ y) cout << res[x][y] << ' ';
//        cout << '\n';
//        cout << endl;
        return res;
    }
}sg[nax << 2];


void pull(int v) {
    sg[v] = sg[v << 1] + sg[v << 1 | 1];
}

void build(int v, int x, int y) {
    if (x == y) {
        sg[v] = Node(x);
        return;
    }
    int mid = x + y >> 1;
    build(v << 1, x, mid);
    build(v << 1 | 1, mid + 1, y);
    pull(v);
}

void update(int v, int x, int y, int pos, int len) {
    if (x == y) {
        sg[v][0][len] = INF; /// this will baned the values for being used
        return;
    }

    int mid = (x + y) >> 1;
    if (pos <= mid) update(v << 1, x, mid, pos, len);
    else update(v << 1 | 1, mid + 1, y, pos, len);
    pull(v);
}

void solve() {
    cin >> n;
    for (int i = 1 ; i <= n ; ++ i) {
        cin >> a[i];
    }

    build(1, 1, n);

    vector <array <int, 3>> all;

    for (int i = 1 ; i <= n ; ++ i) {
        all.push_back({a[i], i, 0});
        if (i + 1 <= n) all.push_back({a[i] + a[i + 1], i, 1});
    }
    sort(begin(all), end(all));

    int ans = INF;

    for (auto [k, pos, len] : all) {
        ans = min(ans, sg[1][0][0] - k);
//        cout << sg[1][0][0] << endl;
        update(1, 1, n , pos, len);
//        cout << pos << ' ' << len << endl;
    }

    cout << ans << '\n';


}

int32_t main() {
    cin.tie(0)->sync_with_stdio(false);

    int T;

    for (cin >> T ; T -- ;) {
        solve();
    }
}