// 
#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#define debug(...) fprintf(stderr, ##__VA_ARGS__)
#else
#define endl "\n"
#define debug(...) void(0)
#endif
typedef long long LL;
template <class T>
using must_int = enable_if_t<is_integral<T>::value, int>;
template <unsigned umod>
struct modint {
  static constexpr int mod = umod;
  unsigned v;
  modint() : v(0) {}
  template <class T, must_int<T> = 0>
  modint(T x) {
    x %= mod;
    v = x < 0 ? x + mod : x;
  }
  modint operator+() const { return *this; }
  modint operator-() const { return modint() - *this; }
  friend int raw(const modint &self) { return self.v; }
  friend ostream& operator<<(ostream& os, const modint &self) { 
    return os << raw(self); 
  }
  modint &operator+=(const modint &rhs) {
    v += rhs.v;
    if (v >= umod) v -= umod;
    return *this;
  }
  modint &operator-=(const modint &rhs) {
    v -= rhs.v;
    if (v >= umod) v += umod;
    return *this;
  }
  modint &operator*=(const modint &rhs) {
    v = 1ull * v * rhs.v % umod;
    return *this;
  }
  modint &operator/=(const modint &rhs) {
    assert(rhs.v);
    return *this *= qpow(rhs, mod - 2);
  }
  template <class T, must_int<T> = 0>
  friend modint qpow(modint a, T b) {
    modint r = 1;
    for (; b; b >>= 1, a *= a)
      if (b & 1) r *= a;
    return r;
  }
  friend modint operator+(modint lhs, const modint &rhs) { return lhs += rhs; }
  friend modint operator-(modint lhs, const modint &rhs) { return lhs -= rhs; }
  friend modint operator*(modint lhs, const modint &rhs) { return lhs *= rhs; }
  friend modint operator/(modint lhs, const modint &rhs) { return lhs /= rhs; }
  bool operator==(const modint &rhs) const { return v == rhs.v; }
  bool operator!=(const modint &rhs) const { return v != rhs.v; }
};
typedef modint<int(1e9 + 7)> mint;
int n, m, L[5010], R[5010];
vector<int> buc[5010][4];
mint a[5010][5010], cs[5010], ls[5010];
int mian() {
  cin >> n >> m;
  n += 2;
  fill(cs, cs + n + 1, 0);
  fill(ls, ls + n + 1, 0);
  for (int i = 1; i <= n; i++) {
    fill(a[i], a[i] + n + 1, 0);
    for (auto& c : buc[i]) c.clear();
  }
  for (int i = 1; i <= m; i++) {
    int l, r, c;
    cin >> l >> r >> c;
    l += 2, r += 2;
    buc[r][c].push_back(l);
  }
  L[1] = 1, R[1] = 0;
  a[1][0] = ls[1] = cs[0] = 1, L[1] = R[1] = 0;
  for (int i = 3; i <= n; i++) {
    for (int k = 0; k < i - 1; k++) a[i - 1][k] = cs[k] + ls[k];
    for (int k = 0; k < i - 1; k++) cs[k] += a[i - 1][k], ls[i - 1] += a[i - 1][k];
    L[i - 1] = 0, R[i - 1] = i;
    auto mine = [i](auto& c) { return c.empty() ? i : *min_element(c.begin(), c.end()); };
    auto maxe = [](auto& c) { return c.empty() ? 0 : *max_element(c.begin(), c.end()); };
    int rj = mine(buc[i][1]) - 1, lj = maxe(buc[i][2]);
    int rk = mine(buc[i][2]) - 1, lk = maxe(buc[i][3]);
    debug("i = %d, j in [%d, %d], k in [%d, %d]\n", i - 2, lj - 2, rj - 2, lk - 2, rk - 2);
    for (int j = 0; j < lj; j++) {
      while (L[j] <= R[j]) ls[j] -= a[j][L[j]], cs[L[j]] -= a[j][L[j]], ++L[j];
    }
    for (int j = rj + 1; j <= i; j++) {
      while (L[j] <= R[j]) ls[j] -= a[j][L[j]], cs[L[j]] -= a[j][L[j]], ++L[j];
    }
    for (int j = lj; j <= rj; j++) {
      while (L[j] < lk && L[j] <= R[j]) ls[j] -= a[j][L[j]], cs[L[j]] -= a[j][L[j]], ++L[j];
      while (R[j] > rk && L[j] <= R[j]) ls[j] -= a[j][R[j]], cs[R[j]] -= a[j][R[j]], --R[j];
    }
#ifdef LOCAL
    for (int j = 1; j <= i; j++) {
      for (int k = L[j]; k <= R[j]; k++) if (a[j][k] != 0) debug("dp[%d][%d][%d] = %d\n", i - 2, j - 2, k - 2, raw(a[j][k]));
    }
    assert(accumulate(ls, ls + n + 1, mint{}) == accumulate(cs, cs + n + 1, mint{}));
    debug("i = %d + 2, ans = %d now\n", i - 2, raw(accumulate(ls, ls + n + 1, mint{})));
#endif
  }
  cout << accumulate(ls + 1, ls + n + 1, mint{}) << endl;
  return 0;
}
int main() {
#ifndef LOCAL
  cin.tie(nullptr)->sync_with_stdio(false);  
#endif
  int t;
  cin >> t;
  while (t--) mian();
  return 0;
}