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

public class TreeTag668D{
	static class FastReader {

        BufferedReader br;
        StringTokenizer st;

        private 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());
        }

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

	int[] nextIntArrayOne(int n) {
				int[] a = new int[n+1];
				for (int i = 1; i < n+1; i++)
					a[i] = nextInt();
				return a;
	}

        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;
        }
    }

	public static void main(String[] args) {
		FastReader s =new FastReader();
		int t = s.nextInt();
		StringBuilder str = new StringBuilder();

		while(t-- >0) {
			int n = s.nextInt(), alice = s.nextInt() - 1, bob = s.nextInt() - 1, da = s.nextInt(), db = s.nextInt();
			ArrayList<ArrayList<Integer>> tree = new ArrayList<>();

			for(int i = 0; i < n; i++) {
				tree.add(new ArrayList<Integer>());
			}

			for(int i = 1; i <= n - 1; i++) {

				int u = s.nextInt() - 1, v = s.nextInt() - 1;

				tree.get(u).add(v);
				tree.get(v).add(u);

			}

			boolean answer = false; // true means alice wins

			// in range

			int dist[] = new int[n];

			int farthest = 0, max = 0;
			for(int i = 0; i<n; i++) {

				if(dist[i] >= max) {
					max = dist[i];
					farthest = i;
				}
			}

			dfs(alice,alice,tree,dist,1);
			//when i can trap bob
			if(db <= 2 *da) answer = true;

			// when i can reach every node in tree
			if(dist[bob] <= da) answer = true;

			int diameter = -1;
			Arrays.fill(dist, 0);
			dfs(farthest, farthest, tree, dist, 0);

			for(int i = 0; i< n; i++) {
				diameter = Math.max(diameter, dist[i]);
			}

			if(da * 2 >= diameter) answer = true;

			if(answer) str.append("Alice\n"); else str.append("Bob\n");

		}

		System.out.println(str);
	}

	private static void dfs(int src, int parent, ArrayList<ArrayList<Integer>> tree, int[] dist, int depth) {
		dist[src] = depth;
		List<Integer> nbrs = tree.get(src);

		for(int nbr : nbrs) {
			if(nbr != parent) {
				dfs(nbr,src,tree,dist,depth + 1);
			}
		}

	}

}


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

public class TreeTag668D{
	static class FastReader {

        BufferedReader br;
        StringTokenizer st;

        private 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());
        }

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

	int[] nextIntArrayOne(int n) {
				int[] a = new int[n+1];
				for (int i = 1; i < n+1; i++)
					a[i] = nextInt();
				return a;
	}

        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;
        }
    }

	public static void main(String[] args) {
		FastReader s =new FastReader();
		int t = s.nextInt();
		StringBuilder str = new StringBuilder();

		while(t-- >0) {
			int n = s.nextInt(), alice = s.nextInt() - 1, bob = s.nextInt() - 1, da = s.nextInt(), db = s.nextInt();
			ArrayList<ArrayList<Integer>> tree = new ArrayList<>();

			for(int i = 0; i < n; i++) {
				tree.add(new ArrayList<Integer>());
			}

			for(int i = 1; i <= n - 1; i++) {

				int u = s.nextInt() - 1, v = s.nextInt() - 1;

				tree.get(u).add(v);
				tree.get(v).add(u);

			}

	            int dis[] = new int[n];
	            dfs(alice, alice, tree,dis,0);

	            if(dis[bob] <= da)
	            {
	               str.append("Alice\n");
	                continue;
	            }

	            int farthest = 0, maxDis = 0;
	            for(int i = 0; i < n; i++)
	            {
	                if(maxDis < dis[i])
	                {
	                    maxDis = dis[i];
	                    farthest = i;
	                }
	            }
	            dfs(farthest, farthest, tree,dis, 0);
	            int diameter = 0;
	            for(int i = 0; i < n; i++)
	            {
	                diameter = Math.max(diameter, dis[i]);
	            }
	            boolean answer = false;
	            if(da * 2 >= diameter) answer = true;

				//when i can trap bob

				if(db <= 2 *da) answer = true;

				if(answer) str.append("Alice\n"); else str.append("Bob\n");

		}

		System.out.println(str);
	}

	private static void dfs(int src, int parent, ArrayList<ArrayList<Integer>> tree, int[] dist, int depth) {
		dist[src] = depth;
		List<Integer> nbrs = tree.get(src);

		for(int nbr : nbrs) {
			if(nbr != parent) {
				dfs(nbr,src,tree,dist,depth + 1);
			}
		}

	}

}


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

public class TreeTag668D{
	static class FastReader {

        BufferedReader br;
        StringTokenizer st;

        private 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());
        }

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

	int[] nextIntArrayOne(int n) {
				int[] a = new int[n+1];
				for (int i = 1; i < n+1; i++)
					a[i] = nextInt();
				return a;
	}

        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;
        }
    }

	public static void main(String[] args) {
		FastReader s =new FastReader();
		int t = s.nextInt();
		StringBuilder str = new StringBuilder();

		while(t-- >0) {
			   int n = s.nextInt(), a = s.nextInt(), b = s.nextInt(), da = s.nextInt(), db = s.nextInt();
			   ArrayList<ArrayList<Integer>> tree = new ArrayList<>();
	            for(int i = 0; i <= n; i++)
	            {
	                tree.add(new ArrayList<>());
	            }
	            for(int i = 1; i < n; i++)
	            {
	                int u = s.nextInt(), v = s.nextInt();
	                tree.get(u).add(v);
	                tree.get(v).add(u);
	            }
	            int dis[] = new int[n+1];
	            dfs(a, a, tree,dis,0);
	            if(dis[b] <= da)
	            {
	               str.append("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, farthest, tree,dis, 0);
	            int diameter = 0;
	            for(int i = 1; i <= n; i++)
	            {
	                diameter = Math.max(diameter, dis[i]);
	            }
	            if(db > 2*da && diameter > 2*da)
	            {
	                str.append("Bob\n");
	            }
	            else
	            {
	                str.append("Alice\n");
	            }

		}

		System.out.println(str);
	}

	private static void dfs(int src, int parent, ArrayList<ArrayList<Integer>> tree, int[] dist, int depth) {
		dist[src] = depth;
		List<Integer> nbrs = tree.get(src);

		for(int nbr : nbrs) {
			if(nbr != parent) {
				dfs(nbr,src,tree,dist,depth + 1);
			}
		}

	}

}


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

public class TreeTag668D{
	static class FastReader {

        BufferedReader br;
        StringTokenizer st;

        private 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());
        }

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

	int[] nextIntArrayOne(int n) {
				int[] a = new int[n+1];
				for (int i = 1; i < n+1; i++)
					a[i] = nextInt();
				return a;
	}

        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;
        }
    }

	public static void main(String[] args) {
		FastReader s =new FastReader();
		int t = s.nextInt();
		StringBuilder str = new StringBuilder();

		while(t-- >0) {
			   int n = s.nextInt(), a = s.nextInt(), b = s.nextInt(), da = s.nextInt(), db = s.nextInt();
			   ArrayList<ArrayList<Integer>> tree = new ArrayList<>();
	            for(int i = 0; i <= n; i++)
	            {
	                tree.add(new ArrayList<>());
	            }
	            for(int i = 1; i < n; i++)
	            {
	                int u = s.nextInt(), v = s.nextInt();
	                tree.get(u).add(v);
	                tree.get(v).add(u);
	            }
	            int dis[] = new int[n+1];
	            dfs(a, a, tree,dis,0);
	            if(dis[b] <= da)
	            {
	               str.append("Alice\n");
	                continue;
	            }
	            int farthest = 0, maxDis = 0;
	            for(int i = 1; i <= n; i++)
	            {
	                if(maxDis < dis[i])
	                {
	                    maxDis = dis[i];
	                    farthest = i;
	                }
	            }
	            dfs(farthest, farthest, tree,dis, 0);
	            int diameter = 0;
	            for(int i = 1; i <= n; i++)
	            {
	                diameter = Math.max(diameter, dis[i]);
	            }
	            if(db > 2*da && diameter > 2*da)
	            {
	                str.append("Bob\n");
	            }
	            else
	            {
	                str.append("Alice\n");
	            }

		}

		System.out.println(str);
	}

	private static void dfs(int src, int parent, ArrayList<ArrayList<Integer>> tree, int[] dist, int depth) {
		dist[src] = depth;
		List<Integer> nbrs = tree.get(src);

		for(int nbr : nbrs) {
			if(nbr != parent) {
				dfs(nbr,src,tree,dist,depth + 1);
			}
		}

	}

}


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

public class TreeTag668D{
	static class FastReader {

        BufferedReader br;
        StringTokenizer st;

