#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;

#define fi first
#define se second
#define pp push_back
#define all(x) (x).begin(), (x).end()
#define Ones(n) __builtin_popcount(n)
#define endl '\n'
#define mem(arrr, xx) memset(arrr,xx,sizeof arrr)
//#define int long long
#define debug(x) cout << (#x) << " = " << x << endl

void Gamal() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
#ifdef Clion
    freopen("input.txt", "r", stdin), freopen("output.txt", "w", stdout);
#endif
}

int dx[] = {+0, +0, -1, +1, +1, +1, -1, -1};
int dy[] = {-1, +1, +0, +0, +1, -1, +1, -1};

const double EPS = 1e-9;
const ll OO = 0X3F3F3F3F3F3F3F3F;
const int N = 2e5 + 5, INF = INT_MAX, MOD = 1e9 + 7, LOG = 20;

vector<int> adj[N];
int depth[N], up[N][LOG], n, timer, tin[N], tout[N], sub[N], mx, m;


void dfs(int u, int p) {
    tin[u] = timer++;
    sub[u] = 0;
    for (auto v: adj[u]) {
        if (v == p)continue;
        depth[v] = depth[u] + 1;
        up[v][0] = u;
        dfs(v, u);
        sub[u] += sub[v] + 1;
    }
    tout[u] = timer - 1;
}

bool isAncestor(int u, int v) {
    return tin[u] <= tin[v] && tout[u] >= tout[v];
}

int LCA(int u, int v) {
    if (depth[u] < depth[v])
        swap(u, v);
    int k = depth[u] - depth[v];
    for (int i = 0; i < LOG; ++i) {
        if ((1 << i) & k) {
            u = up[u][i];
        }
    }
    if (u == v)
        return u;
    for (int i = LOG - 1; i >= 0; --i) {
        if (up[u][i] != up[v][i]) {
            u = up[u][i];
            v = up[v][i];
        }
    }
    return up[u][0];
}

int Kthancestor(int u, int k) {
    if (k > depth[u])return 0;
    for (int j = LOG - 1; j >= 0; --j) {
        if (k & (1 << j)) {
            u = up[u][j];
        }
    }
    return u;
}

void build(int root) {
    dfs(root, root);
    up[root][0] = root;
    for (int j = 1; j < LOG; ++j) {
        for (int i = 0; i < n; ++i) {
            up[i][j] = up[up[i][j - 1]][j - 1];
        }
    }
}

int dist(int u, int v) {
    return depth[u] + depth[v] - 2 * depth[LCA(u, v)];
}

void solve() {
    int s;
    cin >> n >> s >> m;
    s--, m--;
    for (int i = 0; i < n; ++i)adj[i].clear();
    for (int i = 0; i < n - 1; ++i) {
        int u, v;
        cin >> u >> v;
        u--, v--;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }
    timer = 0;
    depth[s] = 0;
    build(s);
    int ans = 0;
    for (int i = 0; i < n; ++i) {
        if (isAncestor(i, m)) {
            ans = max(ans, depth[i]);
            continue;
        }
        ans = max(ans, dist(i, m) + depth[m]);
    }
    cout << ans << endl;
}


signed main() {
    Gamal();
    int t = 1;
    cin >> t;
    while (t--) {
        solve();
    }
}