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

#define int long long

template<class T>bool chkmax(T &a,T b){return b>a?a=b,true:false;}
template<class T>bool chkmin(T &a,T b){return b<a?a=b,true:false;}

constexpr int inf=2e18;

template<const int mod>
struct modint{
	int x;
	modint(int x=0):x(norm(x%mod)){}
	int val()const{
		return x;
	}
	modint operator-()const{
		return modint(norm(mod-x));
	}
	int norm(int x)const{
		if(x<0) x+=mod;
		if(x>=mod) x-=mod;
		return x;
	}
	modint pow(int x)const{
		modint res=1;
		modint cur=*this;
		while(x){
			if(x&1){
				res*=cur;
			}
			cur*=cur;
			x/=2;
		}
		return res;
	}
	modint inv()const{
		assert(x!=0);
		return pow(mod-2);
	}
	modint &operator*=(const modint &rhs){
		x=(long long)(x)*rhs.x%mod;
		return *this;
	}
	modint &operator+=(const modint &rhs){
		x=norm(x+rhs.x);
		return *this;
	}
	modint &operator-=(const modint &rhs){
		x=norm(x-rhs.x);
		return *this;
	}
	modint &operator/=(const modint &rhs){
		return *this*=rhs.inv();
	}
	friend modint operator*(const modint &lhs,const modint &rhs){
		modint res=lhs;
		res*=rhs;
		return res;
	}
	friend modint operator+(const modint &lhs,const modint &rhs){
		modint res=lhs;
		res+=rhs;
		return res;
	}
	friend modint operator-(const modint &lhs,const modint &rhs){
		modint res=lhs;
		res-=rhs;
		return res;
	}
	friend modint operator/(const modint &lhs,const modint &rhs){
		modint res=lhs;
		res/=rhs;
		return res;
	}
	friend istream &operator>>(istream &is,modint &a){
		long long v;
		is>>v;
		a=modint(v);
		return is;
	}
	friend ostream &operator<<(ostream &os,const modint &a){
		return os<<a.val();
	}
	friend bool operator==(const modint &lhs,const modint &rhs){
		return lhs.val()==rhs.val();
	}
	friend bool operator!=(const modint &lhs,const modint &rhs){
		return lhs.val()!=rhs.val();
	}
};

using Mint=modint<(int)1e9+7>;

struct SegmentTree{
	#define ls (p<<1)
	#define rs (p<<1|1)
	#define mid (tr[p].l+tr[p].r)/2
	struct node{
		int l,r;
		Mint val;
		Mint tag;
		bool f;
	};
	vector<node>tr;
	SegmentTree(int n):tr(4*n){
		function<void(int,int,int)>build=[&](int p,int l,int r){
			tr[p].l=l,tr[p].r=r;
			tr[p].val=0;
			tr[p].tag=0;
			tr[p].f=false;
			if(l==r){
				return;
			}
			build(ls,l,mid);
			build(rs,mid+1,r);
		};
		build(1,0,n-1);
	}
	void pushup(int p){
		tr[p].val=tr[ls].val+tr[rs].val;
	}
	void pushdown(int p){
		if(tr[p].f){
			tr[ls].val=tr[p].tag*(tr[ls].r-tr[ls].l+1);
			tr[rs].val=tr[p].tag*(tr[rs].r-tr[rs].l+1);
			tr[ls].tag=tr[p].tag;
			tr[rs].tag=tr[p].tag;
			tr[ls].f=true;
			tr[rs].f=true;
			tr[p].f=false;
		}
	}
	void update(int p,int l,int r,Mint x){
		if(l<=tr[p].l&&tr[p].r<=r){
			tr[p].val=x*(tr[p].r-tr[p].l+1);
			tr[p].tag=x;
			tr[p].f=true;
			return;
		}
		pushdown(p);
		if(l<=mid){
			update(ls,l,r,x);
		}
		if(mid<r){
			update(rs,l,r,x);
		}
		pushup(p);
	}
	void update(int l,int r,Mint x){
		update(1,l,r,x);
	}
	void update(int i,Mint x){
		update(i,i,x);
	}
	Mint query(int p,int l,int r){
		if(l<=tr[p].l&&tr[p].r<=r){
			return tr[p].val;
		}
		pushdown(p);
		Mint res=0;
		if(l<=mid){
			res+=query(ls,l,r);
		}
		if(mid<r){
			res+=query(rs,l,r);
		}
		return res;
	}
	Mint query(int l,int r){
		return query(1,l,r);
	}
	Mint query(int i){
		return query(i,i);
	}
	#undef ls
	#undef rs
	#undef mid
};

void solve(){
	int n,m;
	cin>>n>>m;
	vector<vector<pair<int,int>>>con(n);
	for(int i=0;i<m;i++){
		int l,r,x;
		cin>>l>>r>>x;
		l--,r--;
		con[r].emplace_back(l,x);
	}
	for(auto[l,x]:con[0]){
		if(x>1){
			cout<<"0\n";
			return;
		}
	}
	vector<SegmentTree>dp1(n+2,SegmentTree(n+2)),dp2(n+2,SegmentTree(n+2));
	dp1[-1+2].update(-2+2,3);
	dp2[-2+2].update(-1+2,3);
	for(int i=0;i<n-1;i++){
		int l_j=-inf,r_j=inf;
		int l_k=-inf,r_k=inf;
		for(auto[l,x]:con[i+1]){
			if(x==1){
				chkmin(r_j,l-1);
			}
			else if(x==2){
				chkmax(l_j,l);
				chkmin(r_k,l-1);
			}
			else{
				chkmax(l_k,l);
			}
		}
		vector<Mint>add(i+2);
		for(int j=-2;j<i;j++){
			add[j+2]=dp1[j+2].query(0,n+1)+dp2[j+2].query(0,n+1);
		}
		for(int j=-2;j<i;j++){
			dp1[i+2].update(j+2,dp1[i+2].query(j+2)+add[j+2]);
			dp2[j+2].update(i+2,dp2[j+2].query(i+2)+add[j+2]);
		}
		for(int j=-2;j<n;j++){
			if(l_j<=j&&j<=r_j){
				if(l_k-1+2>=0) dp1[j+2].update(0,l_k-1+2,0);
				if(r_k+1+2<=n+1) dp1[j+2].update(r_k+1+2,n+1,0);
			}
			else{
				dp1[j+2].update(0,n+1,0);
			}
		}
		for(int k=-2;k<n;k++){
			if(l_k<=k&&k<=r_k){
				if(l_j-1+2>=0) dp2[k+2].update(0,l_j-1+2,0);
				if(r_j+1+2<=n+1) dp2[k+2].update(r_j+1+2,n+1,0);
			}
			else{
				dp2[k+2].update(0,n+1,0);
			}
		}
	}
	Mint ans=0;
	for(int j=-1;j<n-1;j++){
		ans+=dp1[j+2].query(0,n+1);
	}
	cout<<ans<<"\n";
}

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