        private 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());
        }

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

	int[] nextIntArrayOne(int n) {
				int[] a = new int[n+1];
				for (int i = 1; i < n+1; i++)
					a[i] = nextInt();
				return a;
	}

        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;
        }
    }

	public static void main(String[] args) {
		FastReader s =new FastReader();
		int t = s.nextInt();
		StringBuilder str = new StringBuilder();

		while(t-- >0) {
			int n = s.nextInt(), alice = s.nextInt() - 1, bob = s.nextInt() - 1, da = s.nextInt(), db = s.nextInt();
			ArrayList<ArrayList<Integer>> tree = new ArrayList<>();

			for(int i = 0; i < n; i++) {
				tree.add(new ArrayList<Integer>());
			}

			for(int i = 1; i <= n - 1; i++) {

				int u = s.nextInt() - 1, v = s.nextInt() - 1;

				tree.get(u).add(v);
				tree.get(v).add(u);

			}

			boolean answer = false; // true means alice wins

			// in range

			int dist[] = new int[n];

			int farthest = 0, max = 0;
			for(int i = 0; i<n; i++) {
				if(dist[i] >= max) {
					max = dist[i];
					farthest = i;
				}
			}

			dfs(alice,alice,tree,dist,1);

			if(dist[bob] <= da) answer = true;

			// when i can reach every node in tree

			int diameter = -1;
			Arrays.fill(dist, 0);
			dfs(farthest, farthest, tree, dist, 1);

			for(int i = 0; i< n; i++) {
				diameter = Math.max(diameter, dist[i]);
			}

			if(da * 2 >= diameter) answer = true;

			//when i can trap bob

			if(db <= 2 *da) answer = true;

			if(answer) str.append("Alice\n"); else str.append("Bob\n");

		}

		System.out.println(str);
	}

	private static void dfs(int src, int parent, ArrayList<ArrayList<Integer>> tree, int[] dist, int depth) {

		List<Integer> nbrs = tree.get(src);

		for(int nbr : nbrs) {
			if(nbr != parent) {
				dist[nbr] = depth;
				dfs(nbr,src,tree,dist,depth + 1);
			}
		}

	}

}


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

public class TreeTag668D{
	static class FastReader {

        BufferedReader br;
        StringTokenizer st;

        private 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());
        }

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

	int[] nextIntArrayOne(int n) {
				int[] a = new int[n+1];
				for (int i = 1; i < n+1; i++)
					a[i] = nextInt();
				return a;
	}

        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;
        }
    }

	public static void main(String[] args) {
		FastReader s =new FastReader();
		int t = s.nextInt();
		StringBuilder str = new StringBuilder();

		while(t-- >0) {
			int n = s.nextInt(), alice = s.nextInt() - 1, bob = s.nextInt() - 1, da = s.nextInt(), db = s.nextInt();
			ArrayList<ArrayList<Integer>> tree = new ArrayList<>();

			for(int i = 0; i < n; i++) {
				tree.add(new ArrayList<Integer>());
			}

			for(int i = 1; i <= n - 1; i++) {

				int u = s.nextInt() - 1, v = s.nextInt() - 1;

				tree.get(u).add(v);
				tree.get(v).add(u);

			}

			boolean answer = false; // true means alice wins

			// in range

			int dist[] = new int[1];

			dfs(alice,alice,tree,dist,1,bob);

			if(dist[0] <= da) answer = true;

			// when i can reach every node in tree

			int farthest = dfs(alice,tree,new boolean[n]);
			int diameter = dfs(farthest,tree,new boolean[n]);

			if(da * 2 >= diameter) answer = true;

			//when i can trap bob

			if(db <= 2 *da) answer = true;

			if(answer) str.append("Alice\n"); else str.append("Bob\n");

		}

		System.out.println(str);
	}

	private static int dfs(int src, ArrayList<ArrayList<Integer>> tree, boolean[] bs) {
		List<Integer> nbrs = tree.get(src);
		bs[src] = true;
		int dist = 0;
		for(int nbr : nbrs) {
			if(!bs[nbr]) {

				dist = Math.max(dist, dfs(nbr,tree,bs) + 1);
			}
		}

		return dist;
	}

	private static void dfs(int src, int parent, ArrayList<ArrayList<Integer>> tree, int[] dist, int depth, int bob) {

		List<Integer> nbrs = tree.get(src);

		for(int nbr : nbrs) {
			if(nbr != parent) {
				if(nbr == bob ) dist[0] = depth;
				dfs(nbr,src,tree,dist,depth + 1,bob);
			}
		}

	}

}


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

public class TreeTag668D{
	static class FastReader {

        BufferedReader br;
        StringTokenizer st;

        private 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());
        }

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

	int[] nextIntArrayOne(int n) {
				int[] a = new int[n+1];
				for (int i = 1; i < n+1; i++)
					a[i] = nextInt();
				return a;
	}

        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;
        }
    }

	public static void main(String[] args) {
		FastReader s =new FastReader();
		int t = s.nextInt();
		StringBuilder str = new StringBuilder();

		while(t-- >0) {
			int n = s.nextInt(), alice = s.nextInt() - 1, bob = s.nextInt() - 1, da = s.nextInt(), db = s.nextInt();
			ArrayList<ArrayList<Integer>> tree = new ArrayList<>();

			for(int i = 0; i < n; i++) {
				tree.add(new ArrayList<Integer>());
			}

			for(int i = 1; i <= n - 1; i++) {

				int u = s.nextInt() - 1, v = s.nextInt() - 1;

				tree.get(u).add(v);
				tree.get(v).add(u);

			}

			boolean answer = false; // true means alice wins

			// in range

			int dist[] = new int[n];

			int farthest = 0, max = 0;
			for(int i = 0; i<n; i++) {

				if(dist[i] >= max) {
					max = dist[i];
					farthest = i;
				}
			}

			dfs(alice,alice,tree,dist,0);

			// when i can reach every node in tree
			if(dist[bob] <= da) {
				str.append("Alice\n");
				continue;
			}

			int diameter = 0;

			dfs(farthest, farthest, tree, dist, 0);

			for(int i = 0; i< n; i++) {
				diameter = Math.max(diameter, dist[i]);
			}

			if(db > 2*da && diameter > 2*da)
            {
                answer = false;
            }
            else
            {
                answer = true;
            }

			if(answer) str.append("Alice\n"); else str.append("Bob\n");

		}

		System.out.println(str);
	}

	private static void dfs(int src, int parent, ArrayList<ArrayList<Integer>> tree, int[] dist, int depth) {
		dist[src] = depth;
		List<Integer> nbrs = tree.get(src);

		for(int nbr : nbrs) {
			if(nbr != parent) {
				dfs(nbr,src,tree,dist,depth + 1);
			}
		}

	}

}


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

public class TreeTag668D{
	static class FastReader {

        BufferedReader br;
        StringTokenizer st;

        private 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());
        }

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

	int[] nextIntArrayOne(int n) {
				int[] a = new int[n+1];
				for (int i = 1; i < n+1; i++)
					a[i] = nextInt();
				return a;
	}

        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;
        }
    }

	public static void main(String[] args) {
		FastReader s =new FastReader();
		int t = s.nextInt();
		StringBuilder str = new StringBuilder();

		while(t-- >0) {
			int n = s.nextInt(), alice = s.nextInt() - 1, bob = s.nextInt() - 1, da = s.nextInt(), db = s.nextInt();
			ArrayList<ArrayList<Integer>> tree = new ArrayList<>();

			for(int i = 0; i < n; i++) {
				tree.add(new ArrayList<Integer>());
			}

			for(int i = 1; i <= n - 1; i++) {

				int u = s.nextInt() - 1, v = s.nextInt() - 1;

				tree.get(u).add(v);
				tree.get(v).add(u);

			}

			boolean answer = false; // true means alice wins

			// in range

			int dist[] = new int[n];

			int farthest = 0, max = 0;
			for(int i = 0; i<n; i++) {

				if(dist[i] >= max) {
					max = dist[i];
					farthest = i;
				}
			}

			dfs(alice,alice,tree,dist,0);

			// when i can reach every node in tree
			if(dist[bob] <= da) answer = true;

			int diameter = 0;

			dfs(farthest, farthest, tree, dist, 0);

			for(int i = 0; i< n; i++) {
				diameter = Math.max(diameter, dist[i]);
			}

			if(db > 2*da && diameter > 2*da)
            {
                answer = false;
            }
            else
            {
                answer = true;
            }

			if(answer) str.append("Alice\n"); else str.append("Bob\n");

		}

		System.out.println(str);
	}

	private static void dfs(int src, int parent, ArrayList<ArrayList<Integer>> tree, int[] dist, int depth) {
		dist[src] = depth;
		List<Integer> nbrs = tree.get(src);

		for(int nbr : nbrs) {
			if(nbr != parent) {
				dfs(nbr,src,tree,dist,depth + 1);
			}
		}

	}

}


/*
    Java might be good for Competitive Programming but Python still rocks!!!!!!!!!

                            pppppppppppppppppppp
                         ppppp  ppppppppppppppppppp
                      ppppppp    ppppppppppppppppppppp
                      pppppppp  pppppppppppppppppppppp
                      pppppppppppppppppppppppppppppppp
                              pppppppppppppppppppppppp
       ppppppppppppppppppppppppppppppppppppppppppppppp  pppppppppppppppppppp
      pppppppppppppppppppppppppppppppppppppppppppppppp  ppppppppppppppppppppp
     ppppppppppppppppppppppppppppppppppppppppppppppppp  pppppppppppppppppppppp
    ppppppppppppppppppppppppppppppppppppppppppppppp    pppppppppppppppppppppppp
   pppppppppppppppppppppppppppppppppppppppppppppp     pppppppppppppppppppppppppp
  ppppppppppppppppppppppppppppppppppppppppppppp      pppppppppppppppppppppppppppp
  pppppppppppppppppppppppppppppppp               pppppppppppppppppppppppppppppppp
  pppppppppppppppppppppppppppp     pppppppppppppppppppppppppppppppppppppppppppppp
  ppppppppppppppppppppppppppp    pppppppppppppppppppppppppppppppppppppppppppppppp
    pppppppppppppppppppppppp  pppppppppppppppppppppppppppppppppppppppppppppppppp
     ppppppppppppppppppppppp  ppppppppppppppppppppppppppppppppppppppppppppppppp
      pppppppppppppppppppppp  ppppppppppppppppppppppppppppppppppppppppppppppp
       ppppppppppppppppppppp  ppppppppppppppppppppppppppppppppppppppppppppp
                              pppppppppppppppppppppppp
                              pppppppppppppppppppppppppppppppp
                              pppppppppppppppppppppp  pppppppp
                              ppppppppppppppppppppp    ppppppp
                                 ppppppppppppppppppp  ppppp
                                    pppppppppppppppppppp
*/

