#include <bits/stdc++.h>
using namespace std;
using namespace placeholders;
using LL = long long;
using ULL = unsigned long long;
using VI = vector<int>;
using VVI = vector<vector<int> >;
using VS = vector<string>;
using ISS = istringstream;
using OSS = ostringstream;
using PII = pair<int, int>;
using VPII = vector<pair<int, int> >;
template <typename T = int>
using VT = vector<T>;
template <typename T = int>
using VVT = vector<vector<T> >;
template <typename T = int>
using LIM = numeric_limits<T>;
template <typename T = int>
using OSI = ostream_iterator<T>;
template <typename T>
inline istream &operator>>(istream &s, vector<T> &v) {
  for (T &t : v) {
    s >> t;
  }
  return s;
}
template <typename T>
inline ostream &operator<<(ostream &s, const vector<T> &v) {
  for (int i = 0; i < int(v.size()); ++i) {
    s << (" " + !i) << v[i];
  }
  return s;
}
void in_impl(){};
template <typename T, typename... TS>
void in_impl(T &head, TS &...tail) {
  cin >> head;
  in_impl(tail...);
}
template <typename T>
inline T fromString(const string &s) {
  T res;
  istringstream iss(s);
  iss >> res;
  return res;
}
template <typename T>
inline string toString(const T &a) {
  ostringstream oss;
  oss << a;
  return oss.str();
}
template <typename T>
inline bool chmin(T &a, const T &b) {
  if (b < a) {
    a = b;
    return true;
  }
  return false;
}
template <typename T>
inline bool chmax(T &a, const T &b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
class MinimumCostFlow {
 private:
  struct Edge {
    int to, cap, rev;
    LL cost;
    Edge(int t, LL c, int d, int r) : to(t), cap(c), cost(d), rev(r) {}
  };
  const int V;
  vector<vector<Edge> > G;

 public:
  MinimumCostFlow(int v) : V(v), G(V){};
  void connect(int from, int to, int cap, int cost) {
    G[from].push_back(Edge(to, cap, cost, G[to].size()));
    G[to].push_back(Edge(from, 0, -cost, G[from].size() - 1));
    return;
  }
  LL solve(int s, int t, int f) {
    LL res = 0;
    vector<LL> h(V, 0), prevv(V), preve(V);
    while (0 < f) {
      vector<LL> distance(V, LLONG_MAX / 4);
      distance[s] = 0;
      priority_queue<pair<LL, int>, vector<pair<LL, int> >,
                     greater<pair<LL, int> > >
          que;
      que.push(make_pair(0, s));
      while (!que.empty()) {
        int d = que.top().first;
        int v = que.top().second;
        que.pop();
        if (distance[v] < d) {
          continue;
        }
        for (int i = 0; i < (int)G[v].size(); ++i) {
          Edge &e = G[v][i];
          if (0 < e.cap &&
              distance[v] + e.cost + h[v] - h[e.to] < distance[e.to]) {
            distance[e.to] = distance[v] + e.cost + h[v] - h[e.to];
            prevv[e.to] = v;
            preve[e.to] = i;
            que.push(make_pair(distance[e.to], e.to));
          }
        }
      }
      if (distance[t] == LLONG_MAX / 4) {
        cout << "TEST" << endl;
        return -1;
      }
      for (int i = 0; i < V; ++i) {
        h[i] += distance[i];
      }
      LL d = f;
      for (int v = t; v != s; v = prevv[v]) {
        d = min<LL>(d, G[prevv[v]][preve[v]].cap);
      }
      f -= d;
      res += d * h[t];
      for (int v = t; v != s; v = prevv[v]) {
        Edge &e = G[prevv[v]][preve[v]];
        e.cap -= d;
        G[v][e.rev].cap += d;
      }
    }
    return res;
  }
  int solve2(const int s, const int t, int f) {
    const int INF = INT_MAX / 2;
    int res = 0;
    while (f > 0) {
      vector<int> dist(V, INF);
      dist[s] = 0;
      vector<int> prevv(V), preve(V);
      bool update = true;
      while (update) {
        update = false;
        for (int v = 0; v < V; v++) {
          if (dist[v] == INF) {
            continue;
          }
          for (int i = 0; i < (int)G[v].size(); i++) {
            Edge &e = G[v][i];
            if (e.cap > 0 && dist[e.to] > dist[v] + e.cost) {
              dist[e.to] = dist[v] + e.cost;
              prevv[e.to] = v;
              preve[e.to] = i;
              update = true;
            }
          }
        }
      }
      if (dist[t] == INF) {
        return -1;
      }
      int d = f;
      for (int v = t; v != s; v = prevv[v]) {
        d = min(d, G[prevv[v]][preve[v]].cap);
      }
      f -= d;
      res += d * dist[t];
      for (int v = t; v != s; v = prevv[v]) {
        Edge &e = G[prevv[v]][preve[v]];
        e.cap -= d;
        G[v][e.rev].cap += d;
      }
    }
    return res;
  }
};
LL solve() {
  int N;
  in_impl(N);
  ;
  VI K(N), L(N), R(N);
  for (int i = (int)(0); i < (int)(N); ++i) {
    cin >> K[i] >> L[i] >> R[i];
    --K[i];
  }
  MinimumCostFlow mcflow(4 * N + 2);
  const int SRC = 4 * N;
  const int SINK = SRC + 1;
  for (int i = (int)(0); i < (int)(N); ++i) {
    mcflow.connect(SRC, i, 1, 0);
    mcflow.connect(i, N + K[i], 1, -L[i]);
    if (K[i] + 1 < N) {
      mcflow.connect(i, 2 * N + K[i] + 1, 1, -R[i]);
    }
    if (i) {
      mcflow.connect(N + i, N + i - 1, N, 0);
    }
    if (i + 1 < N) {
      mcflow.connect(2 * N + i, 2 * N + i + 1, N, 0);
    }
    mcflow.connect(N + i, 3 * N + i, 1, 0);
    mcflow.connect(2 * N + i, 3 * N + i, 1, 0);
    mcflow.connect(3 * N + i, SINK, 1, 0);
  }
  return -mcflow.solve(SRC, SINK, N);
}
int main() {
  cin.tie(0);
  ios::sync_with_stdio(false);
  cout << setprecision(12) << fixed;
  int T;
  in_impl(T);
  ;
  for (int REP_COUNTER_249 = (int)(0); REP_COUNTER_249 < (int)(T);
       ++REP_COUNTER_249) {
    cout << solve() << '\n';
  }
  cout << flush;
  return 0;
}
