#include <bits/stdc++.h>
#define ls(u) tr[u].ls
#define rs(u) tr[u].rs
#define N 120005
using namespace std;
typedef long long ll;

int Q;
int n, m, rt, tot, totN;
int tI[N], tO[N], tmr, sz[N], son[N], top[N], id[N];
int p[N], d[N], ids[N], idt[N];
vector <int> sto[N], tto[N*5];

bool vst[N*5], instk[N*5];

struct Seg { int ls, rs; } tr[N*2];

void dfs_son (int u, int fa)
{
    sz[u]=1;
    for (int i=0; i<(int)sto[u].size(); i++) {
        int v=sto[u][i];
        if (v==fa) { continue; }
        p[v]=u; d[v]=d[u]+1;
        dfs_son(v, u);
        sz[u]+=sz[v];
        if (sz[v]>sz[son[u]]) { son[u]=v; }
    }
}
void dfs_top (int u, int fa)
{
    tI[u]=++tmr; id[tmr]=u;
    if (son[fa]==u) { top[u]=top[fa]; }
    else { top[u]=u; }

    if (son[u]) { dfs_top(son[u], u); }
    for (int i=0; i<(int)sto[u].size(); i++) {
        int v=sto[u][i];
        if (v==fa || v==son[u]) { continue; }
        dfs_top(v, u);
    }

    tO[u]=tmr;
}

inline int idp (int i) { return i+tot+tot; }

void buildST (int &u, int l, int r)
{
    if (!u) { u=++tot; }
    if (l==r) { return; }
    int md=(l+r)/2;
    buildST(ls(u), l, md);
    buildST(rs(u), md+1, r);
}

void builded (int u, int l, int r)
{
    if (l==r) {
        ids[id[l]]=u;
        idt[id[l]]=u+tot;
        return;
    }
    int md=(l+r)/2;
    builded(ls(u), l, md);
    builded(rs(u), md+1, r);
    tto[u].push_back(ls(u));
    tto[u].push_back(rs(u));
    tto[ls(u)+tot].push_back(u+tot);
    tto[rs(u)+tot].push_back(u+tot);
}

void upd (int u, int l, int r, int ql, int qr, int tg, int id)
{
    if (l>qr || r<ql) { return; }
    if (ql<=l && r<=qr) {
        if (!tg) { tto[id].push_back(u); }
        else { tto[u+tot].push_back(id); }
        return;
    }
    int md=(l+r)/2;
    upd(ls(u), l, md, ql, qr, tg, id);
    upd(rs(u), md+1, r, ql, qr, tg, id);
}

bool up (int u, int v) { return tI[u]<=tI[v] && tO[v]<=tO[u]; }

void add (int tg, int id, int u, int v)
{
    int uu=u, vv=v;

    if (!tg && !up(u, v)) { u=p[u]; }
    if (tg && !up(v, u)) { v=p[v]; }

    while (top[u]!=top[v]) {
        if (d[top[u]]<d[top[v]]) { swap(u, v); }
        upd(rt, 1, n, tI[top[u]], tI[u], tg, id);
        u=p[top[u]];
    }
    if (d[u]>d[v]) { swap(u, v); }

    if (!tg && up(uu, vv)) {
        if (u!=v) { upd(rt, 1, n, tI[u]+1, tI[v], tg, id); }
    }
    else if (tg && up(vv, uu)) {
        if (u!=v) { upd(rt, 1, n, tI[u]+1, tI[v], tg, id); }
    }
    else {
        upd(rt, 1, n, tI[u], tI[v], tg, id);
    }
}

bool cal (int u)
{
    if (vst[u]) { return 1; }
    vst[u]=1; instk[u]=1;
    for (int i=0; i<(int)tto[u].size(); i++) {
        int v=tto[u][i];
        if (instk[v]) { return 0; }
        bool cur=cal(v);
        if (!cur) { return 0; }
    }
    instk[u]=0;
    return 1;
}

void clr ()
{
    for (int i=1; i<=n; i++) { sto[i].clear(); }
    for (int i=1; i<=n; i++) { son[i]=0; }
    for (int i=1; i<=totN; i++) { tto[i].clear(); vst[i]=0; instk[i]=0; }
    for (int i=1; i<=tot; i++) { tr[i].ls=0; tr[i].rs=0; }
    rt=0; tot=0; totN=0; tmr=0;
}

int main ()
{
    // freopen("0test.in", "r", stdin);
    // freopen("0test.out", "w", stdout);

    scanf("%d", &Q);
    while (Q--) {
        clr();
        scanf("%d", &n);
        for (int i=1; i<n; i++) {
            int u, v; scanf("%d %d", &u, &v);
            sto[u].push_back(v);
            sto[v].push_back(u);
        }

        scanf("%d", &m);

        dfs_son(1, 0);
        dfs_top(1, 0);
        buildST(rt, 1, n);
        builded(rt, 1, n);

        for (int i=1; i<=m; i++) {
            int s, t; scanf("%d %d", &s, &t);
            add(0, idp(i), s, t);
            tto[ids[s]].push_back(idp(i));
            add(1, idp(i), s, t);
            tto[idp(i)].push_back(idt[t]);
        }
        totN=tot+tot+m;

        bool ok=1;
        for (int i=1; i<=totN; i++) {
            if (!vst[i]) {
                if (!cal(i)) { printf("No\n"); ok=0; break; }
            }
        }
        if (!ok) { continue; }
        printf("Yes\n");
    }

    return 0;
}