import java.util.*;
import java.lang.*;
import java.io.*;
public final class ProblemD
{
    public static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
    public static int t, n, i, a, b, da, db, u, v, md, node, dba;
    public static ArrayList<Integer>[] tree;
    public static void main(String[] args) throws IOException
    {
        FastScanner sc = new FastScanner();
        Print print = new Print();
        t = sc.nextInt();
        while(t-- > 0)
        {
            n = sc.nextInt();
            a = sc.nextInt();
            b = sc.nextInt();
            da = sc.nextInt();
            db = sc.nextInt();
            a--;
            b--;
            tree = new ArrayList[n];
            for(i = 0; i < n; i++)
                tree[i] = new ArrayList<>();
            for(i = 0; i < n-1; i++)
            {
                u = sc.nextInt();
                u--;
                v = sc.nextInt();
                v--;
                tree[u].add(v);
                tree[v].add(u);
            }
            if(da * 2 >= db)
            {
                print.string("Alice");
                continue;
            }
            md = 0;
            node = b;
            dfs(b, -1, 0);
            if(dba <= da)
            {
                print.string("Alice");
                continue;
            }
            md = 0;
            dfs(node, -1, 0);
            if(md <= 2 * da)
            {
                print.string("Alice");
                continue;
            }
            print.string("Bob");
        }
        out.close();
    }

    public static void dfs(int source, int parent, int dist)
    {
        if(source == a)
            dba = dist;
        if(dist > md)
        {
            node = source;
            md = dist;
        }
        for(int child: tree[source])
        {
            if(child == parent) continue;
            dfs(child, source, dist + 1);
        }
    }

    public static class Print
    {
        Print()
        {}

        void integer(int... arr) throws IOException
        {
            for(int value: arr)
            {
                out.write(value+" ");
                out.flush();
            }
            out.write("\n");
            out.flush();
        }

        void string(String... arr) throws IOException
        {
            for(String value: arr)
            {
                out.write(value+" ");
                out.flush();
            }
            out.write("\n");
            out.flush();
        }

        void character(char... arr) throws IOException
        {
            for(char value: arr)
            {
                out.write(value+" ");
                out.flush();
            }
            out.write("\n");
            out.flush();
        }

        void long_int(long... arr) throws IOException
        {
            for(long value: arr)
            {
                out.write(value+" ");
                out.flush();
            }
            out.write("\n");
            out.flush();
        }
    }

    static class FastScanner
    {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.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());
        }
        int[] readArray(int n)
        {
            int[] a=new int[n];
            for (int i=0; i<n; i++) a[i]=nextInt();
            return a;
        }
        long nextLong()
        {
            return Long.parseLong(next());
        }
    }
}


/*
    Java might be good for Competitive Programming but Python still rocks!!!!!!!!!

                            pppppppppppppppppppp
                         ppppp  ppppppppppppppppppp
                      ppppppp    ppppppppppppppppppppp
                      pppppppp  pppppppppppppppppppppp
                      pppppppppppppppppppppppppppppppp
                              pppppppppppppppppppppppp
       ppppppppppppppppppppppppppppppppppppppppppppppp  pppppppppppppppppppp
      pppppppppppppppppppppppppppppppppppppppppppppppp  ppppppppppppppppppppp
     ppppppppppppppppppppppppppppppppppppppppppppppppp  pppppppppppppppppppppp
    ppppppppppppppppppppppppppppppppppppppppppppppp    pppppppppppppppppppppppp
   pppppppppppppppppppppppppppppppppppppppppppppp     pppppppppppppppppppppppppp
  ppppppppppppppppppppppppppppppppppppppppppppp      pppppppppppppppppppppppppppp
  pppppppppppppppppppppppppppppppp               pppppppppppppppppppppppppppppppp
  pppppppppppppppppppppppppppp     pppppppppppppppppppppppppppppppppppppppppppppp
  ppppppppppppppppppppppppppp    pppppppppppppppppppppppppppppppppppppppppppppppp
    pppppppppppppppppppppppp  pppppppppppppppppppppppppppppppppppppppppppppppppp
     ppppppppppppppppppppppp  ppppppppppppppppppppppppppppppppppppppppppppppppp
      pppppppppppppppppppppp  ppppppppppppppppppppppppppppppppppppppppppppppp
       ppppppppppppppppppppp  ppppppppppppppppppppppppppppppppppppppppppppp
                              pppppppppppppppppppppppp
                              pppppppppppppppppppppppppppppppp
                              pppppppppppppppppppppp  pppppppp
                              ppppppppppppppppppppp    ppppppp
                                 ppppppppppppppppppp  ppppp
                                    pppppppppppppppppppp
*/

import java.util.*;
import java.lang.*;
import java.io.*;
public final class ProblemD
{
    public static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
    public static int t, n, i, j, k, a, b, da, db, u, v, md, dba;
    public static ArrayList<Integer>[] tree;
    public static void main(String[] args) throws IOException
    {
        FastScanner sc = new FastScanner();
        Print print = new Print();
        t = sc.nextInt();
        while(t-- > 0)
        {
            n = sc.nextInt();
            a = sc.nextInt();
            b = sc.nextInt();
            da = sc.nextInt();
            db = sc.nextInt();
            a--;
            b--;
            tree = new ArrayList[n];
            md = 0;
            dba = 0;
            for(i = 0; i < n; i++)
                tree[i] = new ArrayList<>();
            for(i = 0; i < n-1; i++)
            {
                u = sc.nextInt();
                u--;
                v = sc.nextInt();
                v--;
                tree[u].add(v);
                tree[v].add(u);
            }
            if(da * 2 >= db)
            {
                print.string("Alice");
                continue;
            }
            dfs(0, -1, 0);
            if(dba <= da)
            {
                print.string("Alice");
                continue;
            }
            if(md <= da * 2)
            {
                print.string("Alice");
                continue;
            }
            print.string("Bob");
        }
        out.close();
    }

    public static void dfs(int source, int parent, int dist)
    {
        md = Math.max(md, dist);
        if(source == a)
            dba = dist;
        for(int child: tree[source])
        {
            if(child == parent) continue;
            dfs(child, source, dist + 1);
        }
    }

    public static class Print
    {
        Print()
        {}

        void integer(int... arr) throws IOException
        {
            for(int value: arr)
            {
                out.write(value+" ");
                out.flush();
            }
            out.write("\n");
            out.flush();
        }

        void string(String... arr) throws IOException
        {
            for(String value: arr)
            {
                out.write(value+" ");
                out.flush();
            }
            out.write("\n");
            out.flush();
        }

        void character(char... arr) throws IOException
        {
            for(char value: arr)
            {
                out.write(value+" ");
                out.flush();
            }
            out.write("\n");
            out.flush();
        }

        void long_int(long... arr) throws IOException
        {
            for(long value: arr)
            {
                out.write(value+" ");
                out.flush();
            }
            out.write("\n");
            out.flush();
        }
    }

    static class FastScanner
    {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.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());
        }
        int[] readArray(int n)
        {
            int[] a=new int[n];
            for (int i=0; i<n; i++) a[i]=nextInt();
            return a;
        }
        long nextLong()
        {
            return Long.parseLong(next());
        }
    }
}


