#include <bits/stdc++.h>
#define ll long long
#define re register
#define cs const

namespace IO {

inline char gc()
{
    static cs int Rlen = 1 << 22 | 1;
    static char buf[Rlen], *p1, *p2;
    return (p1 == p2) && (p2 = (p1 = buf) + fread(buf, 1, Rlen, stdin), p1 == p2) ? EOF : *p1++;
} template<typename T>T get_integer()
{
    char c;
    bool f = false;

    while (!isdigit(c = gc()))
        f = c == '-';

    T x = c ^ 48;

    while (isdigit(c = gc()))
        x = ((x + (x << 2)) << 1) + (c ^ 48);

    return f ? -x : x;
} inline int gi()
{
    return get_integer<int>();
}
inline ll gl()
{
    return get_integer<ll>();
}

} using namespace IO;

using std::cerr;
using std::cout;

template<typename T, typename BT>
void ckmx(T &a, cs BT &b)
{
    a < b ? a = b : a;
}

cs int N = 5e4 + 7, M = 1e5 + 7;

int n, m;
int el[N], nx[N + N], to[N + N], w[N + N], ec;
inline void adde(int u, int v, int vl)
{
    nx[++ec] = el[u], el[u] = ec, to[ec] = v, w[ec] = vl;
    nx[++ec] = el[v], el[v] = ec, to[ec] = u, w[ec] = vl;
}

int d[N], fa[N], top[N];
int son[N], sz[N], dfn[N], dfc;
ll len[N];
void dfs1(int u, int p)
{
    fa[u] = p, d[u] = d[p] + 1, sz[u] = 1, son[u] = 0;

    for (int re e = el[u]; e; e = nx[e])
        if (to[e] != p)
        {
            len[to[e]] = len[u] + w[e];
            dfs1(to[e], u);
            sz[u] += sz[to[e]];

            if (sz[to[e]] > sz[son[u]])
                son[u] = to[e];
        }
}

void dfs2(int u, int tp)
{
    top[u] = tp, dfn[u] = ++dfc;

    if (son[u])
        dfs2(son[u], tp);

    for (int re e = el[u]; e; e = nx[e])
        if (to[e] != fa[u] && to[e] != son[u])
            dfs2(to[e], to[e]);
}

int LCA(int u, int v)
{
    while (top[u] != top[v])
        d[top[u]] > d[top[v]] ? u = fa[top[u]] : v = fa[top[v]];

    return d[u] < d[v] ? u : v;
}

ll dis(int u, int v)
{
    return len[u] + len[v] - len[LCA(u, v)] * 2;
}

cs ll INF = 1e17;

int x[M], y[M], p[M];
ll vl[M], cost[M], ans;
std::vector<int> id[N];

namespace S1 {

int rt[N];

cs int N =::N * 100;

int lc[N], rc[N], tot;
ll v1[N], v2[N], dlt;

int node()
{
    int u = ++tot;
    lc[u] = rc[u] = 0;
    v1[u] = v2[u] = -INF;
    return u;
}

void ins(int &u, int l, int r, int p, ll _v1, ll _v2)
{
    if (!u)
        u = node();

    ckmx(v1[u], _v1);
    ckmx(v2[u], _v2);

    if (l == r)
        return;

    int m = (l + r) >> 1;
    p <= m ? ins(lc[u], l, m, p, _v1, _v2) : ins(rc[u], m + 1, r, p, _v1, _v2);
} void del(int &u, int l, int r, int p)
{
    if (!u)
        return;

    if (l == r)
    {
        u = 0;
        return;
    }

    int m = (l + r) >> 1;
    p <= m ? del(lc[u], l, m, p) : del(rc[u], m + 1, r, p);
    v1[u] = std::max(v1[lc[u]], v1[rc[u]]);
    v2[u] = std::max(v2[lc[u]], v2[rc[u]]);

    if (!lc[u] && !rc[u])
        u = 0;
} void merge(int &u, int v, int l, int r)
{
    if (!u || !v)
    {
        u |= v;
        return;
    }

    ckmx(v1[u], v1[v]);
    ckmx(v2[u], v2[v]);

    if (l == r)
        return;

    int m = (l + r) >> 1;
    ckmx(ans, std::max(v1[lc[u]] + v2[rc[v]], v1[lc[v]] + v2[rc[u]]) - dlt);
    merge(lc[u], lc[v], l, m);
    merge(rc[u], rc[v], m + 1, r);
}

void work(int u)
{
    for (int re e = el[u]; e; e = nx[e])
        if (to[e] != fa[u])
            work(to[e]);

    dlt = len[u];

    for (int re i : id[u])
    {
        int tmp = 0;
        ins(tmp, 1, n, d[p[i]], vl[i], vl[i] + len[p[i]]);
        merge(rt[u], tmp, 1, n);
    }

    for (int re e = el[u]; e; e = nx[e])
        if (to[e] != fa[u])
        {
            int v = to[e];
            del(rt[v], 1, n, d[u]);
            merge(rt[u], rt[v], 1, n);
        }
}

void Main()
{
    for (int re i = 1; i <= n; ++i)
        id[i].clear(), rt[i] = 0;

    for (int i = 1; i <= m; ++i)
    {
        if (x[i] != p[i])
            id[x[i]].push_back(i);

        if (y[i] != p[i])
            id[y[i]].push_back(i);
    }

    tot = 0;
    v1[0] = v2[0] = -INF;
    work(1);
}

}

