// Utilities
import java.io.*;
import java.util.*;

public class Main {
	static int T;
	static int N, M;
	static char[][] grid;
	static ArrayList<Pair> idxGood;
	static int goodCnt, goodCmp;
	static int idxGr, idxGc;
	static int[][] d = {{1,0},{0,1},{-1,0},{0,-1}};
	static boolean[][] vis;
	static int nr, nc;
	static boolean existGood, existBad, visEnd;
	
	public static void main(String[] args) throws IOException {
		T = in.iscan();
		outer : while (T-- > 0) {
			N = in.iscan(); M = in.iscan(); grid = new char[N][M];
			existGood = false; existBad = false; idxGood = new ArrayList<Pair>();
			goodCnt = 0; idxGr = -1; idxGc = -1;
			for (int i = 0; i < N; i++) {
				grid[i] = in.sscan().toCharArray();
				for (int j = 0; j < M; j++) {
					if (grid[i][j] == 'G') {
						existGood = true;
						idxGr = i; idxGc = j;
						goodCnt++;
					}
					if (grid[i][j] == 'B') existBad = true;
				}
			}
			for (int i = 0; i < N; i++) {
				for (int j = 0; j < M; j++) {
					if (grid[i][j] == 'B') {
						for (int k = 0; k < 4; k++) {
							nr = i + d[k][0]; nc = j + d[k][1];
							if (nr < 0 || nr == N || nc < 0 || nc == M) continue;
							if (grid[nr][nc] == 'G') {
								out.println("No");
								continue outer;
							}
							if (grid[nr][nc] == '.') grid[nr][nc] = '#';
						}
					}
				}
			}
			if (existGood) {
				vis = new boolean[N][M]; goodCmp = 0; visEnd = false;
				dfs(idxGr, idxGc);
				if (goodCmp == goodCnt && visEnd) out.println("Yes");
				else out.println("No");
			}
			else { // !existGood
				out.println("Yes");
			}
		}
		out.close();
	} 
	
	static void dfs(int r, int c) {
		vis[r][c] = true;
		if (grid[r][c] == 'G') goodCmp++;
		if (r == N-1 && c == M-1) visEnd = true;
		for (int j = 0; j < 4; j++) {
			nr = r + d[j][0]; nc = c + d[j][1];
			if (nr < 0 || nr == N || nc < 0 || nc == M) continue;
			if (grid[nr][nc] != '#' && !vis[nr][nc]) dfs(nr, nc);
		}
	}
	
	static class Pair {
		int r, c;
		Pair(int r, int c){ this.r = r; this.c = c; }
	}
	
	static INPUT in = new INPUT(System.in);
	static PrintWriter out = new PrintWriter(System.out);
	private static class INPUT {

		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar, numChars;

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

		public INPUT (String file) throws IOException {
			this.stream = new FileInputStream (file);
		}

		public int cscan () throws IOException {
			if (curChar >= numChars) {
				curChar = 0;
				numChars = stream.read (buf);
			}
			
			if (numChars == -1)
				return numChars;

			return buf[curChar++];
		}

		public int iscan () throws IOException {
			int c = cscan (), sgn = 1;
			
			while (space (c))
				c = cscan ();

			if (c == '-') {
				sgn = -1;
				c = cscan ();
			}

			int res = 0;

			do {
				res = (res << 1) + (res << 3);
				res += c - '0';
				c = cscan ();
			}
			while (!space (c));

			return res * sgn;
		}

		public String sscan () throws IOException {
			int c = cscan ();
			
			while (space (c))
				c = cscan ();

			StringBuilder res = new StringBuilder ();

			do {
				res.appendCodePoint (c);
				c = cscan ();
			}
			while (!space (c));

			return res.toString ();
		}

		public double dscan () throws IOException {
			int c = cscan (), sgn = 1;
			
			while (space (c))
				c = cscan ();

			if (c == '-') {
				sgn = -1;
				c = cscan ();
			}

			double res = 0;

			while (!space (c) && c != '.') {
				if (c == 'e' || c == 'E')
					return res * UTILITIES.fast_pow (10, iscan ());
				
				res *= 10;
				res += c - '0';
				c = cscan ();
			}

			if (c == '.') {
				c = cscan ();
				double m = 1;

				while (!space (c)) {
					if (c == 'e' || c == 'E')
						return res * UTILITIES.fast_pow (10, iscan ());

					m /= 10;
					res += (c - '0') * m;
					c = cscan ();
				}
			}

			return res * sgn;
		}

		public long lscan () throws IOException {
			int c = cscan (), sgn = 1;
			
			while (space (c))
				c = cscan ();

			if (c == '-') {
				sgn = -1;
				c = cscan ();
			}

			long res = 0;

			do {
				res = (res << 1) + (res << 3);
				res += c - '0';
				c = cscan ();
			}
			while (!space (c));

			return res * sgn;
		}

		public boolean space (int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}
	}

	public static class UTILITIES {

		static final double EPS = 10e-6;

		public static int lower_bound (int[] arr, int x) {
			int low = 0, high = arr.length, mid = -1;

			while (low < high) {
				mid = (low + high) / 2;

				if (arr[mid] >= x)
					high = mid;
				else
					low = mid + 1;
			}

			return low;
		}

		public static int upper_bound (int[] arr, int x) {
			int low = 0, high = arr.length, mid = -1;

			while (low < high) {
				mid = (low + high) / 2;

				if (arr[mid] > x)
					high = mid;
				else
					low = mid + 1;
			}

			return low;
		}

		public static int gcd (int a, int b) {
			return b == 0 ? a : gcd (b, a % b);
		}

		public static int lcm (int a, int b) {
			return a * b / gcd (a, b);
		}

		public static long fast_pow_mod (long b, long x, int mod) {
			if (x == 0) return 1;
			if (x == 1) return b;
			if (x % 2 == 0) return fast_pow_mod (b * b % mod, x / 2, mod) % mod;

			return b * fast_pow_mod (b * b % mod, x / 2, mod) % mod;
		}

		public static int fast_pow (int b, int x) {
			if (x == 0) return 1;
			if (x == 1) return b;
			if (x % 2 == 0) return fast_pow (b * b, x / 2);

			return b * fast_pow (b * b, x / 2);
		}

		public static long choose (long n, long k) {
			k = Math.min (k, n - k);
			long val = 1;

			for (int i = 0; i < k; ++i)
				val = val * (n - i) / (i + 1);

			return val;
		}

		public static long permute (int n, int k) {
			if (n < k) return 0;
			long val = 1;

			for (int i = 0; i < k; ++i)
				val = (val * (n - i));

			return val;
		}
	}
}