import java.util.*;
import java.io.*;
public class EdD {
	static int[] depth;
	static Map<Integer, ArrayList<Integer>> mp;
	public static void main(String[] args) throws Exception{
		int num = 998244353;

		// TODO Auto-generated method stub
 		BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
 		PrintWriter out = new PrintWriter(System.out);
 		int t = Integer.parseInt(bf.readLine());
 		for(int i = 0;i<t;i++){
//	 		String input1 = bf.readLine().trim();
//	 		String input2 = bf.readLine().trim();
	 		StringTokenizer st = new StringTokenizer(bf.readLine());
	 		int n = Integer.parseInt(st.nextToken());
	 		int a = Integer.parseInt(st.nextToken());
	 		int b = Integer.parseInt(st.nextToken());
	 		int da = Integer.parseInt(st.nextToken());
	 		int db = Integer.parseInt(st.nextToken());
	 		mp = new HashMap<Integer, ArrayList<Integer>>();
	 		for(int j =1 ;j<=n;j++){
	 			mp.put(j,  new ArrayList<Integer>());
	 		}
	 		depth = new int[n+1];
	 		for(int j = 0;j<n-1;j++){
	 			StringTokenizer st1 = new StringTokenizer(bf.readLine());
	 			int v1 = Integer.parseInt(st1.nextToken());
	 			int v2 = Integer.parseInt(st1.nextToken());
	 			mp.get(v1).add(v2);
	 			mp.get(v2).add(v1);
	 		}
	 		dfs(a, -1);
	 		boolean ans = false;
	 		if (depth[b] <= da)
	 			ans = true;
	 		int max = 0;
	 		int maxindex =0;
	 		for(int j = 1;j<=n;j++){
	 			if (depth[j] > max){
	 				max = depth[j];
	 				maxindex = j;
	 			}

	 		}
	 		depth[maxindex] = 0;
	 		dfs(maxindex, -1);
	 		max = 0;
	 		maxindex = 0;
	 		for(int j = 1;j<=n;j++){
	 			if (depth[j] > max){
	 				max = depth[j];
	 				maxindex = j;
	 			}

	 		}
	 		if (db <= 2*da || da >= (max+1)/2)
	 			ans = true;
	 		if (ans)
	 			out.println("Alice");
	 		else
	 			out.println("Bob");

 		}

 		out.println();

 		out.close();

 	}
	public static void dfs(int v, int p){
		for(int child : mp.get(v)){
			if (child == p)
				continue;
			depth[child] = depth[v]+1;
			dfs(child, v);
		}
	}

}

//StringJoiner sj = new StringJoiner(" ");
//sj.add(strings)
//sj.toString() gives string of those stuff w spaces or whatever that sequence is


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

public class Main {
    static ArrayList<ArrayList<Integer>> map;
    static int[] p;
    public static void main(String[] args) throws Exception {
        FastScanner sc = new FastScanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        StringBuilder sb = new StringBuilder();
        int T = sc.nextInt();
        for(int ti = 0; ti < T; ti++){
            int n = sc.nextInt();
            int Alice = sc.nextInt()-1;
            int Bob = sc.nextInt()-1;
            int AliceWalk = sc.nextInt();
            int BobWalk = sc.nextInt();
            map = new ArrayList<>();
            p = new int[n];
            for(int i = 0; i < n; i++){
                map.add(new ArrayList<>());
            }
            for(int i = 0; i < n-1; i++){
                int f = sc.nextInt()-1;
                int t = sc.nextInt()-1;
                map.get(f).add(t);
                map.get(t).add(f);
            }
            if(AliceWalk+1 >= BobWalk || isFirst(Alice,-1,Bob,0,AliceWalk)){
                pw.println("Alice");
                continue;
            }else{
                Pair da = dfs(0,-1,0);
                Pair db = dfs(da.s,-1,0);
            	pw.println(db.f > AliceWalk*2 ? "Bob" : "Alice");
            }
        }
        pw.flush();
    }

    public static boolean isFirst(int a, int prev, int b, int now, int max){
        if(now == max){
            return false;
        }
        for(int next : map.get(a)){
            if(next == prev) continue;
            if(next == b) return true;
            if(isFirst(next,a,b,now+1,max)) return true;
        }
        return false;
    }

    public static Pair dfs(int v, int par, int dist) {
    	p[v] = par;
    	Pair res = new Pair(dist, v);
    	for (int to : map.get(v)) {
    		if (to == par) continue;
    		Pair res2 = dfs(to, v, dist + 1);
    		if(res.f < res2.f || (res.f == res2.f) && (res.s < res2.s)){
    		    res = res2;
    		}
    	}
    	return res;
    }

    static class GeekInteger {
        public static void save_sort(int[] array) {
            shuffle(array);
            Arrays.sort(array);
        }

        public static int[] shuffle(int[] array) {
            int n = array.length;
            Random random = new Random();
            for (int i = 0, j; i < n; i++) {
                j = i + random.nextInt(n - i);
                int randomElement = array[j];
                array[j] = array[i];
                array[i] = randomElement;
            }
            return array;
        }

    }
}

class Pair{
    int f,s;
    public Pair(int f, int s){
        this.f = f;
        this.s = s;
    }
}

class FastScanner {
    private BufferedReader reader = null;
    private StringTokenizer tokenizer = null;
    public FastScanner(InputStream in) {
        reader = new BufferedReader(new InputStreamReader(in));
        tokenizer = null;
    }

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

