#include<bits/stdc++.h>
using namespace std;

typedef long long ll;
        
constexpr int MOD = 1e9 + 7;

struct mint{
    int val;
    mint(ll x = 0){
        while(x < 0) x += MOD;
        val = x % MOD;
    }
    mint pow(long long b) const{
        mint res = 1;
        mint a = mint(val);
        for ( ; b; b >>= 1, a *= a){
            if(b & 1)res *= a;
        }
        return mint(res);
    }
    mint operator - () const{
        return mint((MOD - val) % MOD);
    }
    mint inv() const{
        return this -> pow(MOD - 2);
    }
    mint &operator += (const mint &rhs){
        val = (0ll + val + rhs.val) % MOD;
        return *this;
    }
    mint &operator ++ (int null){
        return *this += 1;
    }
    mint &operator -= (const mint &rhs){
        val = (MOD + val - rhs.val) % MOD;
        return *this;
    }
    mint &operator *= (const mint &rhs){
        val = 1ll * val * rhs.val % MOD;
        return *this;
    }
    mint &operator /= (const mint &rhs){
        return *this *= rhs.inv();
    }
    bool operator == (const mint &rhs){
        return this -> val == rhs.val;
    }
    bool operator != (const mint &rhs){
        return !(*this == rhs);
    }
    friend mint operator + (const mint &lhs, const mint &rhs){
        mint res = lhs;
        return res += rhs;
    } 
    friend mint operator - (const mint &lhs, const mint &rhs){
        mint res = lhs;
        return res -= rhs;
    }
    friend mint operator * (const mint &lhs, const mint &rhs){
        mint res = lhs;
        return res *= rhs;
    }
    friend mint operator / (const mint &lhs, const mint &rhs){
        mint res = lhs;
        return res /= rhs;
    }
    friend mint operator + (const mint &lhs, const ll &rhs){
        mint res = lhs;
        return res += mint(rhs);
    } 
    friend mint operator - (const mint &lhs, const ll &rhs){
        mint res = lhs;
        return res -= mint(rhs);
    }
    friend mint operator * (const mint &lhs, const ll &rhs){
        mint res = lhs;
        return res *= mint(rhs);
    }
    friend mint operator / (const mint &lhs, const ll &rhs){
        mint res = lhs;
        return res /= mint(rhs);
    } 
    friend istream &operator >> (istream &is, mint &a){
        ll v;
        is >> v;
        a = mint(v);
        return is;
    }
    friend ostream &operator << (ostream &os, const mint &a){
        return os << a.val;
    }
    mint sqrt(){
        mint a = 1;
        while((a * a - *this).pow((MOD - 1) / 2) != mint(-1))a++;
        mint real = 1, imagin = 0;
        mint l = a, r = 1;
        for(int n = (MOD + 1) >> 1; n; n >>= 1){
            if(n & 1){
                mint tmpl = real * l + imagin * r * (a * a - *this);
                mint tmpr = real * r + l * imagin;
                real = tmpl, imagin = tmpr;
            }
            mint tmpl = l * l + r * r * (a * a - *this);
            mint tmpr = l * r * 2;
            l = tmpl, r = tmpr;
        }
        assert(imagin.val == 0);
        return real;
    }
};

vector<mint> fac(1, 1), invfac(1, 1);

mint C(int n, int m){
    if(n < 0 || m < 0 || n < m)return 0;
    while(fac.size() < n + 1){
        fac.push_back(fac.back() * int(fac.size()));
        invfac.push_back(1 / fac.back());
    }
    return fac[n] * invfac[m] * invfac[n - m];
}

mint A(int n, int m){
    if(n < 0 || m < 0 || n < m)return 0;
    while(fac.size() < n + 1){
        fac.push_back(fac.back() * int(fac.size()));
        invfac.push_back(1 / fac.back());
    }
    return fac[n] * invfac[n - m];
}
    
void solve(){
    int n;
    cin >> n;

    vector<int> a(n);
    for(int i = 0; i < n; i++){
        cin >> a[i];
    }

    if(a[0] != 0 || a[n - 1] != n - 1){
        cout << 0 << "\n";
        return;
    }

    mint ans = 1;

    for(int i = 1; i < n; i++){
        if(a[i] != a[i - 1])ans *= 2;
        else ans *= i + 1 - a[i];
    }

    cout << ans << "\n";
    return;
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int t;
    cin >> t;
    while(t--)solve();
    return 0;
}