import java.util.ArrayList;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.Arrays;
import java.util.Random;
import java.io.FileWriter;
import java.io.PrintWriter;
/*
    Solution Created: 19:21:09 06/09/2020
    Custom Competitive programming helper.
*/

public class Main {
	static int t, n, a, b, da,db;
	static ArrayList<Integer>[] adj;
	public static void solve(Reader in, Writer out) {
		t = in.nextInt();
		while(t-->0) {
			init(in);
			int leaf = 0;
			for(int i = 0; i<n; i++) {
				if(adj[i].size()==1) {
					leaf = i;
					break;
				}
			}
			int maxd = maxDist(leaf, -1);
			if(db<2*da+1) {
				out.println("Alice");
				continue;
			}
			if(canReach(a,b, -1, 0)) {
				out.println("Alice");
				continue;
			}
			if(maxd<2*da+1) {
				out.println("Alice");
				continue;
			}
			out.println("Bob");
		}
	}
	public static boolean canReach(int i,int bob, int prev, int moves) {
		if(moves>da) return false;
		if(i==b) return true;
		boolean can = false;
		for(Integer next : adj[i]) {
			if(next==prev) continue;
			can|=canReach(next, bob, i, moves+1);
		}
		return can;
	}
	public static int maxDist(int i, int prev) {
		int max = 0;
		for(Integer next : adj[i]) {
			if(next==prev) continue;
			max = Math.max(maxDist(next, i)+1,max);
		}
		return max;
	}

	public static void main(String[] args) {
		Reader in = new Reader();
		Writer out = new Writer();
		solve(in, out);
		out.exit();
	}
	public static void init(Reader in) {
		n = in.nextInt();
		a = in.nextInt()-1;
		b = in.nextInt()-1;
		da = in.nextInt();
		db = in.nextInt();
		adj = new ArrayList[n];
		for(int i = 0; i<n; i++) adj[i] = new ArrayList<Integer>();
		for(int i = 0; i<n-1; i++) {
			int v = in.nextInt()-1, b = in.nextInt()-1;
			adj[v].add(b);
			adj[b].add(v);
		}
	}

static class Reader {
	static BufferedReader br;
	static StringTokenizer st;
	private int charIdx = 0;
	private String s;

	public Reader() {
		this.br = new BufferedReader(new InputStreamReader(System.in));
	}