    public String nextLine() {
        if (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                return reader.readLine();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken("\n");
    }

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

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

    public double nextDouble() {
         return Double.parseDouble(next());
    }

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

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

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


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

public class Main {
    static ArrayList<ArrayList<Integer>> map;
    static int[] p;
    public static void main(String[] args) throws Exception {
        FastScanner sc = new FastScanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        StringBuilder sb = new StringBuilder();
        int T = sc.nextInt();
        for(int ti = 0; ti < T; ti++){
            int n = sc.nextInt();
            int Alice = sc.nextInt()-1;
            int Bob = sc.nextInt()-1;
            int AliceWalk = sc.nextInt();
            int BobWalk = sc.nextInt();
            map = new ArrayList<>();
            p = new int[n];
            for(int i = 0; i < n; i++){
                map.add(new ArrayList<>());
            }
            for(int i = 0; i < n-1; i++){
                int f = sc.nextInt()-1;
                int t = sc.nextInt()-1;
                map.get(f).add(t);
                map.get(t).add(f);
            }
            if(AliceWalk+1 >= BobWalk || isFirst(Alice,-1,Bob,0,AliceWalk)){
                pw.println("Alice");
                continue;
            }else{
                Pair da = dfs(0,-1,0);
                Pair db = dfs(da.s,-1,0);
                ArrayList<Integer> diam = new ArrayList<>();
                int vv = db.s;
            	while (vv != da.s) {
            		diam.add(vv);
            		vv = p[vv];
            	}
            	pw.println((diam.size()+1) > AliceWalk*2+1 ? "Bob" : "Alice");
            }
        }
        pw.flush();
    }

    public static boolean isFirst(int a, int prev, int b, int now, int max){
        if(now == max){
            return false;
        }
        for(int next : map.get(a)){
            if(next == prev) continue;
            if(next == b) return true;
            if(isFirst(next,a,b,now+1,max)) return true;
        }
        return false;
    }

    public static Pair dfs(int v, int par, int dist) {
    	p[v] = par;
    	Pair res = new Pair(dist, v);
    	for (int to : map.get(v)) {
    		if (to == par) continue;
    		Pair res2 = dfs(to, v, dist + 1);
    		if(res.f < res2.f || (res.f == res2.f) && (res.s < res2.s)){
    		    res = res2;
    		}
    	}
    	return res;
    }

    static class GeekInteger {
        public static void save_sort(int[] array) {
            shuffle(array);
            Arrays.sort(array);
        }

        public static int[] shuffle(int[] array) {
            int n = array.length;
            Random random = new Random();
            for (int i = 0, j; i < n; i++) {
                j = i + random.nextInt(n - i);
                int randomElement = array[j];
                array[j] = array[i];
                array[i] = randomElement;
            }
            return array;
        }

    }
}

class Pair{
    int f,s;
    public Pair(int f, int s){
        this.f = f;
        this.s = s;
    }
}

class FastScanner {
    private BufferedReader reader = null;
    private StringTokenizer tokenizer = null;
    public FastScanner(InputStream in) {
        reader = new BufferedReader(new InputStreamReader(in));
        tokenizer = null;
    }

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

    public String nextLine() {
        if (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                return reader.readLine();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken("\n");
    }

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

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

    public double nextDouble() {
         return Double.parseDouble(next());
    }

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

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

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


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

public class Main {
    static ArrayList<ArrayList<Integer>> map;
    static int[] p;
    public static void main(String[] args) throws Exception {
        FastScanner sc = new FastScanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        StringBuilder sb = new StringBuilder();
        int T = sc.nextInt();
        for(int ti = 0; ti < T; ti++){
            int n = sc.nextInt();
            int Alice = sc.nextInt()-1;
            int Bob = sc.nextInt()-1;
            int AliceWalk = sc.nextInt();
            int BobWalk = sc.nextInt();
            map = new ArrayList<>();
            p = new int[n];
            for(int i = 0; i < n; i++){
                map.add(new ArrayList<>());
            }
            for(int i = 0; i < n-1; i++){
                int f = sc.nextInt()-1;
                int t = sc.nextInt()-1;
                map.get(f).add(t);
                map.get(t).add(f);
            }
            if(BobWalk <= AliceWalk*2 || isFirst(Alice,-1,Bob,0,AliceWalk)){
                pw.println("Alice");
                continue;
            }else{
                Pair da = dfs(0,-1,0);
                Pair db = dfs(da.s,-1,0);
                ArrayList<Integer> diam = new ArrayList<>();
                int vv = db.s;
            	while (vv != da.s) {
            		diam.add(vv);
            		vv = p[vv];
            	}
            	pw.println((diam.size()+1) > AliceWalk*2+1 ? "Bob" : "Alice");
            }
        }
        pw.flush();
    }

    public static boolean isFirst(int a, int prev, int b, int now, int max){
        if(now == max){
            return false;
        }
        for(int next : map.get(a)){
            if(next == prev) continue;
            if(next == b) return true;
            if(isFirst(next,a,b,now+1,max)) return true;
        }
        return false;
    }

    public static Pair dfs(int v, int par, int dist) {
    	p[v] = par;
    	Pair res = new Pair(dist, v);
    	for (int to : map.get(v)) {
    		if (to == par) continue;
    		Pair res2 = dfs(to, v, dist + 1);
    		if(res.f < res2.f || (res.f == res2.f) && (res.s < res2.s)){
    		    res = res2;
    		}
    	}
    	return res;
    }

    static class GeekInteger {
        public static void save_sort(int[] array) {
            shuffle(array);
            Arrays.sort(array);
        }

        public static int[] shuffle(int[] array) {
            int n = array.length;
            Random random = new Random();
            for (int i = 0, j; i < n; i++) {
                j = i + random.nextInt(n - i);
                int randomElement = array[j];
                array[j] = array[i];
                array[i] = randomElement;
            }
            return array;
        }

    }
}

class Pair{
    int f,s;
    public Pair(int f, int s){
        this.f = f;
        this.s = s;
    }
}

class FastScanner {
    private BufferedReader reader = null;
    private StringTokenizer tokenizer = null;
    public FastScanner(InputStream in) {
        reader = new BufferedReader(new InputStreamReader(in));
        tokenizer = null;
    }

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

    public String nextLine() {
        if (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                return reader.readLine();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken("\n");
    }

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

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

    public double nextDouble() {
         return Double.parseDouble(next());
    }

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

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

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


import java.io.*;
import java.util.*;
public class D {

  public static void main(String[] args) {
      int t = sc.nextInt();
      while(t-- > 0)
        solve();
      out.close();
  }

  private static void solve() {
      int n = sc.nextInt();
      int a = sc.nextInt();
      int b = sc.nextInt();
      int da = sc.nextInt();
      int db = sc.nextInt();
      Map<Integer, List<Integer>> graph = new HashMap<>();
      for(int i = 1; i <= n; i++)
        graph.put(i, new ArrayList<>());

      for(int i = 0; i < n - 1; i++) {
        int u = sc.nextInt();
        int v = sc.nextInt();
        graph.get(u).add(v);
        graph.get(v).add(u);
      }

      int distAB = bfs(graph, a, b);
      if(da >= distAB) {
        out.println("Alice");
        return;
      }

      int farNode = bfs1(graph, 1);
      int diamter = bfs2(graph, farNode);
      int farB = Math.min(diamter, db+1);
      //out.println(farNode + ", " + diamter + " " + farB);
      if(da * 2 + 1 >= farB)
        out.println("Alice");
      else
        out.println("Bob");
      return;
  }

  private static int bfs(Map<Integer, List<Integer>> graph, int node, int target) {
      int steps = 0;

      Queue<Integer> queue = new LinkedList<>();
      queue.offer(node);
      Set<Integer> visited = new HashSet<>();
      visited.add(node);

      while(queue.size() > 0) {
         int size = queue.size();
         for(int i = 0; i < size; i++) {
           int n = queue.poll();
           if(n == target)
            return steps;
           for(int adj : graph.get(n)) {
            if(visited.contains(adj))
              continue;
            visited.add(adj);
            queue.offer(adj);
           }
         }
         steps++;
      }
      return steps;
  }

  private static int bfs2(Map<Integer, List<Integer>> graph, int node) {
      int d = 0;
      Queue<Integer> queue = new LinkedList<>();
      queue.offer(node);
      Set<Integer> visited = new HashSet<>();
      visited.add(node);
      while(queue.size() > 0) {
         int size = queue.size();
         for(int i = 0; i < size; i++) {
           int n = queue.poll();
           for(int adj : graph.get(n)) {
            if(visited.contains(adj))
              continue;
            visited.add(adj);
            queue.offer(adj);
           }
         }
         d++;
      }
      return d;
  }
  private static int bfs1(Map<Integer, List<Integer>> graph, int node) {
    Queue<Integer> queue = new LinkedList<>();
    queue.offer(node);
    Set<Integer> visited = new HashSet<>();
    visited.add(node);
    int lastNode = 0;
    while(queue.size() > 0) {
       int n = queue.poll();
       lastNode = n;
       for(int adj : graph.get(n)) {
        if(visited.contains(adj))
          continue;
        visited.add(adj);
        queue.offer(adj);
       }
    }
    return lastNode;
  }

  public static void sort(int[] a) {
    int l = 0, r = a.length;
      ArrayList<Integer> list=new ArrayList<>();
      for (int i=l ; i<r; i++) list.add(a[i]);
      Collections.sort(list);
      for (int i=l; i<r; i++) a[i]=list.get(i-l);
  }

  public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));

  public static FastScanner sc = new FastScanner();

  static class FastScanner {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.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());
      }
      int[] readArray(int n) {
        int[] a=new int[n];
        for (int i=0; i<n; i++) a[i]=nextInt();
        return a;
      }
      long nextLong() {
        return Long.parseLong(next());
      }
  }
}


import java.io.*;
import java.util.*;
public class D {

  public static void main(String[] args) {
      int t = sc.nextInt();
      while(t-- > 0)
        solve();
      out.close();
  }

  private static void solve() {
      int n = sc.nextInt();
      int a = sc.nextInt();
      int b = sc.nextInt();
      int da = sc.nextInt();
      int db = sc.nextInt();
      Map<Integer, List<Integer>> graph = new HashMap<>();
      for(int i = 1; i <= n; i++)
        graph.put(i, new ArrayList<>());

      for(int i = 0; i < n - 1; i++) {
        int u = sc.nextInt();
        int v = sc.nextInt();
        graph.get(u).add(v);
        graph.get(v).add(u);
      }

      int distAB = bfs(graph, a, b);
      if(da >= distAB) {
        out.println("Alice");
        return;
      }

      int farNode = bfs1(graph, 1);
      int diamter = bfs2(graph, farNode);
      int farB = Math.min(diamter-1, db);
      //out.println(farNode + ", " + diamter + " " + farB);
      if(da+1 >= farB)
        out.println("Alice");
      else
        out.println("Bob");
      return;
  }

  private static int bfs(Map<Integer, List<Integer>> graph, int node, int target) {
      int steps = 0;

      Queue<Integer> queue = new LinkedList<>();
      queue.offer(node);
      Set<Integer> visited = new HashSet<>();
      visited.add(node);

      while(queue.size() > 0) {
         int size = queue.size();
         for(int i = 0; i < size; i++) {
           int n = queue.poll();
           if(n == target)
            return steps;
           for(int adj : graph.get(n)) {
            if(visited.contains(adj))
              continue;
            visited.add(adj);
            queue.offer(adj);
           }
         }
         steps++;
      }
      return steps;
  }

  private static int bfs2(Map<Integer, List<Integer>> graph, int node) {
      int d = 0;
      Queue<Integer> queue = new LinkedList<>();
      queue.offer(node);
      Set<Integer> visited = new HashSet<>();
      visited.add(node);
      while(queue.size() > 0) {
         int size = queue.size();
         for(int i = 0; i < size; i++) {
           int n = queue.poll();
           for(int adj : graph.get(n)) {
            if(visited.contains(adj))
              continue;
            visited.add(adj);
            queue.offer(adj);
           }
         }
         d++;
      }
      return d;
  }
  private static int bfs1(Map<Integer, List<Integer>> graph, int node) {
    Queue<Integer> queue = new LinkedList<>();
    queue.offer(node);
    Set<Integer> visited = new HashSet<>();
    visited.add(node);
    int lastNode = 0;
    while(queue.size() > 0) {
       int n = queue.poll();
       lastNode = n;
       for(int adj : graph.get(n)) {
        if(visited.contains(adj))
          continue;
        visited.add(adj);
        queue.offer(adj);
       }
    }
    return lastNode;
  }

  public static void sort(int[] a) {
    int l = 0, r = a.length;
      ArrayList<Integer> list=new ArrayList<>();
      for (int i=l ; i<r; i++) list.add(a[i]);
      Collections.sort(list);
      for (int i=l; i<r; i++) a[i]=list.get(i-l);
  }

  public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));

  public static FastScanner sc = new FastScanner();

  static class FastScanner {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.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());
      }
      int[] readArray(int n) {
        int[] a=new int[n];
        for (int i=0; i<n; i++) a[i]=nextInt();
        return a;
      }
      long nextLong() {
        return Long.parseLong(next());
      }
  }
}


import java.util.*;
public class TreeTag {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int T = in.nextInt();
        for (int t = 0; t < T; t++) {
            int N = in.nextInt(), a = in.nextInt() - 1, b = in.nextInt() - 1, da = in.nextInt(), db = in.nextInt();
            HashSet<Integer>[] adj = new HashSet[N];
            for (int i = 0; i < N; i++) {
                adj[i] = new HashSet<>();
            }
            for (int i = 0; i < N - 1; i++) {
                int u = in.nextInt() - 1, v = in.nextInt() - 1;
                adj[u].add(v);
                adj[v].add(u);
            }
            int dist = search(N, adj, new boolean[N], b, a);
            boolean res;
            if (dist <= da) {
                res = true;
            } else if (db > 2 * da) {
                res = false;
            } else {
                res = true;
            }
            System.out.println(res ? "Alice" : "Bob");
        }
    }
    public static int search(int N, HashSet<Integer>[] adj, boolean[] visited, int target, int i) {
        visited[i] = true;
        if (i == target) {
            return 0;
        }
        for (int j : adj[i]) {
            if (!visited[j]) {
                int n = search(N, adj, visited, target, j);
                if (n >= 0) {
                    return n + 1;
                }
            }
        }
        return -1;
    }
}


