//#pragma GCC optimize("O3")
//#pragma GCC optimize("unroll-loops")
//#pragma GCC target("avx2") // doesn't work on Yandex
//#pragma GCC target("avx") // for old judges
//#pragma GCC target("bmi,bmi2,lzcnt,popcnt") // fast bit operations

#include <iostream>
#include <iomanip>
#include <vector>
#include <set>
#include <map>
#include <unordered_map>
#include <queue>
#include <deque>
#include <cmath>
#include <algorithm>
#include <cassert>
#include <chrono>
#include <random>
#include <string>
#include <numeric>
#include <complex>
#include <tuple>
#include <utility>
#include <bitset>
#include <array>
#include <stack>
#include <sstream>
#include <unordered_set>

using namespace std;
typedef long long ll;

string to_string(string a) { return '"' + a + '"'; }
string to_string(char a) { return "'" + string(1, a) + "'"; }
string to_string(const char* a) { return to_string((string) a); }
string to_string(bool a) { return a ? "true" : "false"; }
template <class T1, class T2>
string to_string(pair<T1, T2> a) {
    return "(" + to_string(a.first) + ", " + to_string(a.second) + ")";
}
template <class T>
string to_string(T a) {
    bool first = true; string res = "{";
    for (const auto& i : a) {
        if (!first) res += ", ";
        first = false;
        res += to_string(i);
    }
    res += "}";
    return res;
}
void debug_out() { cerr << endl; }
template <class T1, class... T2>
void debug_out(T1 a, T2... b) {
    cerr << " " << to_string(a);
    debug_out(b...);
}

#ifdef LOCAL
#define out(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define out(...) 42
#endif

clock_t start_time; void start_timer() { start_time = clock(); }
double get_time() { return (double) (clock() - start_time) / CLOCKS_PER_SEC; }

void Solve();

int main() {
    ios_base::sync_with_stdio(0); cin.tie(0);
#ifdef LOCAL
    freopen("usr/share/man/man1/input.txt", "r", stdin);
#endif
    start_timer();
    Solve();
#ifdef LOCAL
    cerr << fixed << setprecision(3);
    cerr << endl << "Time spent: " << get_time() << endl;
#endif
    return 0;
}

// do something, stay focused
// look for stupid bugs
// guess, slow, stress
// don't overgeneralize
// don't rush

// don't waste time on standings

// SOLVE THE PROBLEM OR DIE TRYING
// THE SOLUTION IS ALWAYS SIMPLE
// THE CODE IS ALWAYS SHORT

const int N = 2e5 + 5;
const ll inf = 1e18;

vector<pair<int, ll>> g[2][N];
pair<int, ll> par[N];
bool reach[N];

void add_e(int u, int v, ll w) {
    g[0][u].push_back({v, w});
    g[1][v].push_back({u, w});
}

void dfs(int u, int x) {
    reach[u] = 1;
    for (auto [v, w] : g[0][u]) {
        if (v == x) continue;
        if (reach[v]) continue;
        if (par[v].first == u) {
            dfs(v, x);
        }
    }
}

void Solve() {
    int T;
    cin >> T;
    while (T--) {
        int n, m;
        cin >> n >> m;
        for (int i = 1; i <= n; i++) {
            g[0][i].clear();
            g[1][i].clear();
            par[i] = {0, 0};
            reach[i] = 0;
        }
        int x = 0;
        int y = 0;
        ll wxy = 0;
        for (int i = 1; i <= m; i++) {
            int u, v;
            ll w;
            cin >> u >> v >> w;
            if (u < v) {
                add_e(u, v, w);
            }
            else {
                x = v;
                y = u;
                wxy = w;
            }
        }
        ll ans_def = 0;
        for (int v = 2; v <= n; v++) {
            ll mn = inf;
            int who = 0;
            for (auto [u, w] : g[1][v]) {
                if (w < mn) {
                    mn = w;
                    who = u;
                }
            }
            par[v] = {who, mn};
            ans_def += mn;
        }
        ll ans_alt = inf;
        if (x != 1) {
            ans_alt = ans_def - par[x].second + wxy;
            dfs(1, x);
            if (!reach[y]) {
                ll rest = ans_alt;
                ans_alt = inf;
                vector<int> path;
                int ptr = y;
                while (ptr != x) {
                    path.push_back(ptr);
                    ptr = par[ptr].first;
                }
                for (int v : path) {
                    ll mn = inf;
                    for (auto [u, w] : g[1][v]) {
                        if (reach[u] && w < mn) {
                            mn = w;
                        }
                    }
                    if (mn == inf) continue;
                    ll ans_cur = rest - par[v].second + mn;
                    ans_alt = min(ans_alt, ans_cur);
                }
            }
        }
        ll ans = min(ans_def, ans_alt);
        cout << ans << "\n";
    }
}