namespace S2 {

int st[N], tp;
int vt[M + M], ct;
ll ans;

struct atom
{
    int u;
    ll vl;
};
typedef std::pair<atom, atom> Atom;
Atom t[N];
#define fi first
#define se second

ll dis(cs atom &a, cs atom &b)
{
    if (!a.u && !b.u)
        return -INF * 10;

    if (!a.u || !b.u)
        return -INF * 5;

    return ::dis(a.u, b.u) + a.vl + b.vl;
}

Atom merge(cs Atom &a, cs Atom &b, bool upt, ll dlt)
{
    ll d00 = dis(a.fi, b.fi), d01 = dis(a.fi, b.se);
    ll d10 = dis(a.se, b.fi), d11 = dis(a.se, b.se);

    if (upt)
        ckmx(ans, std::max({d00, d01, d10, d11}) + dlt);
    ll da = dis(a.fi, a.se), db = dis(b.fi, b.se);
    ll mx = std::max({d00, d01, d10, d11, da, db});

    if (mx == d00)
        return {a.fi, b.fi};

    if (mx == d01)
        return {a.fi, b.se};

    if (mx == d10)
        return {a.se, b.fi};

    if (mx == d11)
        return {a.se, b.se};

    if (mx == da)
        return a;

    if (mx == db)
        return b;

    assert(0);
    return Atom({0, 0}, {0, 0});
}

void solve(int rt)
{
    ct = 0;

    for (int i : id[rt])
        vt[++ct] = x[i], vt[++ct] = y[i];

    vt[++ct] = rt;
    std::sort(vt + 1, vt + ct + 1,
              [](int u, int v)
    {
        return dfn[u] < dfn[v];
    });
    ct = std::unique(vt + 1, vt + ct + 1) - vt - 1;

    for (int re i = 1; i <= ct; ++i)
        t[vt[i]] = Atom({0, 0}, {0, 0});

    for (int i : id[rt])
    {
        t[x[i]] = merge(t[x[i]], Atom({y[i], vl[i] - cost[i] + len[x[i]]}, {0, 0}), x[i] != rt, -len[x[i]] * 2);
        t[y[i]] = merge(t[y[i]], Atom({x[i], vl[i] - cost[i] + len[y[i]]}, {0, 0}), y[i] != rt, -len[y[i]] * 2);
    }

    tp = 0;

    for (int re i = 1; i <= ct; ++i)
    {
        int u = vt[i];

        if (tp)
        {
            int p = LCA(st[tp], u);

            while (d[st[tp]] > d[p])
            {
                int v = st[tp], w = st[tp - 1];

                if (d[w] >= d[p])
                    t[w] = merge(t[w], t[v], w != rt, -len[w] * 2), --tp;
                else
                    t[p] = t[v], st[tp] = p;
            }
        }

        st[++tp] = u;
    }

    while (tp > 1)
    {
        int u = st[tp], v = st[--tp];
        t[v] = merge(t[v], t[u], v != rt, -len[v] * 2);
    }
}

void Main()
{
    ans = -INF * 2;

    for (int re i = 1; i <= n; ++i)
        id[i].clear();

    for (int i = 1; i <= m; ++i)
        id[p[i]].push_back(i);

    for (int re i = 1; i <= n; ++i)
        solve(i);

    ckmx(::ans, ans / 2);
}

}