import java.util.*;
public class TreeTag {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int T = in.nextInt();
        for (int t = 0; t < T; t++) {
            int N = in.nextInt(), a = in.nextInt() - 1, b = in.nextInt() - 1, da = in.nextInt(), db = in.nextInt();
            HashSet<Integer>[] adj = new HashSet[N];
            for (int i = 0; i < N; i++) {
                adj[i] = new HashSet<>();
            }
            for (int i = 0; i < N - 1; i++) {
                int u = in.nextInt() - 1, v = in.nextInt() - 1;
                adj[u].add(v);
                adj[v].add(u);
            }
            int dist = search(N, adj, new boolean[N], b, a);
            int max = diameter(N, adj);
            boolean res;
            if (dist <= da) {
                res = true;
            } else if (Math.min(max, db) > 2 * da) {
                res = false;
            } else {
                res = true;
            }
            System.out.println(res ? "Alice" : "Bob");
        }
    }
    public static int search(int N, HashSet<Integer>[] adj, boolean[] visited, int target, int i) {
        visited[i] = true;
        if (i == target) {
            return 0;
        }
        for (int j : adj[i]) {
            if (!visited[j]) {
                int n = search(N, adj, visited, target, j);
                if (n >= 0) {
                    return n + 1;
                }
            }
        }
        return -1;
    }
    public static int diameter(int N, HashSet<Integer>[] adj) {
        remove(N, adj, new boolean[N], 0);
        return search(N, adj, new int[N], 0);
    }
    public static int search(int N, HashSet<Integer>[] adj, int[] distances, int i) {
        int res = 0;
        List<Integer> dist = new ArrayList<>();
        for (int j : adj[i]) {
            res = Math.max(res, search(N, adj, distances, j));
            dist.add(distances[j]);
        }
        dist.add(0);
        dist.add(0);
        Collections.sort(dist);
        distances[i] = dist.get(dist.size() - 1) + 1;
        res = Math.max(res, dist.get(dist.size() - 1) + dist.get(dist.size() - 2) + 1);
        return res;
    }
    public static void remove(int N, HashSet<Integer>[] adj, boolean[] visited, int i) {
        visited[i] = true;
        HashSet<Integer> visit = new HashSet<>(), remove = new HashSet<>();
        for (int j : adj[i]) {
            if (visited[j]) {
                remove.add(j);
            } else {
                visit.add(j);
            }
        }
        for (int j : remove) {
            adj[i].remove(j);
        }
        for (int j : visit) {
            remove(N, adj, visited, j);
        }
    }
}


import java.util.*;
public class TreeTag {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int T = in.nextInt();
        for (int t = 0; t < T; t++) {
            int N = in.nextInt(), a = in.nextInt() - 1, b = in.nextInt() - 1, da = in.nextInt(), db = in.nextInt();
            HashSet<Integer>[] adj = new HashSet[N];
            for (int i = 0; i < N; i++) {
                adj[i] = new HashSet<>();
            }
            for (int i = 0; i < N - 1; i++) {
                int u = in.nextInt() - 1, v = in.nextInt() - 1;
                adj[u].add(v);
                adj[v].add(u);
            }
            int dist = search(N, adj, new boolean[N], b, a);
            int max = diameter(N, adj) - 1;
            boolean res;
            if (dist <= da) {
                res = true;
            } else if (Math.min(max, db) > 2 * da) {
                res = false;
            } else {
                res = true;
            }
            System.out.println(res ? "Alice" : "Bob");
        }
    }
    public static int search(int N, HashSet<Integer>[] adj, boolean[] visited, int target, int i) {
        visited[i] = true;
        if (i == target) {
            return 0;
        }
        for (int j : adj[i]) {
            if (!visited[j]) {
                int n = search(N, adj, visited, target, j);
                if (n >= 0) {
                    return n + 1;
                }
            }
        }
        return -1;
    }
    public static int diameter(int N, HashSet<Integer>[] adj) {
        remove(N, adj, new boolean[N], 0);
        return search(N, adj, new int[N], 0);
    }
    public static int search(int N, HashSet<Integer>[] adj, int[] distances, int i) {
        int res = 0;
        List<Integer> dist = new ArrayList<>();
        for (int j : adj[i]) {
            res = Math.max(res, search(N, adj, distances, j));
            dist.add(distances[j]);
        }
        dist.add(0);
        dist.add(0);
        Collections.sort(dist);
        distances[i] = dist.get(dist.size() - 1) + 1;
        res = Math.max(res, dist.get(dist.size() - 1) + dist.get(dist.size() - 2) + 1);
        return res;
    }
    public static void remove(int N, HashSet<Integer>[] adj, boolean[] visited, int i) {
        visited[i] = true;
        HashSet<Integer> visit = new HashSet<>(), remove = new HashSet<>();
        for (int j : adj[i]) {
            if (visited[j]) {
                remove.add(j);
            } else {
                visit.add(j);
            }
        }
        for (int j : remove) {
            adj[i].remove(j);
        }
        for (int j : visit) {
            remove(N, adj, visited, j);
        }
    }
}


import java.io.*;
import java.io.IOException;
import java.util.*;
import java.util.function.DoublePredicate;

