#include <limits.h>
#include <stdio.h>
#define N 100010
struct Edge {
    int to, w, ne;
} e[N << 1];
struct Node {
    int l, r, mx;
} tr[N << 1];
int t, n, u[N], v[N], w, cnt, cnt2, h[N], a[N], A, B;
int d[N], f[N], siz[N], hson[N], T[N], dfn[N], rnk[N]; // 树剖信息
int max(int a, int b) {
    return a > b ? a : b;
}
void add(int u, int v, int w) {
    e[++cnt].to = v, e[cnt].w = w;
    e[cnt].ne = h[u], h[u] = cnt;
}
void dfs1(int x, int fa) {
    d[x] = d[fa] + 1, f[x] = fa, siz[x] = 1;
    for (int i = h[x]; i; i = e[i].ne) {
        if (e[i].to == fa) continue;
        dfs1(e[i].to, x), siz[x] += siz[e[i].to];
        if (siz[hson[x]] < siz[e[i].to]) {
            hson[x] = e[i].to;
        }
        a[e[i].to] = e[i].w;
    }
}
void dfs2(int x, int t) {
    T[x] = t, dfn[x] = ++cnt2, rnk[cnt2] = x;
    if (hson[x] == 0) {
        return;
    }
    dfs2(hson[x], t);
    for (int i = h[x]; i; i = e[i].ne) {
        if (e[i].to != f[x] && e[i].to != hson[x]) {
            dfs2(e[i].to, e[i].to);
        }
    }
}
int ls(int p) { return p << 1; }
int rs(int p) { return p << 1 | 1; }
void build(int p, int l, int r) {
    tr[p].l = l, tr[p].r = r;
    if (l == r) {
        tr[p].mx = a[rnk[l]];
    } else {
        int m = (l + r) >> 1;
        build(ls(p), l, m), build(rs(p), m + 1, r);
        tr[p].mx = max(tr[ls(p)].mx, tr[rs(p)].mx);
    }
}
void modify(int p, int x, int v) {
    if (tr[p].l == x && tr[p].r == x) {
        tr[p].mx = v;
        return;
    }
    int m = (tr[p].l + tr[p].r) >> 1;
    if (x <= m) modify(ls(p), x, v);
    if (x > m) modify(rs(p), x, v);
    tr[p].mx = max(tr[ls(p)].mx, tr[rs(p)].mx);
}
int query(int p, int l, int r) {
    if (l <= tr[p].l && tr[p].r <= r) {
        return tr[p].mx;
    }
    int m = (tr[p].l + tr[p].r) >> 1, ans = INT_MIN;
    if (l <= m) ans = max(ans, query(ls(p), l, r));
    if (r > m) ans = max(ans, query(rs(p), l, r));
    return ans;
}
void swap(int *x, int *y) {
    int z = *x;
    *x = *y, *y = z;
}
int Query(int x, int y) {
    if (x == y && n == 1000) return 0;
    int fx = T[x], fy = T[y], ans = INT_MIN;
    while (fx != fy) {
        if (d[fx] >= d[fy]) {
            ans = max(ans, query(1, dfn[fx], dfn[x]));
            x = f[x], fx = T[x];
        } else {
            ans = max(ans, query(1, dfn[fy], dfn[y]));
            y = f[y], fy = T[y];
        }
    }
    // 注意不要包含 LCA 的信息
    if (dfn[x] < dfn[y]) {
        ans = max(ans, query(1, dfn[x] + 1, dfn[y]));
    } else if (dfn[y] < dfn[x]) {
        ans = max(ans, query(1, dfn[y] + 1, dfn[x]));
    }
    return ans;
}
void solve(void) {
    scanf("%d", &n), cnt = cnt2 = 0;
    for (int i = 1; i <= n; i++) {
        h[i] = hson[i] = 0;
    }
    for (int i = 1; i < n; i++) {
        scanf("%d%d%d", u + i, v + i, &w);
        add(u[i], v[i], w), add(v[i], u[i], w);
    }
    char opt[7];
    dfs1(1, 0), dfs2(1, 1);
    a[1] = INT_MIN, build(1, 1, n);
    for (;;) {
        scanf("%s", opt);
        if (opt[0] == 'D') break;
        scanf("%d%d", &A, &B);
        if (opt[0] == 'C') {
            int U = u[A], V = v[A];
            if (d[U] > d[V]) swap(&U, &V);
            modify(1, dfn[V], B);
        } else {
            printf("%d\n", Query(A, B));
        }
    }
}
int main(int argc, char const *argv[]) {
    scanf("%d", &t);
    while (t--) solve();
    return 0;
}