#include <bits/stdc++.h>

using namespace std;

const int N = 100010;

vector<int> E[N];
int  fa[N];
int dep[N];
int cnt[N];
int son[N];
int top[N];
int idx[N];
int tot;

vector<int> G[N];
int L[N];
int R[N];
int W[N];

int dp[N];
int sum[N];

void dfs(int u)
{
	cnt[u] = 1;
	son[u] = 0;
	for (int &v : E[u]) {
		if (v == fa[u]) continue;
		fa[v] = u;
		dep[v] = dep[u] + 1;
		dfs(v);
		if (cnt[v] > cnt[son[u]]) son[u] = v;
		cnt[u] += cnt[v];
	}
}

void build(int u, int root)
{
	idx[u] = ++tot;
	top[u] = root;
	if (son[u]) build(son[u], root);
	for (int &v : E[u]) {
		if (v != fa[u] && v != son[u]) build(v, v);
	}
}

class BitTree{
public:
	static const int SIZE = 100010;
	int u[SIZE];
	void clear() {
		memset(u, 0, sizeof(u));
	}
	void modify(int x, int w) {
		while (x < SIZE) {
			u[x] += w;
			x += x & (-x);
		}
	}
	int get(int x) {
		long long res = 0;
		while (x) {
			res += u[x];
			x -= x & (-x);
		}
		return res;
	}
}A, B;

//0 lca
//1 sum
//2 dp
int find(int u, int v, int tag)
{
	int p = top[u];
	int q = top[v];
	int res = 0;
	while (p != q) {
		if (dep[p] < dep[q]) {
			swap(p, q);
			swap(u, v);
		}
		//idx[p], idx[u]
		if (tag == 1) res += A.get(idx[u]) - A.get(idx[p] - 1);
		if (tag == 2) res += B.get(idx[u]) - B.get(idx[p] - 1);
		u = fa[p];
		p = top[u];
	}
	if (dep[u] > dep[v]) swap(u, v);
	//idx[u], idx[v]
	if (tag == 1) res += A.get(idx[v]) - A.get(idx[u] - 1);
	if (tag == 2) res += B.get(idx[v]) - B.get(idx[u] - 1);
	if (tag == 0) return u;
	return res;
}

void gao(int u)
{
	sum[u] = 0;
	for (int &v : E[u]) {
		if (v == fa[u]) continue;
		gao(v);
		sum[u] += dp[v];
	}
	dp[u] = sum[u];
	for (int &it : G[u]) {
		int delta = W[it] + find(L[it], R[it], 1) - find(L[it], R[it], 2) + sum[u];
		dp[u] = max(dp[u], delta);
	}
	A.modify(idx[u], +sum[u]);
	B.modify(idx[u], +dp[u]);
}

int main()
{
	int T;
	scanf("%d", &T);
	while (T--) {
		int n, m;
		scanf("%d%d", &n, &m);
		for (int i = 1; i <= n; i++) {
			E[i].clear();
			G[i].clear();
		}
		for (int i = 1; i < n; i++) {
			int u, v;
			scanf("%d%d", &u, &v);
			E[u].push_back(v);
			E[v].push_back(u);
		}
		dfs(1);
		tot = 0;
		build(1, 1);
		for (int i = 0; i < m; i++) {
			scanf("%d%d%d", &L[i], &R[i], &W[i]);
			int lca = find(L[i], R[i], 0);
			G[lca].push_back(i);
		}
		A.clear();
		B.clear();
		gao(1);
		printf("%d\n", dp[1]);
	}
	return 0;
}