//import javafx.util.Pair;
//import java.util.concurrent.LinkedBlockingDeque;

  public class Codeforces {

        public static long mod = (long)Math.pow(10,9)+7 ;
        public static double epsilon=0.00000000008854;//value of epsilon
        public static InputReader sc = new InputReader(System.in);
        public static PrintWriter pw = new PrintWriter(System.out);

        // fun(n,sum)=fun(n-1,sum)+fun(n-1,sum-n^x);
        public static int parent(int a,int p[]){
            if(a!=p[a]){
                p[a]=parent(p[a], p);
            }
            return p[a];
        }
       public static void Union(int a,int b,int p[],int size[]){
            a=parent(a, p);
            b=parent(b, p);
            if(a!=b){
                p[a]=b;
                size[b]+=size[a];
            }
       }

       //public static void dfs1(ArrayList<ArrayList<Integer>> g,int u,int vis[] )
       public static int findLengthOfShortestSubarray(int[] a) {
            TreeMap<Integer,Integer> left=new TreeMap<>();
            left.put(a[0],1);
            int ans=1;
            for(int i=1;i<a.length;i++){
                if(a[i]>=a[i-1])
                left.put(a[i], i+1);
                else{
                    break;
                }
                ans++;
            }
            int t=0;

            if(ans!=a.length)
            for(int i=a.length-1;i>=0;i--){
                if((i==a.length-1)||a[i]<=a[i+1]){
                    t++;
                    Integer k=left.floorKey(a[i]);

                    if(k==null){
                        ans=Math.max(ans, t);
                    }
                    else{
                        //pw.println(k);
                        ans=Math.max(ans, left.get(k)+t);
                    }
                }
                else{
                    break;
                }
            }
            return a.length-ans;

        }
        public static int getXor(int k){
            pw.println(1+" "+k);
            pw.flush();
            int t=sc.nextInt();
            return t;
        }

        public static int daimeterUtil(int r,ArrayList<ArrayList <Integer>> a,int h[],int vis[]){
            vis[r]=1;
            int m1=0,m2=0,d=0;
            for(int i=0;i<a.get(r).size();i++){
                int u=a.get(r).get(i);
                if(vis[u]!=1){
                    if(h[u]+1>m1){
                        m2=m1;
                        m1=h[u]+1;
                    }
                    else if(h[u]+1>m2){
                        m2=h[u]+1;
                    }
                }
            }
            d=Math.max(m1+m2, d);
            for(int i=0;i<a.get(r).size();i++){
                int u=a.get(r).get(i);
                if(vis[u]!=1){
                    d=Math.max(daimeterUtil(u, a, h, vis), d);
                }
            }
            return d;

        }
        public static int hieght(int r,int h[],ArrayList<ArrayList <Integer>> a,int vis[],int p[]){//bottom Up
            vis[r]=1;
            for(int i=0;i<a.get(r).size();i++){
                int v=a.get(r).get(i);
                if(vis[v]==0){
                    p[v]=r;
                    h[r]=Math.max(h[r], 1+hieght(v, h, a, vis,p));
                }
            }
            return h[r];
        }
        public static int daimeter(int r,ArrayList<ArrayList <Integer>> a){
            int n=a.size();
            int h[]=new int[n];
            int p[]=new int[n];
            hieght(r, h, a, new int[n], p);
            //ans[0]=h[b-1];
            return daimeterUtil(r, a, h, new int[n]);
        }
        public static void hieghtBfs(int r,int h[],ArrayList<ArrayList <Integer>> a,int p[],int vis[]){/// top to bottom
            Deque<Integer> q=new LinkedList<>();
            q.add(r);
            int c=1;
            p[r]=-1;
            vis[r]=1;
            while(q.size()>0){
                int l=q.size();
                while(l-->0){
                    int v=q.remove();
                    h[v]=c;
                    for(int i=0;i<a.get(v).size();i++){
                        int u=a.get(v).get(i);
                        if(vis[u]==0){
                            p[u]=v;
                            vis[u]=1;
                            q.add(u);
                        }
                    }
                }
                c++;
            }
        }
        public static ArrayList<ArrayList <Integer>> GetGraph(int n,int m){
            ArrayList<ArrayList <Integer>> a=new ArrayList<>();
            for(int i=0;i<n;i++){
                a.add(new ArrayList<>());
            }
            for(int i=0;i<m;i++){
                int u=sc.nextInt()-1;
                int v=sc.nextInt()-1;
                a.get(u).add(v);
                a.get(v).add(u);
            }
            return a;
        }

        public static void main(String[] args) {
            // code starts..
            Random rand=new Random();
            int q=sc.nextInt();
            while(q-->0){
                int n=sc.nextInt();
                int a=sc.nextInt();
                int b=sc.nextInt();
                int da=sc.nextInt();
                int db=sc.nextInt();
                ArrayList<ArrayList<Integer>> g=GetGraph(n, n-1);
                //int ans[]=new int[1];
                int d=daimeter(0, g);
                int h[]=new int[n];

                hieghtBfs(a-1, h, g, new int[n], new int[n]);
                //pw.println(Arrays.toString(h));
                int dist=h[b-1]-1;
                int maxh=d/2+d%2;
                ///pw.println(dist +" dflh "+maxh+" "+a+" "+b);
                db=Math.min(d, db);

                if(dist<=da){
                    pw.println("Alice");
                }
                else if(db<=2*da){
                    pw.println("Alice");
                }
                else{
                    pw.println("Bob");
                }
                //pw.println(d);

            }
            // Code ends...
            pw.flush();
            pw.close();
        }

        public static Comparator<Long[]> column(int i){
            return
            new Comparator<Long[]>() {
                @Override
                public int compare(Long[] o1, Long[] o2) {
                    return o1[i].compareTo(o2[i]);//for ascending
                    //return o2[i].compareTo(o1[i]);//for descending
                }
            };
        }
        public static Comparator<Integer[]> col(int i){
            return
            new Comparator<Integer[]>() {
                @Override
                public int compare(Integer[] o1, Integer[] o2) {
                    return o1[i].compareTo(o2[i]);//for ascending
                    //return o2[i].compareTo(o1[i]);//for descending
                }
            };
        }
        public static Comparator<Integer> des(){
            return
            new Comparator<Integer>() {
                @Override
                public int compare(Integer o1, Integer o2) {
                    //return o1[i].compareTo(o2[i]);//for ascending
                    return o2.compareTo(o1);//for descending
                }
            };
        }

        public static String reverseString(String s){
            StringBuilder input1 = new StringBuilder();
            input1.append(s);
            input1 = input1.reverse();
            return input1.toString();
        }
        public static int[] scanArray(int n){
            int a[]=new int [n];
            for(int i=0;i<n;i++)
            a[i]=sc.nextInt();

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

            return a;
        }
        public static String [] scanStrings(int n){
            String a[]=new String [n];
            for(int i=0;i<n;i++)
            a[i]=sc.nextLine();

            return a;
        }
        public static class InputReader {

            private final InputStream stream;
            private final byte[] buf = new byte[8192];
            private int curChar, snumChars;
            private SpaceCharFilter filter;

            public InputReader(InputStream stream) {
                this.stream = stream;
            }

            public int snext() {
                if (snumChars == -1)
                    throw new InputMismatchException();
                if (curChar >= snumChars) {
                    curChar = 0;
                    try {
                        snumChars = stream.read(buf);
                    } catch (IOException e) {
                        throw new InputMismatchException();
                    }
                    if (snumChars <= 0)
                        return -1;
                }
                return buf[curChar++];
            }

            public int nextInt() {
                int c = snext();
                while (isSpaceChar(c)) {
                    c = snext();
                }
                int sgn = 1;
                if (c == '-') {
                    sgn = -1;
                    c = snext();
                }
                int res = 0;
                do {
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    res *= 10;
                    res += c - '0';
                    c = snext();
                } while (!isSpaceChar(c));
                return res * sgn;
            }

            public long nextLong() {
                int c = snext();
                while (isSpaceChar(c)) {
                    c = snext();
                }
                int sgn = 1;
                if (c == '-') {
                    sgn = -1;
                    c = snext();
                }
                long res = 0;
                do {
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    res *= 10;
                    res += c - '0';
                    c = snext();
                } while (!isSpaceChar(c));
                return res * sgn;
            }

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

            public String readString() {
                int c = snext();
                while (isSpaceChar(c)) {
                    c = snext();
                }
                StringBuilder res = new StringBuilder();
                do {
                    res.appendCodePoint(c);
                    c = snext();
                } while (!isSpaceChar(c));
                return res.toString();
            }

            public String nextLine() {
                int c = snext();
                while (isSpaceChar(c))
                    c = snext();
                StringBuilder res = new StringBuilder();
                do {
                    res.appendCodePoint(c);
                    c = snext();
                } while (!isEndOfLine(c));
                return res.toString();
            }

            public boolean isSpaceChar(int c) {
                if (filter != null)
                    return filter.isSpaceChar(c);
                return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
            }

            private boolean isEndOfLine(int c) {
                return c == '\n' || c == '\r' || c == -1;
            }

            public interface SpaceCharFilter {
                public boolean isSpaceChar(int ch);
            }
        }

    }
    class SegmentTree{
    int s[],n;

    int li[];
    long qn[];
	SegmentTree(int a[],long q[]){
        n=a.length;
        qn=q;
        li=a;
		int l=(int)Math.ceil(Math.log(n)/Math.log(2));
		l=2*(int)Math.pow(2,l)-1;
		s=new int[l];
		createSegmentTreeUtil(a, 0, 0, a.length-1);
	}

	int createSegmentTreeUtil(int a[],int root,int l,int r){
		if(l==r)
		s[root]=l;
		else
		s[root]= Compare(createSegmentTreeUtil(a, 2*root+1, l, (l+r)/2), createSegmentTreeUtil(a,2*root+2, (l+r)/2+1,r));
		return s[root];
	}
	int getValue(int gl,int gr){
		return getValueUtil(0, 0, n-1, gl, gr);
	}
	int getValueUtil(int root,int l,int r,int gl,int gr){
		if(l>=gl&&r<=gr){
			return s[root];
		}
		if(l>gr||r<gl){
			return n;
		}
		return Compare(getValueUtil(2*root+1, l, (l+r)/2, gl, gr), getValueUtil(2*root+2, (l+r)/2+1, r, gl, gr));
	}
	void update(int p,int k){
		updateUtil(p, k,0,0,n-1);
	}
	int updateUtil(int p,int k,int root,int l,int r){
		if(l==r&&l==k){
			return s[root]=p;
		}
		else if(l>k||r<k)
		return s[root];
		else{
			return s[root]=Compare(updateUtil(p, k, 2*root+1, l, (l+r)/2), updateUtil(p, k, 2*root+2,(l+r)/2+1,r ));
		}
	}
	int Compare(int a,int b){
        if(a>=n&&b>=n){
            System.out.println("adfna");
        }

		if(a>=n){
            return b;
        }
        if(b>=n){
            return a;
        }
        if(li[a]==li[b]){
            if(qn[a]>qn[b]){
                return a;
            }
            else return b;
        }
        else if(li[a]<li[b])
        return b;
        else return a;

	}
}


import java.io.*;
import java.io.IOException;
import java.util.*;
import java.util.function.DoublePredicate;

