// Author: Lech Duraj
#include <cstdio>
#include <algorithm>
#include <vector>
#include <queue>
#include <functional>
using namespace std;

typedef pair<int,int> PI;

const int delta = 11;
const int maxn = 2000;

vector<int> children[maxn];
vector<int> G[maxn];
bool L[maxn][maxn];
bool A[delta][delta];
int depth[maxn];
int parent[maxn];
int M[1<<delta];

void clear_match()
{
    for(int p=0; p<delta; p++)
        for(int q=0; q<delta; q++)
            A[p][q] = 0;
}

void dfs(int x, int p)
{
    int c = 0;
    parent[x] = p;
    for(int y : G[x])
        if (y != p)
        {
            children[x].push_back(y);
            depth[y] = depth[x] + 1;
            dfs(y, x);
        }        
}

int matching(int i, vector<int> &possible)
{
    M[0] = 0;
    int d = children[i].size();
    for(int s = 1; s < (1 << d); s++)
    {
        M[s] = 0;
        for(int x = 0; x < d; x++)
            for(int y = 0; y < d; y++)
                if ((x!=y) && (s & (1<<x)) && (s & (1<<y)) && A[x][y])
                    M[s] = max(M[s],1 + M[s - (1<<x) - (1<<y)]);
    }
    int full = (1 << d) - 1;
    for(int x = 0; x < d; x++)
        if (M[full - (1 << x)]==M[full])
            possible.push_back(children[i][x]);
    return M[full];
}

int main()
{
    int TT;
    scanf("%d",&TT);
    while(TT--)
    {
        int n;
        scanf("%d",&n);
        for(int i=0; i<n; i++)
        {
            G[i].clear();
            children[i].clear();
        }
        for(int i=0; i<n-1; i++)
        {
            int a,b;
            scanf("%d %d",&a,&b);
            G[a-1].push_back(b-1);
            G[b-1].push_back(a-1);
        }
        dfs(0, -1);
        int m;
        scanf("%d",&m);
        for(int i=0; i<n; i++)
            for(int j=0; j<n; j++)
                L[i][j] = false;
        for(int i=0; i<m; i++)
        {
            int a,b;
            scanf("%d %d",&a,&b);
            L[a-1][b-1] = L[b-1][a-1] = true;
        }
        vector<PI> allvert;
        for(int i=0; i<n; i++)
            allvert.push_back(PI(depth[i],i));
        sort(allvert.begin(),allvert.end(),greater<PI>());
        int result = 0;
        for(int i=0; i<n; i++)
        {
            clear_match();
            int x = allvert[i].second;
            for(int v : children[x])
                if (L[v][x])
                    result++;
            for(int s = 0; s<children[x].size(); s++)
                for(int t = 0; t<children[x].size(); t++)
                {
                    int v = children[x][s];
                    int w = children[x][t];
                    if (v!=w && L[v][w] && !L[v][x] && !L[w][x])
                        A[s][t] = A[t][s] = true;
                }
            vector<int> possible;
            result += matching(x, possible);
            for(int v : possible)
                if (!L[v][x])
                    for(int z=0; z<n; z++)
                        if (z!=x && parent[z]!=x && L[v][z])
                            L[x][z] = L[z][x] = true;
        }
        printf("%d\n",result);
    }
}