#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define MOD 1000000007
#define F first
#define S second
#define PB push_back
#define MP make_pair
#define FOR(i,a,b) for(int i=a;i<b;i++)
#define FORll(i,a,b) for(ll i=a;i<b;i++)
#define yes cout<<"YES\n";
#define no cout<<"NO\n";
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
#define fast_io ios::sync_with_stdio(0);cin.tie(0);
#define debug(x) for(auto k:x) cout<<k<<" ";cout<<"\n";
#define int long long
#define double long double
#define INF LLONG_MAX
#define endl "\n"
int gcd(int a,int b){if(b==0)return a;else return gcd(b,a%b);}
int lcm(int a,int b){return a*b/gcd(a,b);}
int power(int x, unsigned int y, unsigned int M)
{
    if (y == 0)
        return 1;
    int p = power(x, y / 2, M) % M;
    p = (p * p) % M;
    return (y % 2 == 0) ? p : (x * p) % M;
}
int modInverse(int A, int M)
{
    int g = gcd(A, M);
    if (g != 1)
        return -1;
    else {
       return power(A, M - 2, M);
    }
}
struct TreeNode{
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};
//DSU Data Structure for MST
class DSU{
private:
    vector<int> par;
    vector<int> siz;
public:
    DSU(int n){
        par.resize(n+1);
        siz.resize(n+1);
        for(int i=1;i<=n;i++){
            par[i] = i;
            siz[i] = 1;
        }
    }
    int get_leader(int u){
        if(par[u]==u) return u;
        // path compression -> O(n) to O(1) amortized
        return par[u] = get_leader(par[u]);
    }
    bool merge(int u,int v){
        u = get_leader(u);
        v = get_leader(v);
        if(u==v) return false;
        //union by rank
        if(siz[u]<siz[v]){
            siz[v] += siz[u];
            par[u] = v;
        }
        else{
            siz[u] += siz[v];
            par[v] = u;
        }
        return true;
    }
};
// --- code starts here ---
//to reverse sort use greater<int>()
//use "\n" instead of endl
//use INF , -INF for initialising
signed main(){
    //prob D
    fast_io;
    int t = 1;
    cin>>t;
    while(t--){
        int n;
        cin>>n;
        vector<int> a(n);
        for(auto &x: a){cin>>x;}
        // dp[i][j] -> num of good subsequences ending at index i such that
        // max value of any element in this subseq is j

        vector<vector<int>> dp(n,vector<int>(n+1,0));

        FOR(i, 0, n){
            dp[i][a[i]] = 1;
        }


        FOR(i, 0, n) {
            FOR(j, 1, n + 1) {
                FOR(k, i + 1, n) {
                    if (dp[i][j] == 0) continue;

                    if (a[k] >= a[i]) {
                        int new_max = max(j, a[k]);
                        dp[k][new_max] = (dp[k][new_max] + dp[i][j]) % MOD;
                    } else {
                        if (j == a[i] || a[k] >= j) {
                            int new_max = max(j, a[k]);
                            dp[k][new_max] = (dp[k][new_max] + dp[i][j]) % MOD;
                        }
                    }
                }
            }
        }
        int ans = 1;
        FOR(i, 0, n) {
            FOR(j, 1, n + 1) {
                // cout << i << " " << j << " : " << dp[i][j] << endl;
                ans = (ans + dp[i][j]) % MOD;
            }
        }
        cout << ans << endl;

    }
}