//import javafx.util.Pair;
//import java.util.concurrent.LinkedBlockingDeque;

  public class Codeforces {

        public static long mod = (long)Math.pow(10,9)+7 ;
        public static double epsilon=0.00000000008854;//value of epsilon
        public static InputReader sc = new InputReader(System.in);
        public static PrintWriter pw = new PrintWriter(System.out);

        // fun(n,sum)=fun(n-1,sum)+fun(n-1,sum-n^x);
        public static int parent(int a,int p[]){
            if(a!=p[a]){
                p[a]=parent(p[a], p);
            }
            return p[a];
        }
       public static void Union(int a,int b,int p[],int size[]){
            a=parent(a, p);
            b=parent(b, p);
            if(a!=b){
                p[a]=b;
                size[b]+=size[a];
            }
       }

       //public static void dfs1(ArrayList<ArrayList<Integer>> g,int u,int vis[] )
       public static int findLengthOfShortestSubarray(int[] a) {
            TreeMap<Integer,Integer> left=new TreeMap<>();
            left.put(a[0],1);
            int ans=1;
            for(int i=1;i<a.length;i++){
                if(a[i]>=a[i-1])
                left.put(a[i], i+1);
                else{
                    break;
                }
                ans++;
            }
            int t=0;

            if(ans!=a.length)
            for(int i=a.length-1;i>=0;i--){
                if((i==a.length-1)||a[i]<=a[i+1]){
                    t++;
                    Integer k=left.floorKey(a[i]);

                    if(k==null){
                        ans=Math.max(ans, t);
                    }
                    else{
                        //pw.println(k);
                        ans=Math.max(ans, left.get(k)+t);
                    }
                }
                else{
                    break;
                }
            }
            return a.length-ans;

        }
        public static int getXor(int k){
            pw.println(1+" "+k);
            pw.flush();
            int t=sc.nextInt();
            return t;
        }

        public static int daimeterUtil(int r,ArrayList<ArrayList <Integer>> a,int h[],int vis[]){
            vis[r]=1;
            int m1=0,m2=0,d=0;
            for(int i=0;i<a.get(r).size();i++){
                int u=a.get(r).get(i);
                if(vis[u]!=1){
                    if(h[u]+1>m1){
                        m2=m1;
                        m1=h[u]+1;
                    }
                    else if(h[u]+1>m2){
                        m2=h[u]+1;
                    }
                }
            }
            d=Math.max(m1+m2, d);
            for(int i=0;i<a.get(r).size();i++){
                int u=a.get(r).get(i);
                if(vis[u]!=1){
                    d=Math.max(daimeterUtil(u, a, h, vis), d);
                }
            }
            return d;

        }
        public static int hieght(int r,int h[],ArrayList<ArrayList <Integer>> a,int vis[],int p[]){//bottom Up
            vis[r]=1;
            for(int i=0;i<a.get(r).size();i++){
                int v=a.get(r).get(i);
                if(vis[v]==0){
                    p[v]=r;
                    h[r]=Math.max(h[r], 1+hieght(v, h, a, vis,p));
                }
            }
            return h[r];
        }
        public static int daimeter(int r,ArrayList<ArrayList <Integer>> a){
            int n=a.size();
            int h[]=new int[n];
            int p[]=new int[n];
            hieght(r, h, a, new int[n], p);
            //ans[0]=h[b-1];
            return daimeterUtil(r, a, h, new int[n]);
        }
        public static void hieghtBfs(int r,int h[],ArrayList<ArrayList <Integer>> a,int p[],int vis[]){/// top to bottom
            Deque<Integer> q=new LinkedList<>();
            q.add(r);
            int c=1;
            p[r]=-1;
            vis[r]=1;
            while(q.size()>0){
                int l=q.size();
                while(l-->0){
                    int v=q.remove();
                    h[v]=c;
                    for(int i=0;i<a.get(v).size();i++){
                        int u=a.get(v).get(i);
                        if(vis[u]==0){
                            p[u]=v;
                            vis[u]=1;
                            q.add(u);
                        }
                    }
                }
                c++;
            }
        }
        public static ArrayList<ArrayList <Integer>> GetGraph(int n,int m){
            ArrayList<ArrayList <Integer>> a=new ArrayList<>();
            for(int i=0;i<n;i++){
                a.add(new ArrayList<>());
            }
            for(int i=0;i<m;i++){
                int u=sc.nextInt()-1;
                int v=sc.nextInt()-1;
                a.get(u).add(v);
                a.get(v).add(u);
            }
            return a;
        }

        public static void main(String[] args) {
            // code starts..
            Random rand=new Random();
            int q=sc.nextInt();
            while(q-->0){
                int n=sc.nextInt();
                int a=sc.nextInt();
                int b=sc.nextInt();
                int da=sc.nextInt();
                int db=sc.nextInt();
                ArrayList<ArrayList<Integer>> g=GetGraph(n, n-1);
                //int ans[]=new int[1];
                int d=daimeter(0, g)+1;
                int h[]=new int[n];

                hieghtBfs(a-1, h, g, new int[n], new int[n]);
                //pw.println(Arrays.toString(h));
                int dist=h[b-1]-1;
                int maxh=d/2+d%2;
                ///pw.println(dist +" dflh "+maxh+" "+a+" "+b);
                db=Math.min(d, db);

                if(dist<=da){
                    pw.println("Alice");
                }
                else if(db<=2*da){
                    pw.println("Alice");
                }
                else{
                    pw.println("Bob");
                }
                //pw.println(d);

            }
            // Code ends...
            pw.flush();
            pw.close();
        }

        public static Comparator<Long[]> column(int i){
            return
            new Comparator<Long[]>() {
                @Override
                public int compare(Long[] o1, Long[] o2) {
                    return o1[i].compareTo(o2[i]);//for ascending
                    //return o2[i].compareTo(o1[i]);//for descending
                }
            };
        }
        public static Comparator<Integer[]> col(int i){
            return
            new Comparator<Integer[]>() {
                @Override
                public int compare(Integer[] o1, Integer[] o2) {
                    return o1[i].compareTo(o2[i]);//for ascending
                    //return o2[i].compareTo(o1[i]);//for descending
                }
            };
        }
        public static Comparator<Integer> des(){
            return
            new Comparator<Integer>() {
                @Override
                public int compare(Integer o1, Integer o2) {
                    //return o1[i].compareTo(o2[i]);//for ascending
                    return o2.compareTo(o1);//for descending
                }
            };
        }

        public static String reverseString(String s){
            StringBuilder input1 = new StringBuilder();
            input1.append(s);
            input1 = input1.reverse();
            return input1.toString();
        }
        public static int[] scanArray(int n){
            int a[]=new int [n];
            for(int i=0;i<n;i++)
            a[i]=sc.nextInt();

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

            return a;
        }
        public static String [] scanStrings(int n){
            String a[]=new String [n];
            for(int i=0;i<n;i++)
            a[i]=sc.nextLine();

            return a;
        }
        public static class InputReader {

            private final InputStream stream;
            private final byte[] buf = new byte[8192];
            private int curChar, snumChars;
            private SpaceCharFilter filter;

            public InputReader(InputStream stream) {
                this.stream = stream;
            }

            public int snext() {
                if (snumChars == -1)
                    throw new InputMismatchException();
                if (curChar >= snumChars) {
                    curChar = 0;
                    try {
                        snumChars = stream.read(buf);
                    } catch (IOException e) {
                        throw new InputMismatchException();
                    }
                    if (snumChars <= 0)
                        return -1;
                }
                return buf[curChar++];
            }

            public int nextInt() {
                int c = snext();
                while (isSpaceChar(c)) {
                    c = snext();
                }
                int sgn = 1;
                if (c == '-') {
                    sgn = -1;
                    c = snext();
                }
                int res = 0;
                do {
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    res *= 10;
                    res += c - '0';
                    c = snext();
                } while (!isSpaceChar(c));
                return res * sgn;
            }

            public long nextLong() {
                int c = snext();
                while (isSpaceChar(c)) {
                    c = snext();
                }
                int sgn = 1;
                if (c == '-') {
                    sgn = -1;
                    c = snext();
                }
                long res = 0;
                do {
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    res *= 10;
                    res += c - '0';
                    c = snext();
                } while (!isSpaceChar(c));
                return res * sgn;
            }

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

            public String readString() {
                int c = snext();
                while (isSpaceChar(c)) {
                    c = snext();
                }
                StringBuilder res = new StringBuilder();
                do {
                    res.appendCodePoint(c);
                    c = snext();
                } while (!isSpaceChar(c));
                return res.toString();
            }

            public String nextLine() {
                int c = snext();
                while (isSpaceChar(c))
                    c = snext();
                StringBuilder res = new StringBuilder();
                do {
                    res.appendCodePoint(c);
                    c = snext();
                } while (!isEndOfLine(c));
                return res.toString();
            }

            public boolean isSpaceChar(int c) {
                if (filter != null)
                    return filter.isSpaceChar(c);
                return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
            }

            private boolean isEndOfLine(int c) {
                return c == '\n' || c == '\r' || c == -1;
            }

            public interface SpaceCharFilter {
                public boolean isSpaceChar(int ch);
            }
        }

    }
    class SegmentTree{
    int s[],n;

    int li[];
    long qn[];
	SegmentTree(int a[],long q[]){
        n=a.length;
        qn=q;
        li=a;
		int l=(int)Math.ceil(Math.log(n)/Math.log(2));
		l=2*(int)Math.pow(2,l)-1;
		s=new int[l];
		createSegmentTreeUtil(a, 0, 0, a.length-1);
	}

	int createSegmentTreeUtil(int a[],int root,int l,int r){
		if(l==r)
		s[root]=l;
		else
		s[root]= Compare(createSegmentTreeUtil(a, 2*root+1, l, (l+r)/2), createSegmentTreeUtil(a,2*root+2, (l+r)/2+1,r));
		return s[root];
	}
	int getValue(int gl,int gr){
		return getValueUtil(0, 0, n-1, gl, gr);
	}
	int getValueUtil(int root,int l,int r,int gl,int gr){
		if(l>=gl&&r<=gr){
			return s[root];
		}
		if(l>gr||r<gl){
			return n;
		}
		return Compare(getValueUtil(2*root+1, l, (l+r)/2, gl, gr), getValueUtil(2*root+2, (l+r)/2+1, r, gl, gr));
	}
	void update(int p,int k){
		updateUtil(p, k,0,0,n-1);
	}
	int updateUtil(int p,int k,int root,int l,int r){
		if(l==r&&l==k){
			return s[root]=p;
		}
		else if(l>k||r<k)
		return s[root];
		else{
			return s[root]=Compare(updateUtil(p, k, 2*root+1, l, (l+r)/2), updateUtil(p, k, 2*root+2,(l+r)/2+1,r ));
		}
	}
	int Compare(int a,int b){
        if(a>=n&&b>=n){
            System.out.println("adfna");
        }

		if(a>=n){
            return b;
        }
        if(b>=n){
            return a;
        }
        if(li[a]==li[b]){
            if(qn[a]>qn[b]){
                return a;
            }
            else return b;
        }
        else if(li[a]<li[b])
        return b;
        else return a;

	}
}