	public Reader(String f){
		try {
			this.br = new BufferedReader(new FileReader(f));
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public int[] na(int n) {
		int[] a = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = nextInt();
		return a;
	}

	public double[] nd(int n) {
		double[] a = new double[n];
		for (int i = 0; i < n; i++)
			a[i] = nextDouble();
		return a;
	}

	public char nextChar() {
		if (s == null || charIdx >= s.length()) {
			if (st == null || !st.hasMoreTokens())
				try {
					readLine();
				} catch (Exception e) {
				}
			s = st.nextToken();
			charIdx = 0;
		}
		return s.charAt(charIdx++);
	}

	public long[] nl(int n) {
		long[] a = new long[n];
		for (int i = 0; i < n; i++)
			a[i] = nextLong();
		return a;
	}

	public char[] nca() {
		return next().toCharArray();
	}

	public String[] nS(int n) {
		String[] a = new String[n];
		for (int i = 0; i < n; i++)
			a[i] = next();
		return a;
	}

	public int nextInt() {
		if (st == null || !st.hasMoreTokens())
			try {
				readLine();
			} catch (Exception e) {
			}
		return Integer.parseInt(st.nextToken());
	}

	public double nextDouble() {
		if (st == null || !st.hasMoreTokens())
			try {
				readLine();
			} catch (Exception e) {
			}
		return Double.parseDouble(st.nextToken());
	}

	public Long nextLong() {
		if (st == null || !st.hasMoreTokens())
			try {
				readLine();
			} catch (Exception e) {
			}
		return Long.parseLong(st.nextToken());
	}

	public String next() {
		if (st == null || !st.hasMoreTokens())
			try {
				readLine();
			} catch (Exception e) {
			}
		return st.nextToken();
	}

	public static void readLine() {
		try {
			st = new StringTokenizer(br.readLine());
		} catch (Exception e) {
		}
	}
}

static class Util{
		private static Random random = new Random();
		static long[] fact;
		public static void initFactorial(int n, long mod) {
			fact = new long[n+1];
			fact[0] = 1;
			for (int i = 1; i < n+1; i++) fact[i] = (fact[i - 1] * i) % mod;
		}
		public static long modInverse(long a, long MOD) {
			long[] gcdE = gcdExtended(a, MOD);
			if (gcdE[0] != 1) return -1; // Inverted doesn't exist
			long x = gcdE[1];
			return (x % MOD + MOD) % MOD;
		}
		public static long[] gcdExtended(long p, long q) {
			if (q == 0) return new long[] { p, 1, 0 };
			long[] vals = gcdExtended(q, p % q);
			long tmp = vals[2];
			vals[2] = vals[1] - (p / q) * vals[2];
			vals[1] = tmp;
			return vals;
		}
		public static long nCr(int n, int r, long MOD) {
			if (r == 0) return 1;
			return (fact[n] * modInverse(fact[r], MOD) % MOD * modInverse(fact[n - r], MOD) % MOD) % MOD;
		}
		public static long nCr(int n, int r) {
			return (fact[n]/fact[r])/fact[n-r];
		}
		public static long nPr(int n, int r, long MOD) {
			if (r == 0) return 1;
			return (fact[n] * modInverse(fact[n - r], MOD) % MOD) % MOD;
		}
		public static long nPr(int n, int r) {
			return fact[n]/fact[n-r];
		}
		public static boolean isPrime(int n) {
	        if (n <= 1) return false;
	        if (n <= 3) return true;
	        if (n % 2 == 0 || n % 3 == 0) return false;
	        for (int i = 5; i * i <= n; i = i + 6)
	            if (n % i == 0 || n % (i + 2) == 0)
	            return false;
	        return true;
	    }
	    public static int lowerBound(int[] a, int v) {
	    	int l = 0, h = a.length;
	    	while(l<h) {
	    		int mid = (l+h)/2;
	    		if(v<=a[mid]) h = mid;
	    		else l = mid+1;
	    	}
	    	return l;
	    }
	    public static int lowerBound(long[] a, long v) {
	    	int l = 0, h = a.length;
	    	while(l<h) {
	    		int mid = (l+h)/2;
	    		if(v<=a[mid]) h = mid;
	    		else l = mid+1;
	    	}
	    	return l;
	    }
	    public static int upperBound(int[] a, int v) {
	    	int l = 0, h = a.length;
	    	while(l<h) {
	    		int mid = (l+h)/2;
	    		if(a[mid]<=v) l = mid+1;
	    		else h = mid;
	    	}
	    	return l;
	    }
	    public static int upperBound(long[] a, long v) {
	    	int l = 0, h = a.length;
	    	while(l<h) {
	    		int mid = (l+h)/2;
	    		if(a[mid]<=v) l = mid+1;
	    		else h = mid;
	    	}
	    	return l;
	    }
	    public static boolean[] getSieve(int n) {
	        boolean[] isPrime = new boolean[n+1];
	        for (int i = 2; i <= n; i++) isPrime[i] = true;
	        for (int i = 2; i*i <= n; i++) if (isPrime[i])
	                for (int j = i; i*j <= n; j++) isPrime[i*j] = false;
	        return isPrime;
	    }
	    public static int gcd(int a, int b) {
	    	int tmp = 0;
	    	while(b != 0) {
	    		tmp = b;
	    		b = a%b;
	    		a = tmp;
	    	}
	    	return a;
	    }
	    public static long gcd(long a, long b) {
	    	long tmp = 0;
	    	while(b != 0) {
	    		tmp = b;
	    		b = a%b;
	    		a = tmp;
	    	}
	    	return a;
	    }
	    public static int random(int min, int max) {
	    	return random.nextInt(max-min+1)+min;
	    }
		public static void dbg(Object... o) {
			System.out.println(Arrays.deepToString(o));
		}
		public static void reverse(int[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				int tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static void reverse(int[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static void reverse(long[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				long tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static void reverse(long[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static void reverse(float[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				float tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static void reverse(float[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static void reverse(double[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				double tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static void reverse(double[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static void reverse(char[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				char tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static void reverse(char[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static <T> void reverse(T[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				T tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static <T> void reverse(T[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static void shuffle(int[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            int t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    public static void shuffle(long[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            long t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    public static void shuffle(float[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            float t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    public static void shuffle(double[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            double t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    public static void shuffle(char[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            char t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    public static <T> void shuffle(T[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            T t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
		public static void sortArray(int[] a) {
	        shuffle(a);
	        Arrays.sort(a);
	    }
		public static void sortArray(long[] a) {
			shuffle(a);
	        Arrays.sort(a);
	    }
		public static void sortArray(float[] a) {
			shuffle(a);
	        Arrays.sort(a);
	    }
		public static void sortArray(double[] a) {
			shuffle(a);
	        Arrays.sort(a);
	    }
		public static void sortArray(char[] a) {
			shuffle(a);
	        Arrays.sort(a);
	    }
		public static <T extends Comparable<T>> void sortArray(T[] a) {
	        Arrays.sort(a);
	    }
	}

static class Writer {
	private PrintWriter pw;
	public Writer(){
		pw = new PrintWriter(System.out);
	}

	public Writer(String f){
		try {
			pw = new PrintWriter(new FileWriter(f));
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public void printArray(int[] a) {
		for(int i = 0; i<a.length; i++) print(a[i]+" ");
	}
	public void printlnArray(int[] a) {
		for(int i = 0; i<a.length; i++) print(a[i]+" ");
		pw.println();
	}
	public void printArray(long[] a) {
		for(int i = 0; i<a.length; i++) print(a[i]+" ");
	}
	public void printlnArray(long[] a) {
		for(int i = 0; i<a.length; i++) print(a[i]+" ");
		pw.println();
	}
	public void print(Object o) {
		pw.print(o.toString());
	}
	public void println(Object o) {
		pw.println(o.toString());
	}
	public void println() {
		pw.println();
	}
	public void flush() {
		pw.flush();
	}
	public void exit() {
		pw.close();
	}
}
}


import java.util.ArrayList;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.Arrays;
import java.util.Random;
import java.io.FileWriter;
import java.io.PrintWriter;
/*
    Solution Created: 20:41:56 06/09/2020
    Custom Competitive programming helper.
*/

public class Main {
	static int t, n, a, b, da, db;
	static ArrayList<Integer>[] adj;

	public static void solve(Reader in, Writer out) {
		t = in.nextInt();
		while (t-- > 0) {
			init(in);
			if ((db < 2 * da + 1) || canReach(a, b, -1, 0) || (diameter() < 2 * da + 1))
				out.println("Alice");
			else
				out.println("Bob");
		}
	}

	public static boolean canReach(int i, int bob, int prev, int moves) {
		if (moves > da)
			return false;
		if (i == b)
			return true;
		boolean can = false;
		for (Integer next : adj[i]) {
			if (next == prev)
				continue;
			can |= canReach(next, bob, i, moves + 1);
		}
		return can;
	}

	static int maxCount,maxIdx;
	public static int diameter() {
		maxCount = 0;
		maxIdx = 0;
		dfs(0,-1, 0);
		int A = maxIdx;
		maxCount = 0;
		maxIdx = 0;
		dfs(A, -1, 0);
		return maxCount;
	}
	public static void dfs(int i, int prev,int count) {
		if(adj[i].size()==1 && count>maxCount) {
			maxIdx = i;
			maxCount = count;
		}
		for(Integer next : adj[i]) if(next!=prev) dfs(next, i, count+1);
	}
	public static void main(String[] args) {
		Reader in = new Reader();
		Writer out = new Writer();
		solve(in, out);
		out.exit();
	}

	public static void init(Reader in) {
		n = in.nextInt();
		a = in.nextInt() - 1;
		b = in.nextInt() - 1;
		da = in.nextInt();
		db = in.nextInt();
		adj = new ArrayList[n];
		for (int i = 0; i < n; i++)
			adj[i] = new ArrayList<Integer>();
		for (int i = 0; i < n - 1; i++) {
			int v = in.nextInt() - 1, b = in.nextInt() - 1;
			adj[v].add(b);
			adj[b].add(v);
		}
	}

static class Reader {
	static BufferedReader br;
	static StringTokenizer st;
	private int charIdx = 0;
	private String s;

	public Reader() {
		this.br = new BufferedReader(new InputStreamReader(System.in));
	}

	public Reader(String f){
		try {
			this.br = new BufferedReader(new FileReader(f));
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public int[] na(int n) {
		int[] a = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = nextInt();
		return a;
	}

	public double[] nd(int n) {
		double[] a = new double[n];
		for (int i = 0; i < n; i++)
			a[i] = nextDouble();
		return a;
	}

	public char nextChar() {
		if (s == null || charIdx >= s.length()) {
			if (st == null || !st.hasMoreTokens())
				try {
					readLine();
				} catch (Exception e) {
				}
			s = st.nextToken();
			charIdx = 0;
		}
		return s.charAt(charIdx++);
	}

	public long[] nl(int n) {
		long[] a = new long[n];
		for (int i = 0; i < n; i++)
			a[i] = nextLong();
		return a;
	}

	public char[] nca() {
		return next().toCharArray();
	}

	public String[] nS(int n) {
		String[] a = new String[n];
		for (int i = 0; i < n; i++)
			a[i] = next();
		return a;
	}

	public int nextInt() {
		if (st == null || !st.hasMoreTokens())
			try {
				readLine();
			} catch (Exception e) {
			}
		return Integer.parseInt(st.nextToken());
	}

	public double nextDouble() {
		if (st == null || !st.hasMoreTokens())
			try {
				readLine();
			} catch (Exception e) {
			}
		return Double.parseDouble(st.nextToken());
	}

	public Long nextLong() {
		if (st == null || !st.hasMoreTokens())
			try {
				readLine();
			} catch (Exception e) {
			}
		return Long.parseLong(st.nextToken());
	}

	public String next() {
		if (st == null || !st.hasMoreTokens())
			try {
				readLine();
			} catch (Exception e) {
			}
		return st.nextToken();
	}

	public static void readLine() {
		try {
			st = new StringTokenizer(br.readLine());
		} catch (Exception e) {
		}
	}
}

static class Util{
		private static Random random = new Random();
		static long[] fact;
		public static void initFactorial(int n, long mod) {
			fact = new long[n+1];
			fact[0] = 1;
			for (int i = 1; i < n+1; i++) fact[i] = (fact[i - 1] * i) % mod;
		}
		public static long modInverse(long a, long MOD) {
			long[] gcdE = gcdExtended(a, MOD);
			if (gcdE[0] != 1) return -1; // Inverted doesn't exist
			long x = gcdE[1];
			return (x % MOD + MOD) % MOD;
		}
		public static long[] gcdExtended(long p, long q) {
			if (q == 0) return new long[] { p, 1, 0 };
			long[] vals = gcdExtended(q, p % q);
			long tmp = vals[2];
			vals[2] = vals[1] - (p / q) * vals[2];
			vals[1] = tmp;
			return vals;
		}
		public static long nCr(int n, int r, long MOD) {
			if (r == 0) return 1;
			return (fact[n] * modInverse(fact[r], MOD) % MOD * modInverse(fact[n - r], MOD) % MOD) % MOD;
		}
		public static long nCr(int n, int r) {
			return (fact[n]/fact[r])/fact[n-r];
		}
		public static long nPr(int n, int r, long MOD) {
			if (r == 0) return 1;
			return (fact[n] * modInverse(fact[n - r], MOD) % MOD) % MOD;
		}
		public static long nPr(int n, int r) {
			return fact[n]/fact[n-r];
		}
		public static boolean isPrime(int n) {
	        if (n <= 1) return false;
	        if (n <= 3) return true;
	        if (n % 2 == 0 || n % 3 == 0) return false;
	        for (int i = 5; i * i <= n; i = i + 6)
	            if (n % i == 0 || n % (i + 2) == 0)
	            return false;
	        return true;
	    }
	    public static int lowerBound(int[] a, int v) {
	    	int l = 0, h = a.length;
	    	while(l<h) {
	    		int mid = (l+h)/2;
	    		if(v<=a[mid]) h = mid;
	    		else l = mid+1;
	    	}
	    	return l;
	    }
	    public static int lowerBound(long[] a, long v) {
	    	int l = 0, h = a.length;
	    	while(l<h) {
	    		int mid = (l+h)/2;
	    		if(v<=a[mid]) h = mid;
	    		else l = mid+1;
	    	}
	    	return l;
	    }
	    public static int upperBound(int[] a, int v) {
	    	int l = 0, h = a.length;
	    	while(l<h) {
	    		int mid = (l+h)/2;
	    		if(a[mid]<=v) l = mid+1;
	    		else h = mid;
	    	}
	    	return l;
	    }
	    public static int upperBound(long[] a, long v) {
	    	int l = 0, h = a.length;
	    	while(l<h) {
	    		int mid = (l+h)/2;
	    		if(a[mid]<=v) l = mid+1;
	    		else h = mid;
	    	}
	    	return l;
	    }
	    public static boolean[] getSieve(int n) {
	        boolean[] isPrime = new boolean[n+1];
	        for (int i = 2; i <= n; i++) isPrime[i] = true;
	        for (int i = 2; i*i <= n; i++) if (isPrime[i])
	                for (int j = i; i*j <= n; j++) isPrime[i*j] = false;
	        return isPrime;
	    }
	    public static int gcd(int a, int b) {
	    	int tmp = 0;
	    	while(b != 0) {
	    		tmp = b;
	    		b = a%b;
	    		a = tmp;
	    	}
	    	return a;
	    }
	    public static long gcd(long a, long b) {
	    	long tmp = 0;
	    	while(b != 0) {
	    		tmp = b;
	    		b = a%b;
	    		a = tmp;
	    	}
	    	return a;
	    }
	    public static int random(int min, int max) {
	    	return random.nextInt(max-min+1)+min;
	    }
		public static void dbg(Object... o) {
			System.out.println(Arrays.deepToString(o));
		}
		public static void reverse(int[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				int tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static void reverse(int[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static void reverse(long[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				long tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static void reverse(long[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static void reverse(float[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				float tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static void reverse(float[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static void reverse(double[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				double tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static void reverse(double[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static void reverse(char[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				char tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static void reverse(char[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static <T> void reverse(T[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				T tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static <T> void reverse(T[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static void shuffle(int[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            int t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    public static void shuffle(long[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            long t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    public static void shuffle(float[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            float t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    public static void shuffle(double[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            double t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    public static void shuffle(char[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            char t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    public static <T> void shuffle(T[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            T t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
		public static void sortArray(int[] a) {
	        shuffle(a);
	        Arrays.sort(a);
	    }
		public static void sortArray(long[] a) {
			shuffle(a);
	        Arrays.sort(a);
	    }
		public static void sortArray(float[] a) {
			shuffle(a);
	        Arrays.sort(a);
	    }
		public static void sortArray(double[] a) {
			shuffle(a);
	        Arrays.sort(a);
	    }
		public static void sortArray(char[] a) {
			shuffle(a);
	        Arrays.sort(a);
	    }
		public static <T extends Comparable<T>> void sortArray(T[] a) {
	        Arrays.sort(a);
	    }
	}

static class Writer {
	private PrintWriter pw;
	public Writer(){
		pw = new PrintWriter(System.out);
	}

	public Writer(String f){
		try {
			pw = new PrintWriter(new FileWriter(f));
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public void printArray(int[] a) {
		for(int i = 0; i<a.length; i++) print(a[i]+" ");
	}
	public void printlnArray(int[] a) {
		for(int i = 0; i<a.length; i++) print(a[i]+" ");
		pw.println();
	}
	public void printArray(long[] a) {
		for(int i = 0; i<a.length; i++) print(a[i]+" ");
	}
	public void printlnArray(long[] a) {
		for(int i = 0; i<a.length; i++) print(a[i]+" ");
		pw.println();
	}
	public void print(Object o) {
		pw.print(o.toString());
	}
	public void println(Object o) {
		pw.println(o.toString());
	}
	public void println() {
		pw.println();
	}
	public void flush() {
		pw.flush();
	}
	public void exit() {
		pw.close();
	}
}
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.LinkedList;

public class Main {
	private static int longestPath(int n, LinkedList<Integer>[] adj) {
		int[] d = new int[n+1];
		Arrays.fill(d, -1);
		LinkedList<Integer> q = new LinkedList<Integer>();
		d[1] = 0;
		q.add(1);
		while (!q.isEmpty()) {
			int u = q.poll();
			for (int j : adj[u]) {
				if (d[j] == -1) {
					q.add(j);
					d[j] = d[u]+1;
				}
			}
		}
		int max = 0, ind = 0;
		for (int i = 1; i <= n; i++) {
			if (d[i] > max) {
				max = d[i];
				ind = i;
			}
		}
		d = new int[n+1];
		Arrays.fill(d, -1);
		q = new LinkedList<Integer>();
		d[ind] = 0;
		q.add(ind);
		while (!q.isEmpty()) {
			int u = q.poll();
			for (int j : adj[u]) {
				if (d[j] == -1) {
					q.add(j);
					d[j] = d[u]+1;
				}
			}
		}
		max = 0;
		for (int i = 1; i <= n; i++) {
			max = Math.max(d[i], max);
		}
		return max;
	}
	private static int bfs(int n, LinkedList<Integer>[] adj, int u, int v) {
		int[] d = new int[n+1];
		Arrays.fill(d, -1);
		LinkedList<Integer> q = new LinkedList<Integer>();
		d[u] = 0;
		q.add(u);
		while (!q.isEmpty()) {
			u = q.poll();
			for (int j : adj[u]) {
				if (j == v)
					return d[u]+1;
				if (d[j] == -1) {
					q.add(j);
					d[j] = d[u]+1;
				}
			}
		}
		return 0;
	}
	private static String solve(BufferedReader in) throws IOException {
		int n, a, b, da, db, u, v;
		String[] tokens = in.readLine().split(" ");
		n = Integer.parseInt(tokens[0]);
		a = Integer.parseInt(tokens[1]);
		b = Integer.parseInt(tokens[2]);
		da = Integer.parseInt(tokens[3]);
		db = Integer.parseInt(tokens[4]);
		LinkedList<Integer>[] adj = new LinkedList[n+1];
		for (int i = 1; i <= n; i++)
			adj[i] = new LinkedList<Integer>();
		for (int i = 1; i < n; i++) {
			String[] path = in.readLine().split(" ");
			u = Integer.parseInt(path[0]);
			v = Integer.parseInt(path[1]);
			adj[u].add(v);
			adj[v].add(u);
		}
		if (2*da >= db)
			return "Alice";
		if (da >= bfs(n, adj, a, b))
			return "Alice";
		if (2*da >= longestPath(n, adj))
			return "Alice";
		return "Bob";
	}
	public static void main(String[] args) throws NumberFormatException, IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		int t = Integer.parseInt(in.readLine());
		for (int i = 0; i < t; i++)
			System.out.println(solve(in));
	}
}


//created by Whiplash99
import java.io.*;
import java.util.*;
public class D
{
    private static ArrayDeque<Integer>[] edge;
    private static int max, node;

    private static void DFS(int u, int p, int dist)
    {
       if(dist>max)
       {
           max=dist;
           node=u;
       }
       for(int v:edge[u])
       {
           if(v==p) continue;
           DFS(v,u,dist+1);
       }
    }
    private static int distance(int u, int p, int target, int dist)
    {
        if(u==target) return dist;

        int d=0;
        for(int v:edge[u])
        {
            if(v==p) continue;
            d+=distance(v,u,target,dist+1);
        }
        return d;
    }
    public static void main(String[] args) throws IOException
    {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

        int i,N;

        int T=Integer.parseInt(br.readLine().trim());
        StringBuilder sb=new StringBuilder();

        while (T-->0)
        {
            String[] s=br.readLine().trim().split(" ");
            N=Integer.parseInt(s[0]);
            int A=Integer.parseInt(s[1])-1;
            int B=Integer.parseInt(s[2])-1;
            int DA=Integer.parseInt(s[3]);
            int DB=Integer.parseInt(s[4]);

            edge=new ArrayDeque[N];
            for(i=0;i<N;i++) edge[i]=new ArrayDeque<>();

            for(i=0;i<N-1;i++)
            {
                s=br.readLine().trim().split(" ");
                int u=Integer.parseInt(s[0])-1;
                int v=Integer.parseInt(s[1])-1;

                edge[u].add(v);
                edge[v].add(u);
            }

            max=node=0;
            DFS(0,0,0);
            int u=node;

            max=node=0;
            DFS(u,u,0);
            int v=node;

            int diameter=distance(u,u,v,0)+1;
            boolean flag=false;

            if(distance(A,A,B,0)<=DA||2*DA>=diameter-1||DB<=2*DA)
                flag=true;

            sb.append(flag?"Alice\n":"Bob\n");
        }
        System.out.println(sb);
    }
}


import java.io.*;
import java.math.BigInteger;
import java.util.*;
import static java.lang.Math.PI;
import static java.lang.System.in;
import static java.lang.System.out;

public class B
{
    static ArrayList<ArrayList<Integer>> adj;
    static int dis[];

    static void dfs(int s, int p, int l)
    {
        dis[s] = l;
        for(int i : adj.get(s))
        {
            if(i==p)    continue;
            dfs(i, s, l+1);
        }
    }

    public static void main(String[] args) throws Exception
    {
        Foster sc = new Foster();
        PrintWriter p = new PrintWriter(out);
        int t = sc.nextInt();
        while(t--!=0)
        {
            int n = sc.nextInt(), a = sc.nextInt(), b = sc.nextInt(), da = sc.nextInt(), db = sc.nextInt();
            adj = new ArrayList<>();
            for(int i = 0; i <= n; i++)
            {
                adj.add(new ArrayList<>());
            }
            for(int i = 1; i < n; i++)
            {
                int u = sc.nextInt(), v = sc.nextInt();
                adj.get(u).add(v);
                adj.get(v).add(u);
            }
            dis = new int[n+1];
            dfs(a, 0, 0);
            if(dis[b] <= da)    //Alice reached in first move
            {
                p.println("Alice");
                continue;
            }
            int farthest = 0, maxDis = 0;
            for(int i = 1; i <= n; i++)
            {
                if(maxDis < dis[i])
                {
                    maxDis = dis[i];
                    farthest = i;
                }
            }
            dfs(farthest, 0, 0);
            int diameter = 0;
            for(int i = 1; i <= n; i++)
            {
                diameter = Math.max(diameter, dis[i]);
            }
            if(db > 2*da && diameter > 2*da)
            {
                p.println("Bob");
            }
            else
            {
                p.println("Alice");
            }
        }
        p.close();
    }
/*
*/
/*
1. Check overflow in pow function or in general
2. Check indices of read array function
3. Think of an easier solution because the problems you solve are always easy
4. Check iterator of loop
5. If still doesn't work, then jump from the 729th floor 'coz "beta tumse na ho paayega"

    Move to top!!
*/
    static class Foster
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(in));
        StringTokenizer st = new StringTokenizer("");
        String next()
        {
            while (!st.hasMoreTokens())
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                }
            return st.nextToken();
        }
        int nextInt()
        {
            return Integer.parseInt(next());
        }
        long nextLong()
        {
            return Long.parseLong(next());
        }
        double nextDouble()
        {
            return Double.parseDouble(next());
        }
        int[] intArray(int n)                   // Check indices
        {
            int arr[] = new int[n];
            for(int i = 0; i < n; i++)
            {
                arr[i] = nextInt();
            }
            return arr;
        }
        long[] longArray(int n)                 // Check indices
        {
            long arr[] = new long[n];
            for(int i = 0; i < n; i++)
            {
                arr[i] = nextLong();
            }
            return arr;
        }
        int[] getBits(int n)                    //in Reverse Order
        {
            int a[] = new int[31];
            for(int i = 0; i < 31; i++)
            {
                if(((1<<i) & n) != 0)
                    a[i] = 1;
            }
            return a;
        }
        static long pow(long... a)
        {
            long mod = Long.MAX_VALUE;
            if(a.length == 3)   mod = a[2];
            long res = 1;
            while(a[1] > 0)
            {
                if((a[1] & 1) == 1)
                    res = (res * a[0]) % mod;
                a[1] /= 2;
                a[0] = (a[0] * a[0]) % mod;
            }
            return res;
        }
        void print(Object... o)
        {
            for(Object next : o)
            {
                System.err.print(next + " ");
            }
        }
        void println(Object... o)
        {
            for(Object next : o)
            {
                System.err.print(next + " ");
            }
            System.err.println();
        }
        void watch(Object...a) throws Exception
        {
            int i = 1;
            for (Object o: a)
            {
                boolean found = false;
                if (o.getClass().isArray())
                {
                    String type = o.getClass().getName().toString();
                    switch (type)
                    {
                        case "[I":
                        {
                            int[] test = (int[]) o;
                            println(i + " : " + Arrays.toString(test));
                            break;
                        }
                        case "[[I":
                        {
                            int[][] obj = (int[][]) o;

                            println(i + " : " + Arrays.deepToString(obj));
                            break;
                        }
                        case "[J":
                        {

                            long[] obj = (long[]) o;
                            println(i + " : " + Arrays.toString(obj));
                            break;
                        }
                        case "[[J":
                        {

                            long[][] obj = (long[][]) o;
                            println(i + " : " + Arrays.deepToString(obj));
                            break;
                        }
                        case "[D":
                        {

                            double[] obj = (double[]) o;
                            println(i + " : " + Arrays.toString(obj));
                            break;
                        }
                        case "[[D":
                        {

                            double[][] obj = (double[][]) o;
                            println(i + " : " + Arrays.deepToString(obj));
                            break;
                        }
                        case "[Ljava.lang.String":
                        {

                            String[] obj = (String[]) o;
                            println(i + " : " + Arrays.toString(obj));
                            break;
                        }
                        case "[[Ljava.lang.String":
                        {

                            String[][] obj = (String[][]) o;
                            println(i + " : " + Arrays.deepToString(obj));
                            break;
                        }
                        case "[C":
                        {
                            char[] obj = (char[]) o;
                            println(i + " : " + Arrays.toString(obj));
                            break;
                        }
                        case "[[C":
                        {

                            char[][] obj = (char[][]) o;
                            println(i + " : " + Arrays.deepToString(obj));
                            break;
                        }
                        default:
                        {
                            println(i + " : type not identified");
                            break;
                        }
                    }
                    found = true;
                }
                if (o.getClass() == ArrayList.class)
                {
                    println(i + " : LIST = " + o);
                    found = true;
                }
                if (o.getClass() == TreeSet.class)
                {
                    println(i + " : SET = " + o);
                    found = true;
                }
                if (o.getClass() == TreeMap.class)
                {
                    println(i + " : MAP = " + o);
                    found = true;
                }
                if (o.getClass() == HashMap.class)
                {
                    println(i + " : MAP = " + o);
                    found = true;
                }
                if (o.getClass() == LinkedList.class)
                {
                    println(i + " : LIST = " + o);
                    found = true;
                }
                if (o.getClass() == PriorityQueue.class)
                {
                    println(i + " : PQ = " + o);
                    found = true;
                }
                if (!found)
                {
                    println(i + " = " + o);
                }
                i++;
            }
        }
    }
}


import java.io.*;
import java.util.*;

public class D
{
	static ArrayList<Integer> g[];
	static int[] visa,visb,dista,distb;

	public static void main(String[] args) throws IOException
	{

		FastReader f=new FastReader();
		StringBuffer sb=new StringBuffer();

		int test=f.nextInt();
		while(test-->0)
		{
			int n=f.nextInt();
			g=new ArrayList[n+1];
			visa=new int[n+1];
			visb=new int[n+1];
			dista=new int[n+1];
			distb=new int[n+1];

			int a=f.nextInt();
			int b=f.nextInt();

			int da=f.nextInt();
			int db=f.nextInt();

			for(int i=0;i<=n;i++)
				g[i]=new ArrayList<>();

			for(int i=1;i<n;i++)
			{
				int x=f.nextInt();
				int y=f.nextInt();

				g[x].add(y);
				g[y].add(x);
			}

			dista[0]=-1;
			dfs1(a,0);
			int dist=dista[b]-dista[a];
			if(dist<=da || db<=2*da)
			{
				sb.append("Alice\n");
				continue;
			}

			distb[0]=-1;
			dfs2(b,0);
			boolean ok=false;
			for(int i=1;i<=n;i++)
			{
				if(distb[i]>=2*da && distb[i]<=db)
					ok=true;
			}
			if(ok)
				sb.append("Bob\n");
			else
				sb.append("Alice\n");
		}
		System.out.println(sb);
	}

	static void dfs2(int n,int par)
	{
		distb[n]=distb[par]+1;
		visb[n]=1;
		for (int child : g[n])
		{
			if (visb[child]==0)
				dfs2(child,n);
		}

	}

	static void dfs1(int n,int par)
	{
		dista[n]=dista[par]+1;
		visa[n]=1;
		for (int child : g[n])
		{
			if (visa[child]==0)
				dfs1(child,n);
		}

	}

	static class FastReader
	{
	    BufferedReader br;
	    StringTokenizer st;

	    public FastReader() {
	    	br = new BufferedReader(new
	                 InputStreamReader(System.in));
	    }
	    String next() {
	        while (st == null || !st.hasMoreElements()) {
	            try{
	                st = new StringTokenizer(br.readLine());
	            }
	            catch (IOException  e) {
	                e.printStackTrace();
	            }
	        }
	        return st.nextToken();
	    }
	    int nextInt() {
	        return Integer.parseInt(next());
	    }
	    long nextLong() {
	        return Long.parseLong(next());
	    }
	    double nextDouble() {
	        return Double.parseDouble(next());
	    }
	    String nextLine() {
	        String str = "";
	        try{
	            str = br.readLine();
	        }
	        catch (IOException e) {
	            e.printStackTrace();
	        }
	        return str;
	    }
	}
}


import java.io.*;
import java.util.*;

public class D
{
	static ArrayList<Integer> g[];
	static int[] vis,dist;

	public static void main(String[] args) throws IOException
	{

		FastReader f=new FastReader();
		StringBuffer sb=new StringBuffer();

		int test=f.nextInt();
		while(test-->0)
		{
			int n=f.nextInt();
			g=new ArrayList[n+1];
			vis=new int[n+1];
			dist=new int[n+1];

			int a=f.nextInt();
			int b=f.nextInt();

			int da=f.nextInt();
			int db=f.nextInt();

			for(int i=0;i<=n;i++)
				g[i]=new ArrayList<>();

			for(int i=1;i<n;i++)
			{
				int x=f.nextInt();
				int y=f.nextInt();

				g[x].add(y);
				g[y].add(x);
			}
			dfs(a,0);
			if(-dist[a]+dist[b] <= da)
			{
				sb.append("Alice\n");
				continue;
			}
			int nr=1,mx=0;
			for(int i=1;i<=n;i++)
			{
				if(dist[i]>mx)
				{
					mx=dist[i];
					nr=i;
				}
			}
			vis=new int[n+1];
			dist=new int[n+1];
			dfs(nr,0);
			int dm=0;
			for(int i : dist)
				dm=Math.max(dm,i);
			dm--;
			if(dm<= 2*da)
			{
				sb.append("Alice\n");
				continue;
			}
			if(db>2*da)
			{
				sb.append("Bob\n");
				continue;
			}
			else
			{
				sb.append("Alice\n");
				continue;
			}
		}
		System.out.println(sb);
	}

	static void dfs(int n,int par)
	{
		dist[n]=dist[par]+1;
		vis[n] = 1;
		for (int child : g[n]) {
			if (vis[child] == 0)
				dfs(child,n);
		}

	}

	static class FastReader
	{
	    BufferedReader br;
	    StringTokenizer st;

	    public FastReader() {
	    	br = new BufferedReader(new
	                 InputStreamReader(System.in));
	    }
	    String next() {
	        while (st == null || !st.hasMoreElements()) {
	            try{
	                st = new StringTokenizer(br.readLine());
	            }
	            catch (IOException  e) {
	                e.printStackTrace();
	            }
	        }
	        return st.nextToken();
	    }
	    int nextInt() {
	        return Integer.parseInt(next());
	    }
	    long nextLong() {
	        return Long.parseLong(next());
	    }
	    double nextDouble() {
	        return Double.parseDouble(next());
	    }
	    String nextLine() {
	        String str = "";
	        try{
	            str = br.readLine();
	        }
	        catch (IOException e) {
	            e.printStackTrace();
	        }
	        return str;
	    }
	}
}


import java.io.*;
import java.util.*;

public class D
{
	static ArrayList<Integer> g[];
	static int[] visa,visb,dista,distb;

	public static void main(String[] args) throws IOException
	{

		FastReader f=new FastReader();
		StringBuffer sb=new StringBuffer();

		int test=f.nextInt();
		while(test-->0)
		{
			int n=f.nextInt();
			g=new ArrayList[n+1];
			visa=new int[n+1];
			visb=new int[n+1];
			dista=new int[n+1];
			distb=new int[n+1];

			int a=f.nextInt();
			int b=f.nextInt();

			int da=f.nextInt();
			int db=f.nextInt();

			for(int i=0;i<=n;i++)
				g[i]=new ArrayList<>();

			for(int i=1;i<n;i++)
			{
				int x=f.nextInt();
				int y=f.nextInt();

				g[x].add(y);
				g[y].add(x);
			}
			dista[0]=-1;
			dfs1(a,0);
			int dist=dista[b]-dista[a];
			if(dist<=da)
			{
//				System.out.println("dist = "+dist);
				sb.append("Alice\n");
				continue;
			}
			if(db<=2*da)
			{
				sb.append("Alice\n");
				continue;
			}
			distb[0]=-1;
			dfs2(b,0);
			boolean ok=false;
			for(int i=1;i<=n;i++)
			{
				if(distb[i]>2*da)
					ok=true;
			}
			if(ok)
				sb.append("Bob\n");
			else
				sb.append("Alice\n");
		}
		System.out.println(sb);
	}

	static void dfs2(int n,int par)
	{
		distb[n]=distb[par]+1;
		visb[n]=1;
		for (int child : g[n])
		{
			if (visb[child]==0)
				dfs2(child,n);
		}

	}

	static void dfs1(int n,int par)
	{
		dista[n]=dista[par]+1;
		visa[n]=1;
		for (int child : g[n])
		{
			if (visa[child]==0)
				dfs1(child,n);
		}

	}

	static class FastReader
	{
	    BufferedReader br;
	    StringTokenizer st;

	    public FastReader() {
	    	br = new BufferedReader(new
	                 InputStreamReader(System.in));
	    }
	    String next() {
	        while (st == null || !st.hasMoreElements()) {
	            try{
	                st = new StringTokenizer(br.readLine());
	            }
	            catch (IOException  e) {
	                e.printStackTrace();
	            }
	        }
	        return st.nextToken();
	    }
	    int nextInt() {
	        return Integer.parseInt(next());
	    }
	    long nextLong() {
	        return Long.parseLong(next());
	    }
	    double nextDouble() {
	        return Double.parseDouble(next());
	    }
	    String nextLine() {
	        String str = "";
	        try{
	            str = br.readLine();
	        }
	        catch (IOException e) {
	            e.printStackTrace();
	        }
	        return str;
	    }
	}
}


import java.io.*;
import java.util.*;

public class D
{
	static ArrayList<Integer> g[];
	static int[] visa,visb,dista,distb;

	public static void main(String[] args) throws IOException
	{

		FastReader f=new FastReader();
		StringBuffer sb=new StringBuffer();

		int test=f.nextInt();
		while(test-->0)
		{
			int n=f.nextInt();
			g=new ArrayList[n+1];
			visa=new int[n+1];
			visb=new int[n+1];
			dista=new int[n+1];
			distb=new int[n+1];

			int a=f.nextInt();
			int b=f.nextInt();

			int da=f.nextInt();
			int db=f.nextInt();

			for(int i=0;i<=n;i++)
				g[i]=new ArrayList<>();

			for(int i=1;i<n;i++)
			{
				int x=f.nextInt();
				int y=f.nextInt();

				g[x].add(y);
				g[y].add(x);
			}

			dista[0]=-1;
			dfs1(a,0);
			int dist=dista[b]-dista[a];
			if(dist<=da || db<=2*da)
			{
				sb.append("Alice\n");
				continue;
			}

			distb[0]=-1;
			dfs2(b,0);
			boolean ok=false;
			for(int i=1;i<=n;i++)
			{
				if(distb[i]>=2*da)
					ok=true;
			}
			if(ok)
				sb.append("Bob\n");
			else
				sb.append("Alice\n");
		}
		System.out.println(sb);
	}

	static void dfs2(int n,int par)
	{
		distb[n]=distb[par]+1;
		visb[n]=1;
		for (int child : g[n])
		{
			if (visb[child]==0)
				dfs2(child,n);
		}

	}

	static void dfs1(int n,int par)
	{
		dista[n]=dista[par]+1;
		visa[n]=1;
		for (int child : g[n])
		{
			if (visa[child]==0)
				dfs1(child,n);
		}

	}

	static class FastReader
	{
	    BufferedReader br;
	    StringTokenizer st;

	    public FastReader() {
	    	br = new BufferedReader(new
	                 InputStreamReader(System.in));
	    }
	    String next() {
	        while (st == null || !st.hasMoreElements()) {
	            try{
	                st = new StringTokenizer(br.readLine());
	            }
	            catch (IOException  e) {
	                e.printStackTrace();
	            }
	        }
	        return st.nextToken();
	    }
	    int nextInt() {
	        return Integer.parseInt(next());
	    }
	    long nextLong() {
	        return Long.parseLong(next());
	    }
	    double nextDouble() {
	        return Double.parseDouble(next());
	    }
	    String nextLine() {
	        String str = "";
	        try{
	            str = br.readLine();
	        }
	        catch (IOException e) {
	            e.printStackTrace();
	        }
	        return str;
	    }
	}
}


import java.io.*;
import java.util.*;

public class D
{
	static ArrayList<Integer> g[];
	static int[] visa,visb,dista,distb;

	public static void main(String[] args) throws IOException
	{

		FastReader f=new FastReader();
		StringBuffer sb=new StringBuffer();

		int test=f.nextInt();
		while(test-->0)
		{
			int n=f.nextInt();
			g=new ArrayList[n+1];
			visa=new int[n+1];
			visb=new int[n+1];
			dista=new int[n+1];
			distb=new int[n+1];

			int a=f.nextInt();
			int b=f.nextInt();

			int da=f.nextInt();
			int db=f.nextInt();

			for(int i=0;i<=n;i++)
				g[i]=new ArrayList<>();

			for(int i=1;i<n;i++)
			{
				int x=f.nextInt();
				int y=f.nextInt();

				g[x].add(y);
				g[y].add(x);
			}
			dista[0]=-1;
			dfs1(a,0);
			int dist=dista[b]-dista[a];
			if(dist<=da)
			{
				sb.append("Alice\n");
				continue;
			}
			if(db<2*da)
			{
				sb.append("Alice\n");
				continue;
			}
			distb[0]=-1;
			dfs2(b,0);
			boolean ok=false;
			for(int i=1;i<=n;i++)
			{
				if(distb[i]>2*da)
					ok=true;
			}
			if(ok)
				sb.append("Bob\n");
			else
				sb.append("Alice\n");
		}
		System.out.println(sb);
	}

	static void dfs2(int n,int par)
	{
		distb[n]=distb[par]+1;
		visb[n]=1;
		for (int child : g[n])
		{
			if (visb[child]==0)
				dfs2(child,n);
		}

	}

	static void dfs1(int n,int par)
	{
		dista[n]=dista[par]+1;
		visa[n]=1;
		for (int child : g[n])
		{
			if (visa[child]==0)
				dfs1(child,n);
		}

	}

	static class FastReader
	{
	    BufferedReader br;
	    StringTokenizer st;

	    public FastReader() {
	    	br = new BufferedReader(new
	                 InputStreamReader(System.in));
	    }
	    String next() {
	        while (st == null || !st.hasMoreElements()) {
	            try{
	                st = new StringTokenizer(br.readLine());
	            }
	            catch (IOException  e) {
	                e.printStackTrace();
	            }
	        }
	        return st.nextToken();
	    }
	    int nextInt() {
	        return Integer.parseInt(next());
	    }
	    long nextLong() {
	        return Long.parseLong(next());
	    }
	    double nextDouble() {
	        return Double.parseDouble(next());
	    }
	    String nextLine() {
	        String str = "";
	        try{
	            str = br.readLine();
	        }
	        catch (IOException e) {
	            e.printStackTrace();
	        }
	        return str;
	    }
	}
}


import java.util.*;
import java.lang.*;
// StringBuilder uses java.lang

public class mC {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        StringBuilder st = new StringBuilder();
        for (int test=0;test<t;test++) {
            int n = sc.nextInt();
            int aAt = sc.nextInt()-1;
            int bAt = sc.nextInt()-1;
            int aJump = sc.nextInt();
            int bJump = sc.nextInt();
            boolean pos = true;
            ArrayList<ArrayList<Integer>> adjList = new ArrayList<>();
            for (int i=0;i<n;i++) {
                ArrayList<Integer> temp = new ArrayList<>();
                adjList.add(temp);
            }
            for (int i=1;i<n;i++) {
                int r = sc.nextInt()-1;
                int s = sc.nextInt()-1;
                adjList.get(r).add(s);
                adjList.get(s).add(r);
            }

            if (2*aJump>=bJump) {
                pos = false;
                //System.out.println("b can't escape from a since small jump");
            } else {
                int[] verts = new int[n+3];
                verts[n]=1;
                verts=dfsTwo(aAt,bAt,0,verts,n,adjList);

                if (aJump>=-verts[n]) {
                    pos=false;
                    //System.out.println("a can reach on first move");
                } else if (verts[n+2]<=2*aJump) {
                    //System.out.println(verts[n+2]);
                    pos=false;
                    //System.out.println("b can't escape from a since tree small");
                }

            }
            if (pos == true) {
                st.append("Bob\n");
            } else {
                st.append("Alice\n");
            }

        }
        System.out.print(st.toString());
    }

    public static int findNthInArray(int[] arr,int val,int start,int o) {
        if (o==0) {
            return start-1;
        } else if (arr[start] == val) {
            return findNthInArray(arr,val,start+1,o-1);
        } else {
            return findNthInArray(arr,val,start+1,o);
        }
    }
    public static ArrayList<Integer> dfs(int at,ArrayList<Integer> went,ArrayList<ArrayList<Integer>> connect) {
        for (int i=0;i<connect.get(at).size();i++) {
            if (!(went.contains(connect.get(at).get(i)))) {
                went.add(connect.get(at).get(i));
                went=dfs(connect.get(at).get(i),went,connect);
            }
        }
        return went;
    } public static int[] dfsTwo(int at, int v, int dist, int[] went, int size, ArrayList<ArrayList<Integer>> connect) {
        int temp = went[size];
        int curFurthest = dist;// not whole tree
        int curLongestSubtree=0;
        int furthest1=-1;
        int furthest2=-2;
        for (int i=0;i<connect.get(at).size();i++) {
            if (went[connect.get(at).get(i)]==0) {
                went[connect.get(at).get(i)]=1;
                if (connect.get(at).get(i)==v) {
                    temp*=-1;
                    went[size]=temp;
                } else if (temp>=0 && went[size]>=0) {
                    went[size]=temp+1;
                }
                went[size+1]=dist;
                went[size+2]=0;
                went=dfsTwo(connect.get(at).get(i),v,dist+1,went,size,connect);
                if (went[size+1]>curFurthest) {
                    curFurthest=went[size+1];
                }
                if (went[size+1]>furthest1+dist) {
                    furthest2=furthest1;
                    furthest1=went[size+1]-dist;
                } else if (went[size+1]>furthest2+dist) {
                    furthest2=went[size+1]-dist;
                }
                if (went[size+2]>curLongestSubtree) {
                    curLongestSubtree=went[size+2];
                }
            }
        }
        went[size+1]=curFurthest;
        went[size+2]=Math.max(curLongestSubtree,furthest1+furthest2);
        return went;
    } public static int[] bfs (int at, int[] went, ArrayList<Integer> queue, int numNodes, ArrayList<ArrayList<Integer>> connect) {
        if (went[at]==0) {
            went[at]=queue.get(2*numNodes+1);
            for (int i=0;i<connect.get(at).size();i++) {
                if (went[connect.get(at).get(i)]==0) {
                    //ArrayList<Integer> temp = new ArrayList<>();
                    queue.add(connect.get(at).get(i));
                    queue.add(queue.get(2*numNodes+1)+1);
                    //queue.add(temp);
                }
            }

        }
        if (queue.size()==numNodes+1) {
            return went;
        } else {
            return bfs(queue.get(2*numNodes+2),went, queue, numNodes+1, connect);
        }
    }
    public static long fastPow(int base,long exp,long mod) {
        if (exp==0) {
            return 1;
        } else {
            if (exp % 2 == 1) {
                long z = fastPow(base,(exp-1)/2,mod);
                return ((((z*base) % mod) * z) % mod);
            } else {
                long z = fastPow(base,exp/2,mod);
                return ((z*z) % mod);
            }
        }
    }
    public static long fastPow(int base,long exp) {
        if (exp==0) {
            return 1;
        } else {
            if (exp % 2 == 1) {
                long z = fastPow(base,(exp-1)/2);
                return ((((z*base)) * z));
            } else {
                long z = fastPow(base,exp/2);
                return ((z*z));
            }
        }
    }
    public static int firstLarger(int val,ArrayList<Integer> ok,int left,int right) {
        if (ok.get(right)<=val) {
            return -1;
        }
        if (left==right) {
            return left;
        } else if (left+1==right) {
            if (val<ok.get(left)) {
                return left;
            } else {
                return right;
            }
        } else {
            int mid = (left+right)/2;
            if (ok.get(mid)>val) {
                return firstLarger(val,ok,left,mid);
            } else {
                return firstLarger(val,ok,mid+1,right);
            }
        }
    }
}


import java.util.*;
import java.lang.*;
// StringBuilder uses java.lang

public class mC {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        StringBuilder st = new StringBuilder();
        for (int test=0;test<t;test++) {
            int n = sc.nextInt();
            int aAt = sc.nextInt()-1;
            int bAt = sc.nextInt()-1;
            int aJump = sc.nextInt();
            int bJump = sc.nextInt();
            boolean pos = true;
            ArrayList<ArrayList<Integer>> adjList = new ArrayList<>();
            for (int i=0;i<n;i++) {
                ArrayList<Integer> temp = new ArrayList<>();
                adjList.add(temp);
            }
            for (int i=1;i<n;i++) {
                int r = sc.nextInt()-1;
                int s = sc.nextInt()-1;
                adjList.get(r).add(s);
                adjList.get(s).add(r);
            }

            if (2*aJump>=bJump) {
                pos = false;
                //System.out.println("b can't escape from a since small jump");
            } else {
                int[] verts = new int[n+3];
                verts[n]=1;
                verts[aAt]=1;
                verts=dfsTwo(aAt,bAt,0,verts,n,adjList);
                if (aJump>=-verts[n]) {
                    pos=false;
                    //System.out.println("a can reach on first move");
                } else if (verts[n+2]<=2*aJump) {
                    //System.out.println(verts[n+2]);
                    pos=false;
                    //System.out.println("b can't escape from a since tree small");
                }

            }
            if (pos == true) {
                st.append("Bob\n");
            } else {
                st.append("Alice\n");
            }

        }
        System.out.print(st.toString());
    }

    public static int findNthInArray(int[] arr,int val,int start,int o) {
        if (o==0) {
            return start-1;
        } else if (arr[start] == val) {
            return findNthInArray(arr,val,start+1,o-1);
        } else {
            return findNthInArray(arr,val,start+1,o);
        }
    }
    public static ArrayList<Integer> dfs(int at,ArrayList<Integer> went,ArrayList<ArrayList<Integer>> connect) {
        for (int i=0;i<connect.get(at).size();i++) {
            if (!(went.contains(connect.get(at).get(i)))) {
                went.add(connect.get(at).get(i));
                went=dfs(connect.get(at).get(i),went,connect);
            }
        }
        return went;
    } public static int[] dfsTwo(int at, int v, int dist, int[] went, int size, ArrayList<ArrayList<Integer>> connect) {
        int temp = went[size];
        int curFurthest = dist;// not whole tree
        int curLongestSubtree=0;
        int furthest1=0;
        int furthest2=0;
        for (int i=0;i<connect.get(at).size();i++) {
            if (went[connect.get(at).get(i)]==0) {
                went[connect.get(at).get(i)]=1;
                if (connect.get(at).get(i)==v) {
                    temp*=-1;
                    went[size]=temp;
                } else if (temp>=0 && went[size]>=0) {
                    went[size]=temp+1;
                }
                went[size+1]=dist;
                went[size+2]=0;
                went=dfsTwo(connect.get(at).get(i),v,dist+1,went,size,connect);
                if (went[size+1]>curFurthest) {
                    curFurthest=went[size+1];
                }
                if (went[size+1]>furthest1+dist) {
                    furthest2=furthest1;
                    furthest1=went[size+1]-dist;
                } else if (went[size+1]>furthest2+dist) {
                    furthest2=went[size+1]-dist;
                }
                if (went[size+2]>curLongestSubtree) {
                    curLongestSubtree=went[size+2];
                }
            }
        }
        went[size+1]=curFurthest;
        went[size+2]=Math.max(curLongestSubtree,furthest1+furthest2);
        return went;
    } public static int[] bfs (int at, int[] went, ArrayList<Integer> queue, int numNodes, ArrayList<ArrayList<Integer>> connect) {
        if (went[at]==0) {
            went[at]=queue.get(2*numNodes+1);
            for (int i=0;i<connect.get(at).size();i++) {
                if (went[connect.get(at).get(i)]==0) {
                    //ArrayList<Integer> temp = new ArrayList<>();
                    queue.add(connect.get(at).get(i));
                    queue.add(queue.get(2*numNodes+1)+1);
                    //queue.add(temp);
                }
            }

        }
        if (queue.size()==numNodes+1) {
            return went;
        } else {
            return bfs(queue.get(2*numNodes+2),went, queue, numNodes+1, connect);
        }
    }
    public static long fastPow(int base,long exp,long mod) {
        if (exp==0) {
            return 1;
        } else {
            if (exp % 2 == 1) {
                long z = fastPow(base,(exp-1)/2,mod);
                return ((((z*base) % mod) * z) % mod);
            } else {
                long z = fastPow(base,exp/2,mod);
                return ((z*z) % mod);
            }
        }
    }
    public static long fastPow(int base,long exp) {
        if (exp==0) {
            return 1;
        } else {
            if (exp % 2 == 1) {
                long z = fastPow(base,(exp-1)/2);
                return ((((z*base)) * z));
            } else {
                long z = fastPow(base,exp/2);
                return ((z*z));
            }
        }
    }
    public static int firstLarger(int val,ArrayList<Integer> ok,int left,int right) {
        if (ok.get(right)<=val) {
            return -1;
        }
        if (left==right) {
            return left;
        } else if (left+1==right) {
            if (val<ok.get(left)) {
                return left;
            } else {
                return right;
            }
        } else {
            int mid = (left+right)/2;
            if (ok.get(mid)>val) {
                return firstLarger(val,ok,left,mid);
            } else {
                return firstLarger(val,ok,mid+1,right);
            }
        }
    }
}


import java.util.*;
import java.lang.*;
// StringBuilder uses java.lang

public class mC {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        StringBuilder st = new StringBuilder();
        for (int test=0;test<t;test++) {
            int n = sc.nextInt();
            int aAt = sc.nextInt()-1;
            int bAt = sc.nextInt()-1;
            int aJump = sc.nextInt();
            int bJump = sc.nextInt();
            boolean pos = true;
            ArrayList<ArrayList<Integer>> adjList = new ArrayList<>();
            for (int i=0;i<n;i++) {
                ArrayList<Integer> temp = new ArrayList<>();
                adjList.add(temp);
            }
            for (int i=1;i<n;i++) {
                int r = sc.nextInt()-1;
                int s = sc.nextInt()-1;
                adjList.get(r).add(s);
                adjList.get(s).add(r);
            }

            int[] verts = new int[n+3];
            verts[n]=1;
            verts[aAt]=1;
            verts=dfsTwo(aAt,bAt,0,verts,n,adjList);
            if (aJump>=-verts[n]) {
                pos=false;
                //System.out.println("a can reach on first move");
            } else if (verts[n+2]<=2*aJump||2*aJump>=bJump) {
                //System.out.println(verts[n+2]);
                pos=false;
                //System.out.println("b can't escape from a since tree small");
            }

            if (pos == true) {
                st.append("Bob\n");
            } else {
                st.append("Alice\n");
            }

        }
        System.out.print(st.toString());
    }

    public static int findNthInArray(int[] arr,int val,int start,int o) {
        if (o==0) {
            return start-1;
        } else if (arr[start] == val) {
            return findNthInArray(arr,val,start+1,o-1);
        } else {
            return findNthInArray(arr,val,start+1,o);
        }
    }
    public static ArrayList<Integer> dfs(int at,ArrayList<Integer> went,ArrayList<ArrayList<Integer>> connect) {
        for (int i=0;i<connect.get(at).size();i++) {
            if (!(went.contains(connect.get(at).get(i)))) {
                went.add(connect.get(at).get(i));
                went=dfs(connect.get(at).get(i),went,connect);
            }
        }
        return went;
    } public static int[] dfsTwo(int at, int v, int dist, int[] went, int size, ArrayList<ArrayList<Integer>> connect) {
        int temp = went[size];
        int curFurthest = dist;// not whole tree
        int curLongestSubtree=0;
        int furthest1=0;
        int furthest2=0;
        for (int i=0;i<connect.get(at).size();i++) {
            if (went[connect.get(at).get(i)]==0) {
                went[connect.get(at).get(i)]=1;
                if (connect.get(at).get(i)==v) {
                    temp*=-1;
                    went[size]=temp;
                } else if (temp>=0 && went[size]>=0) {
                    went[size]=temp+1;
                }
                went[size+1]=dist;
                went[size+2]=0;
                went=dfsTwo(connect.get(at).get(i),v,dist+1,went,size,connect);
                if (went[size+1]>curFurthest) {
                    curFurthest=went[size+1];
                }
                if (went[size+1]>furthest1+dist) {
                    furthest2=furthest1;
                    furthest1=went[size+1]-dist;
                } else if (went[size+1]>furthest2+dist) {
                    furthest2=went[size+1]-dist;
                }
                if (went[size+2]>curLongestSubtree) {
                    curLongestSubtree=went[size+2];
                }
            }
        }
        went[size+1]=curFurthest;
        went[size+2]=Math.max(curLongestSubtree,furthest1+furthest2);
        return went;
    } public static int[] bfs (int at, int[] went, ArrayList<Integer> queue, int numNodes, ArrayList<ArrayList<Integer>> connect) {
        if (went[at]==0) {
            went[at]=queue.get(2*numNodes+1);
            for (int i=0;i<connect.get(at).size();i++) {
                if (went[connect.get(at).get(i)]==0) {
                    //ArrayList<Integer> temp = new ArrayList<>();
                    queue.add(connect.get(at).get(i));
                    queue.add(queue.get(2*numNodes+1)+1);
                    //queue.add(temp);
                }
            }

        }
        if (queue.size()==numNodes+1) {
            return went;
        } else {
            return bfs(queue.get(2*numNodes+2),went, queue, numNodes+1, connect);
        }
    }
    public static long fastPow(int base,long exp,long mod) {
        if (exp==0) {
            return 1;
        } else {
            if (exp % 2 == 1) {
                long z = fastPow(base,(exp-1)/2,mod);
                return ((((z*base) % mod) * z) % mod);
            } else {
                long z = fastPow(base,exp/2,mod);
                return ((z*z) % mod);
            }
        }
    }
    public static long fastPow(int base,long exp) {
        if (exp==0) {
            return 1;
        } else {
            if (exp % 2 == 1) {
                long z = fastPow(base,(exp-1)/2);
                return ((((z*base)) * z));
            } else {
                long z = fastPow(base,exp/2);
                return ((z*z));
            }
        }
    }
    public static int firstLarger(int val,ArrayList<Integer> ok,int left,int right) {
        if (ok.get(right)<=val) {
            return -1;
        }
        if (left==right) {
            return left;
        } else if (left+1==right) {
            if (val<ok.get(left)) {
                return left;
            } else {
                return right;
            }
        } else {
            int mid = (left+right)/2;
            if (ok.get(mid)>val) {
                return firstLarger(val,ok,left,mid);
            } else {
                return firstLarger(val,ok,mid+1,right);
            }
        }
    }
}


import java.util.*;
import java.lang.*;
// StringBuilder uses java.lang

public class mC {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        StringBuilder st = new StringBuilder();
        for (int test=0;test<t;test++) {
            int n = sc.nextInt();
            int aAt = sc.nextInt()-1;
            int bAt = sc.nextInt()-1;
            int aJump = sc.nextInt();
            int bJump = sc.nextInt();
            boolean pos = true;
            ArrayList<ArrayList<Integer>> adjList = new ArrayList<>();
            for (int i=0;i<n;i++) {
                ArrayList<Integer> temp = new ArrayList<>();
                adjList.add(temp);
            }
            for (int i=1;i<n;i++) {
                int r = sc.nextInt()-1;
                int s = sc.nextInt()-1;
                adjList.get(r).add(s);
                adjList.get(s).add(r);
            }

            int[] verts = new int[n+3];
            verts[n]=1;
            verts[aAt]=1;
            verts=dfsTwo(aAt,bAt,0,verts,n,adjList);
            if (aJump>=-verts[n]) {
                pos=false;
                //System.out.println("a can reach on first move");
            } else if (verts[n+2]<=2*aJump||2*aJump>=bJump) {
                //System.out.println(verts[n+2]);
                pos=false;
                //System.out.println("b can't escape from a since tree small");
            }

            }
            if (pos == true) {
                st.append("Bob\n");
            } else {
                st.append("Alice\n");
            }

        }
        System.out.print(st.toString());
    }

    public static int findNthInArray(int[] arr,int val,int start,int o) {
        if (o==0) {
            return start-1;
        } else if (arr[start] == val) {
            return findNthInArray(arr,val,start+1,o-1);
        } else {
            return findNthInArray(arr,val,start+1,o);
        }
    }
    public static ArrayList<Integer> dfs(int at,ArrayList<Integer> went,ArrayList<ArrayList<Integer>> connect) {
        for (int i=0;i<connect.get(at).size();i++) {
            if (!(went.contains(connect.get(at).get(i)))) {
                went.add(connect.get(at).get(i));
                went=dfs(connect.get(at).get(i),went,connect);
            }
        }
        return went;
    } public static int[] dfsTwo(int at, int v, int dist, int[] went, int size, ArrayList<ArrayList<Integer>> connect) {
        int temp = went[size];
        int curFurthest = dist;// not whole tree
        int curLongestSubtree=0;
        int furthest1=0;
        int furthest2=0;
        for (int i=0;i<connect.get(at).size();i++) {
            if (went[connect.get(at).get(i)]==0) {
                went[connect.get(at).get(i)]=1;
                if (connect.get(at).get(i)==v) {
                    temp*=-1;
                    went[size]=temp;
                } else if (temp>=0 && went[size]>=0) {
                    went[size]=temp+1;
                }
                went[size+1]=dist;
                went[size+2]=0;
                went=dfsTwo(connect.get(at).get(i),v,dist+1,went,size,connect);
                if (went[size+1]>curFurthest) {
                    curFurthest=went[size+1];
                }
                if (went[size+1]>furthest1+dist) {
                    furthest2=furthest1;
                    furthest1=went[size+1]-dist;
                } else if (went[size+1]>furthest2+dist) {
                    furthest2=went[size+1]-dist;
                }
                if (went[size+2]>curLongestSubtree) {
                    curLongestSubtree=went[size+2];
                }
            }
        }
        went[size+1]=curFurthest;
        went[size+2]=Math.max(curLongestSubtree,furthest1+furthest2);
        return went;
    } public static int[] bfs (int at, int[] went, ArrayList<Integer> queue, int numNodes, ArrayList<ArrayList<Integer>> connect) {
        if (went[at]==0) {
            went[at]=queue.get(2*numNodes+1);
            for (int i=0;i<connect.get(at).size();i++) {
                if (went[connect.get(at).get(i)]==0) {
                    //ArrayList<Integer> temp = new ArrayList<>();
                    queue.add(connect.get(at).get(i));
                    queue.add(queue.get(2*numNodes+1)+1);
                    //queue.add(temp);
                }
            }

        }
        if (queue.size()==numNodes+1) {
            return went;
        } else {
            return bfs(queue.get(2*numNodes+2),went, queue, numNodes+1, connect);
        }
    }
    public static long fastPow(int base,long exp,long mod) {
        if (exp==0) {
            return 1;
        } else {
            if (exp % 2 == 1) {
                long z = fastPow(base,(exp-1)/2,mod);
                return ((((z*base) % mod) * z) % mod);
            } else {
                long z = fastPow(base,exp/2,mod);
                return ((z*z) % mod);
            }
        }
    }
    public static long fastPow(int base,long exp) {
        if (exp==0) {
            return 1;
        } else {
            if (exp % 2 == 1) {
                long z = fastPow(base,(exp-1)/2);
                return ((((z*base)) * z));
            } else {
                long z = fastPow(base,exp/2);
                return ((z*z));
            }
        }
    }
    public static int firstLarger(int val,ArrayList<Integer> ok,int left,int right) {
        if (ok.get(right)<=val) {
            return -1;
        }
        if (left==right) {
            return left;
        } else if (left+1==right) {
            if (val<ok.get(left)) {
                return left;
            } else {
                return right;
            }
        } else {
            int mid = (left+right)/2;
            if (ok.get(mid)>val) {
                return firstLarger(val,ok,left,mid);
            } else {
                return firstLarger(val,ok,mid+1,right);
            }
        }
    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        solve(in, out);
        out.close();
    }

    static String reverse(String s) {
        return (new StringBuilder(s)).reverse().toString();
    }

    static void sieveOfEratosthenes(int n, int factors[])
    {
        factors[1]=1;
        for(int p = 2; p*p <=n; p++)
        {
            if(factors[p] == 0)
            {
                factors[p]=p;
                for(int i = p*p; i <= n; i += p)
                    factors[i] = p;
            }
        }
    }

    static void sort(int ar[]) {
        int n = ar.length;
        ArrayList<Integer> a = new ArrayList<>();
        for (int i = 0; i < n; i++)
            a.add(ar[i]);
        Collections.sort(a);
        for (int i = 0; i < n; i++)
            ar[i] = a.get(i);
    }

    static void sort1(long ar[]) {
        int n = ar.length;
        ArrayList<Long> a = new ArrayList<>();
        for (int i = 0; i < n; i++)
            a.add(ar[i]);
        Collections.sort(a);
        for (int i = 0; i < n; i++)
            ar[i] = a.get(i);
    }

    static long ncr(long n, long r, long mod) {
        if (r == 0)
            return 1;
        long val = ncr(n - 1, r - 1, mod);
        val = (n * val) % mod;
        val = (val * modInverse(r, mod)) % mod;
        return val;
    }

    public static void solve(InputReader sc, PrintWriter pw) {
        int i, j = 0;
        // int t = 1;
        int t = sc.nextInt();
        u: while (t-- > 0) {
            int n = sc.nextInt();
            int a = sc.nextInt()-1;
            int b = sc.nextInt()-1;
            int da = sc.nextInt();
            int db = sc.nextInt();
            ArrayList<Integer> ar[] = new ArrayList[n];
            for(i=0;i<n;i++){
                ar[i] = new ArrayList<>();
            }
            for(i=0;i<n-1;i++){
                int n1 = sc.nextInt()-1;
                int n2 = sc.nextInt()-1;
                ar[n1].add(n2);
                ar[n2].add(n1);
            }
            int vis[] = new int[n];
            dist = -1;
            find(ar,a,b,0,vis);
            if(2*da>=db||da>=dist){
                pw.println("Alice");
                continue u;
            }
            vis = new int[n];
            ArrayList<Integer> arr = new ArrayList<>();
            arr.add(0);
            arr.add(0);
            vis[b] = 1;
            for(int l:ar[b]){
                arr.add(longest(arr,l,vis,ar,1));
            }
            Collections.sort(arr);
            int len = arr.size();
            // pw.println(arr.get(len-1)+" "+arr.get(len-2));
            if(arr.get(len-1)+arr.get(len-2)+1<=2*da+1){
                pw.println("Alice");
                continue u;
            }
            pw.println("Bob");
        }
    }

    static int longest(ArrayList<Integer> arr, int a, int vis[], ArrayList<Integer> ar[], int c){
        if(vis[a]==1)
            return 0;
        int max = c;
        vis[a] = 1;
        for(int l:ar[a]){
            max = Math.max(max,c+longest(arr,l,vis,ar,c));
        }
        return max;
    }

    static void find(ArrayList<Integer> ar[], int a, int b, int c, int vis[]){
        if(vis[a]==1||dist>=0)
            return;
        if(a==b){
            vis[a] = 1;
            dist = c;
            return;
        }
        vis[a] = 1;
        for(int l:ar[a]){
            find(ar,l,b,c+1,vis);
        }
    }

    static int dist = 0;

    // static void fill(int vis[], int l, int curr, int d, ArrayList<Integer> ar[]){
    //     if(curr==0){
    //         if(vis[l]==1)
    //             return;
    //         vis[l] = 1;
    //         for(int ll:ar[l])
    //             fill(vis,ll,d-1,d,ar);
    //     }
    //     for(int ll:ar[l])
    //         fill(vis,ll,curr-1,d,ar);
    // }

    static class Pair implements Comparable<Pair> {
        int a;
        int b;
        // int c;

        Pair(int a, int b) {
            this.a = a;
            this.b = b;
        }

        public int compareTo(Pair p) {
            if(a!=p.a)
                return p.a-a;
            return b-p.b;
        }
    }

    static boolean isPrime(long n) {
        if (n <= 1)
            return false;
        if (n <= 3)
            return true;
        if (n % 2 == 0 || n % 3 == 0)
            return false;
        for (int i = 5; i * i <= n; i = i + 6)
            if (n % i == 0 || n % (i + 2) == 0)
                return false;
        return true;
    }

    static long gcd(long a, long b) {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }

    static long fast_pow(long base, long n, long M) {
        if (n == 0)
            return 1;
        if (n == 1)
            return base % M;
        long halfn = fast_pow(base, n / 2, M);
        if (n % 2 == 0)
            return (halfn * halfn) % M;
        else
            return (((halfn * halfn) % M) * base) % M;
    }

    static long modInverse(long n, long M) {
        return fast_pow(n, M - 2, M);
    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }
    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        solve(in, out);
        out.close();
    }

    static String reverse(String s) {
        return (new StringBuilder(s)).reverse().toString();
    }

    static void sieveOfEratosthenes(int n, int factors[])
    {
        factors[1]=1;
        for(int p = 2; p*p <=n; p++)
        {
            if(factors[p] == 0)
            {
                factors[p]=p;
                for(int i = p*p; i <= n; i += p)
                    factors[i] = p;
            }
        }
    }

    static void sort(int ar[]) {
        int n = ar.length;
        ArrayList<Integer> a = new ArrayList<>();
        for (int i = 0; i < n; i++)
            a.add(ar[i]);
        Collections.sort(a);
        for (int i = 0; i < n; i++)
            ar[i] = a.get(i);
    }

    static void sort1(long ar[]) {
        int n = ar.length;
        ArrayList<Long> a = new ArrayList<>();
        for (int i = 0; i < n; i++)
            a.add(ar[i]);
        Collections.sort(a);
        for (int i = 0; i < n; i++)
            ar[i] = a.get(i);
    }

    static long ncr(long n, long r, long mod) {
        if (r == 0)
            return 1;
        long val = ncr(n - 1, r - 1, mod);
        val = (n * val) % mod;
        val = (val * modInverse(r, mod)) % mod;
        return val;
    }

    public static void solve(InputReader sc, PrintWriter pw) {
        int i, j = 0;
        // int t = 1;
        int t = sc.nextInt();
        u: while (t-- > 0) {
            int n = sc.nextInt();
            int a = sc.nextInt()-1;
            int b = sc.nextInt()-1;
            int da = sc.nextInt();
            int db = sc.nextInt();
            ArrayList<Integer> ar[] = new ArrayList[n];
            for(i=0;i<n;i++){
                ar[i] = new ArrayList<>();
            }
            for(i=0;i<n-1;i++){
                int n1 = sc.nextInt()-1;
                int n2 = sc.nextInt()-1;
                ar[n1].add(n2);
                ar[n2].add(n1);
            }
            int vis[] = new int[n];
            dist = -1;
            find(ar,a,b,0,vis);
            if(2*da>=db||da>=dist){
                pw.println("Alice");
                continue u;
            }
            vis = new int[n];
            ArrayList<Integer> arr = new ArrayList<>();
            arr.add(0);
            arr.add(0);
            vis[b] = 1;
            l1 = 1;
            for(int l:ar[b]){
                arr.add(longest(l,vis,ar,1));
            }
            Collections.sort(arr);
            int len = arr.size();
            l1 = Math.max(l1,1+arr.get(len-1)+arr.get(len-2));
            // pw.println(l1);
            if(l1<=2*da+1){
                pw.println("Alice");
                continue u;
            }
            pw.println("Bob");
        }
    }

    static int l1;

    static int longest(int a, int vis[], ArrayList<Integer> ar[], int c){
        if(vis[a]==1)
            return 0;
        int max = c;
        vis[a] = 1;
        ArrayList<Integer> arr1 = new ArrayList<>();
        arr1.add(0);
        arr1.add(0);
        for(int l:ar[a]){
            int y = longest(l,vis,ar,c);
            max = Math.max(max,c+y);
            arr1.add(y);
        }
        Collections.sort(arr1);
        int len = arr1.size();
        l1 = Math.max(l1,1+arr1.get(len-1)+arr1.get(len-2));
        return max;
    }

    static void find(ArrayList<Integer> ar[], int a, int b, int c, int vis[]){
        if(vis[a]==1||dist>=0)
            return;
        if(a==b){
            vis[a] = 1;
            dist = c;
            return;
        }
        vis[a] = 1;
        for(int l:ar[a]){
            find(ar,l,b,c+1,vis);
        }
    }

    static int dist = 0;

    // static void fill(int vis[], int l, int curr, int d, ArrayList<Integer> ar[]){
    //     if(curr==0){
    //         if(vis[l]==1)
    //             return;
    //         vis[l] = 1;
    //         for(int ll:ar[l])
    //             fill(vis,ll,d-1,d,ar);
    //     }
    //     for(int ll:ar[l])
    //         fill(vis,ll,curr-1,d,ar);
    // }

    static class Pair implements Comparable<Pair> {
        int a;
        int b;
        // int c;

        Pair(int a, int b) {
            this.a = a;
            this.b = b;
        }

        public int compareTo(Pair p) {
            if(a!=p.a)
                return p.a-a;
            return b-p.b;
        }
    }

    static boolean isPrime(long n) {
        if (n <= 1)
            return false;
        if (n <= 3)
            return true;
        if (n % 2 == 0 || n % 3 == 0)
            return false;
        for (int i = 5; i * i <= n; i = i + 6)
            if (n % i == 0 || n % (i + 2) == 0)
                return false;
        return true;
    }

    static long gcd(long a, long b) {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }

    static long fast_pow(long base, long n, long M) {
        if (n == 0)
            return 1;
        if (n == 1)
            return base % M;
        long halfn = fast_pow(base, n / 2, M);
        if (n % 2 == 0)
            return (halfn * halfn) % M;
        else
            return (((halfn * halfn) % M) * base) % M;
    }

    static long modInverse(long n, long M) {
        return fast_pow(n, M - 2, M);
    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }
    }
}


/* package codechef; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Codechef
{
	public static void main (String[] args) throws java.lang.Exception
	{
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		int T = sc.nextInt();
		for(int t = 0; t<T; t++){
		    int n = sc.nextInt(), aS = sc.nextInt() - 1, bS = sc.nextInt() - 1, aDis = sc.nextInt(), bDis = sc.nextInt();
		    Node nodes[] = new Node[n];
		    for(int i = 0; i<n; i++)nodes[i] = new Node();
		    for(int i = 0; i<n - 1; i++){
		        int g = sc.nextInt() - 1, h = sc.nextInt() - 1;
		        nodes[g].adj.add(nodes[h]); nodes[h].adj.add(nodes[g]);
		    }
		    if(aDis * 2 >= bDis){
		        out.println("Alice"); continue;
		    }
		    BFS(nodes, nodes[bS]);
		    if (nodes[aS].dis<=aDis) {
				//alice wins in one move
				out.println("Alice");
				continue;
			}
		    int farDist = farthest(nodes).dis;
		    if(farDist <= aDis * 2)out.println("Alice");
		    else out.println("Bob");
		}
		out.flush();
	}
	static Node farthest(Node[] nodes){
	    Node ans = nodes[0];
	    for(Node nn: nodes){
	        if(nn.dis > ans.dis)ans = nn;
	    }
	    return ans;
	}
	static void BFS(Node nodes[], Node prev){
	    for (Node nn:nodes) nn.dis=-1;
	    Queue<Node> queue = new LinkedList();
	    queue.add(prev);
	    prev.dis = 0;
	    while(!queue.isEmpty()){
	        Node par = queue.poll();
	        for(Node c: par.adj){
	            if(c.dis == -1){
	                c.dis = par.dis + 1;
	                queue.add(c);
	            }
	        }
	    }
	}
	static class Node{
	    List<Node> adj = new ArrayList();
	    int dis = -1;
	}
}


/* package codechef; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Codechef
{
	public static void main (String[] args) throws java.lang.Exception
	{
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		int T = sc.nextInt();
		for(int t = 0; t<T; t++){
		    int n = sc.nextInt(), aS = sc.nextInt() - 1, bS = sc.nextInt() - 1, aDis = sc.nextInt(), bDis = sc.nextInt();
		    Node nodes[] = new Node[n];
		    for(int i = 0; i<n; i++)nodes[i] = new Node();
		    for(int i = 0; i<n - 1; i++){
		        int g = sc.nextInt() - 1, h = sc.nextInt() - 1;
		        nodes[g].adj.add(nodes[h]); nodes[h].adj.add(nodes[g]);
		    }
		    if(aDis * 2 >= bDis){
		        out.println("Alice"); continue;
		    }
		    BFS(nodes, nodes[bS]);
		    if (nodes[aStart].dist<=aDist) {
				//alice wins in one move
				out.println("Alice");
				continue;
			}
		    int farDist = farthest(nodes).dis;
		    if(farDist <= aDis * 2)out.println("Alice");
		    else out.println("Bob");
		}
		out.flush();
	}
	static Node farthest(Node[] nodes){
	    Node ans = nodes[0];
	    for(Node nn: nodes){
	        if(nn.dis > ans.dis)ans = nn;
	    }
	    return ans;
	}
	static void BFS(Node nodes[], Node prev){
	    for (Node nn:nodes) nn.dis=-1;
	    Queue<Node> queue = new LinkedList();
	    queue.add(prev);
	    prev.dis = 0;
	    while(!queue.isEmpty()){
	        Node par = queue.poll();
	        for(Node c: par.adj){
	            if(c.dis == -1){
	                c.dis = par.dis + 1;
	                queue.add(c);
	            }
	        }
	    }
	}
	static class Node{
	    List<Node> adj = new ArrayList();
	    int dis = -1;
	}
}


/* package codechef; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Codechef
{
	public static void main (String[] args) throws java.lang.Exception
	{
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		int T = sc.nextInt();
		for(int t = 0; t<T; t++){
		    int n = sc.nextInt(), aS = sc.nextInt() - 1, bS = sc.nextInt() - 1, aDis = sc.nextInt(), bDis = sc.nextInt();
		    Node nodes[] = new Node[n];
		    for(int i = 0; i<n; i++)nodes[i] = new Node();
		    for(int i = 0; i<n - 1; i++){
		        int g = sc.nextInt() - 1, h = sc.nextInt() - 1;
		        nodes[g].adj.add(nodes[h]); nodes[h].adj.add(nodes[g]);
		    }
		    if(aDis * 2 >= bDis){
		        out.println("Alice"); continue;
		    }
		    BFS(nodes, nodes[bS]);
		    int farDist = farthest(nodes).dis;
		    if(farDist <= aDis * 2)out.println("Alice");
		    else out.println("Bob");
		}
		out.flush();
	}
	static Node farthest(Node[] nodes){
	    Node ans = nodes[0];
	    for(Node nn: nodes){
	        if(nn.dis > ans.dis)ans = nn;
	    }
	    return ans;
	}
	static void BFS(Node nodes[], Node prev){
	    for (Node nn:nodes) nn.dis=-1;
	    Queue<Node> queue = new LinkedList();
	    queue.add(prev);
	    prev.dis = 0;
	    while(!queue.isEmpty()){
	        Node par = queue.poll();
	        for(Node c: par.adj){
	            if(c.dis == -1){
	                c.dis = par.dis + 1;
	                queue.add(c);
	            }
	        }
	    }
	}
	static class Node{
	    List<Node> adj = new ArrayList();
	    int dis = -1;
	}
}


/* package codechef; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Codechef
{
	public static void main (String[] args) throws java.lang.Exception
	{
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		int T = sc.nextInt();
		for(int t = 0; t<T; t++){
		    int n = sc.nextInt(), aS = sc.nextInt() - 1, bS = sc.nextInt() - 1, aDis = sc.nextInt(), bDis = sc.nextInt();
		    Node nodes[] = new Node[n];
		    for(int i = 0; i<n; i++)nodes[i] = new Node();
		    for(int i = 0; i<n - 1; i++){
		        int g = sc.nextInt() - 1, h = sc.nextInt() - 1;
		        nodes[g].adj.add(nodes[h]); nodes[h].adj.add(nodes[g]);
		    }
		    if(aDis * 2 >= bDis){
		        out.println("Alice"); continue;
		    }
		    BFS(nodes, nodes[bS]);
		    if (nodes[aS].dis<=aDis) {
				//alice wins in one move
				out.println("Alice");
				continue;
			}
			Node farthest=farthest(nodes);
			BFS(nodes, farthest);
			farthest=farthest(nodes);
			int farDist = farthest.dis;
		    if(farDist <= aDis * 2)out.println("Alice");
		    else out.println("Bob");
		}
		out.flush();
	}
	static Node farthest(Node[] nodes){
	    Node ans = nodes[0];
	    for(Node nn: nodes){
	        if(nn.dis > ans.dis)ans = nn;
	    }
	    return ans;
	}
	static void BFS(Node nodes[], Node prev){
	    for (Node nn:nodes) nn.dis=-1;
	    Queue<Node> queue = new LinkedList();
	    queue.add(prev);
	    prev.dis = 0;
	    while(!queue.isEmpty()){
	        Node par = queue.poll();
	        for(Node c: par.adj){
	            if(c.dis == -1){
	                c.dis = par.dis + 1;
	                queue.add(c);
	            }
	        }
	    }
	}
	static class Node{
	    List<Node> adj = new ArrayList();
	    int dis = -1;
	}
}


import java.io.*;
import java.util.*;

public class Coding {

    static long MOD = 1000000007;
    static long[] fact = new long[100002];
    static long[] pow2 = new long[100002];

    public static void main(String[] args) {
        BufferedReader bi = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out));
        //precompute();
        try {
            int t = Integer.parseInt(bi.readLine());
            while (t > 0) {
               String[] inputs = bi.readLine().split(" ");
               int n = Integer.parseInt(inputs[0].trim());
               int a = Integer.parseInt(inputs[1].trim());
               int b = Integer.parseInt(inputs[2].trim());
               int da = Integer.parseInt(inputs[3].trim());
               int db = Integer.parseInt(inputs[4].trim());
               int[] par = new int[n+1];
               int[] dep = new int[n+1];
               List<Integer>[] adj = new ArrayList[n+1];
               for(int i=0;i<=n;++i) {
                   adj[i] = new ArrayList<>();
                   par[i] = -1;
                   dep[i] = 0;
               }
               for(int i=1;i<=n-1;++i) {
                   String input = bi.readLine();
                   int x = Integer.parseInt(input.split(" ")[0].trim());
                   int y = Integer.parseInt(input.split(" ")[1].trim());
                   adj[x].add(y);
                   adj[y].add(x);
               }
               dfs(1, adj, par, dep,-1);
               int dist = findDist(a, b, par);
               if (dist<=da) {
                   writer.append("Alice");
               } else {
                   int diameter = findLongestPath(1, -1, adj, dep);
                   if (2*da>=diameter) {
                       writer.append("Alice");
                   } else {
                       if (db>2*da) {
                           writer.append("Bob");
                       } else {
                           writer.append("Alice");
                       }
                   }
               }
               writer.append('\n');
               writer.flush();
               t--;
            }
            writer.flush();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static void dfs(int cur, List<Integer>[] adj, int[] par, int[] dep, int parent) {
        par[cur] = parent;
        for(int i=0;i<adj[cur].size();++i) {
            int nxt = adj[cur].get(i);
            if (nxt!=parent) {
                dfs(nxt, adj, par, dep, cur);
                dep[cur] = Math.max(dep[cur], dep[nxt]+1);
            }
        }
    }

    private static int findDist(int a, int b, int[] par) {
        Map<Integer, Integer> dist = new HashMap<>();
        int count = 0;
        dist.put(a, 0);
        while (par[a]!=-1) {
            a = par[a];
            count++;
            dist.put(a, count);
        }
        count=0;
        while(!dist.containsKey(b)) {
            b = par[b];
            count++;
        }
        return count+dist.get(b);
    }

    private static int findLongestPath(int cur, int prev, List<Integer>[] adj, int[] dep) {
        int diameter = 0;
        int highest = -1, second=-1;
        for(int i=0;i<adj[cur].size();++i) {
            int nxt = adj[cur].get(i);
            if (nxt!=prev) {
                diameter = Math.max(diameter, findLongestPath(nxt, cur, adj, dep));
            }
            if (dep[nxt]>highest) {
                highest = dep[nxt];
                second = highest;
            } else if (dep[nxt]>second) {
                second = dep[nxt];
            }
        }
        diameter = Math.max(diameter, highest + second + 2);
        return diameter;
    }

    static long ncr(int n, int r) {
        long num = fact[n];
        long denom = (modExp(fact[r], MOD-2)*modExp(fact[n-r], MOD-2))%MOD;
        //System.out.println("num is " + num + " denom is" + denom);
        return (num*denom)%MOD;
    }

    static long modExp(long a, long b) {
        //System.out.println("a is " + a + " and b is " + b);
        if (a==1) return 1;
        long ans = 1;
        while (b!=0) {
            if (b%2==1) {
                ans = (ans*a)%MOD;
            }
            a = (a*a)%MOD;
            b/=2;
        }
        return ans;
    }

    private static void precompute() {
        fact[0] = 1;
        pow2[0] = 1;
        for(int i=1;i<=100000;++i) {
            fact[i] = (fact[i-1]*i)%MOD;
            pow2[i] = (pow2[i-1]*2)%MOD;
        }
    }
}