void Main()
{
    int T = gi();

    while (T--)
    {
        n = gi();
        memset(el, 0, sizeof(int) * (n + 1));
        ec = 0;

        for (int re i = 1; i < n; ++i)
        {
            int u = gi(), v = gi();
            adde(u, v, gi());
        }

        dfc = 0, dfs1(1, 0), dfs2(1, 1);
        m = gi();

        for (int re i = 1; i <= m; ++i)
        {
            x[i] = gi(), y[i] = gi(), cost[i] = gl();

            if (x[i] == y[i])
            {
                --i, --m;
                continue;
            }

            p[i] = LCA(x[i], y[i]);
            vl[i] = len[x[i]] + len[y[i]] - len[p[i]] * 2 - cost[i];
        }

        ans = -INF / 2;
        S1::Main();
        S2::Main();

        if (ans == -INF / 2)
            cout << "F\n";
        else
            cout << ans << "\n";
    }
}
signed main()
{
    Main();
    return 0;
}
/*#include <bits/stdc++.h>
#define ll long long
#define re register
#define cs const

namespace IO {

inline char gc()
{
    static cs int Rlen = 1 << 22 | 1;
    static char buf[Rlen], *p1, *p2;
    return (p1 == p2) && (p2 = (p1 = buf) + fread(buf, 1, Rlen, stdin), p1 == p2) ? EOF : *p1++;
} template<typename T>T get_integer()
{
    char c;
    bool f = false;

    while (!isdigit(c = gc()))
        f = c == '-';

    T x = c ^ 48;

    while (isdigit(c = gc()))
        x = ((x + (x << 2)) << 1) + (c ^ 48);

    return f ? -x : x;
} inline int gi()
{
    return get_integer<int>();
}
inline ll gl()
{
    return get_integer<ll>();
}

} using namespace IO;

using std::cerr;
using std::cout;

template<typename T, typename BT>
void ckmx(T &a, cs BT &b)
{
    a < b ? a = b : a;
}

cs int N = 5e4 + 7, M = 1e5 + 7;

int n, m;
int el[N], nx[N + N], to[N + N], w[N + N], ec;
inline void adde(int u, int v, int vl)
{
    nx[++ec] = el[u], el[u] = ec, to[ec] = v, w[ec] = vl;
    nx[++ec] = el[v], el[v] = ec, to[ec] = u, w[ec] = vl;
}

int d[N], fa[N], top[N];
int son[N], sz[N], dfn[N], dfc;
ll len[N];
void dfs1(int u, int p)
{
    fa[u] = p, d[u] = d[p] + 1, sz[u] = 1, son[u] = 0;

    for (int re e = el[u]; e; e = nx[e])
        if (to[e] != p)
        {
            len[to[e]] = len[u] + w[e];
            dfs1(to[e], u);
            sz[u] += sz[to[e]];

            if (sz[to[e]] > sz[son[u]])
                son[u] = to[e];
        }
}

void dfs2(int u, int tp)
{
    top[u] = tp, dfn[u] = ++dfc;

    if (son[u])
        dfs2(son[u], tp);

    for (int re e = el[u]; e; e = nx[e])
        if (to[e] != fa[u] && to[e] != son[u])
            dfs2(to[e], to[e]);
}

int LCA(int u, int v)
{
    while (top[u] != top[v])
        d[top[u]] > d[top[v]] ? u = fa[top[u]] : v = fa[top[v]];

    return d[u] < d[v] ? u : v;
}

ll dis(int u, int v)
{
    return len[u] + len[v] - len[LCA(u, v)] * 2;
}

cs ll INF = 1e17;

int x[M], y[M], p[M];
ll vl[M], cost[M], ans;
std::vector<int> id[N];

namespace S1 {

int rt[N];

cs int N =::N * 100;

int lc[N], rc[N], tot;
ll v1[N], v2[N], dlt;

int node()
{
    int u = ++tot;
    lc[u] = rc[u] = 0;
    v1[u] = v2[u] = -INF;
    return u;
}

void ins(int &u, int l, int r, int p, ll _v1, ll _v2)
{
    if (!u)
        u = node();

    ckmx(v1[u], _v1);
    ckmx(v2[u], _v2);

    if (l == r)
        return;

    int m = (l + r) >> 1;
    p <= m ? ins(lc[u], l, m, p, _v1, _v2) : ins(rc[u], m + 1, r, p, _v1, _v2);
} void del(int &u, int l, int r, int p)
{
    if (!u)
        return;

    if (l == r)
    {
        u = 0;
        return;
    }

    int m = (l + r) >> 1;
    p <= m ? del(lc[u], l, m, p) : del(rc[u], m + 1, r, p);
    v1[u] = std::max(v1[lc[u]], v1[rc[u]]);
    v2[u] = std::max(v2[lc[u]], v2[rc[u]]);

    if (!lc[u] && !rc[u])
        u = 0;
} void merge(int &u, int v, int l, int r)
{
    if (!u || !v)
    {
        u |= v;
        return;
    }

    ckmx(v1[u], v1[v]);
    ckmx(v2[u], v2[v]);

    if (l == r)
        return;

    int m = (l + r) >> 1;
}*/