import java.io.*;
import java.math.*;
import java.util.*;
public class R648Q4 {

	public static void main(String[] args) { //Just use BFS instead! 
		//(DFS on all paths is simply to tedious to check for one boolean possibility)
		FastScanner input = new FastScanner();
		PrintWriter w = new PrintWriter(System.out);
		int T = input.nextInt();
		for (int i = 1; i <= T; i++) {
			int rows = input.nextInt();
			int cols = input.nextInt();
			boolean bad = false;
			char[][] grid = new char[rows][cols];
			for (int r = 0; r < rows; r++) {
				grid[r]=input.next().toCharArray();
			}
			for (int r = 0; r < rows; r++) {
				for (int c = 0; c < cols; c++){
					if (grid[r][c]=='B') { //Confining bad people
						//by blocking all cardinal directions
						if (r>0) {
							if (grid[r-1][c]=='G') bad=true;
							else if (grid[r-1][c]!='B') grid[r-1][c]='#';
						}
						if (r<rows-1) {
							if (grid[r+1][c]=='G') bad=true;
							else if (grid[r+1][c]!='B') grid[r+1][c]='#';
						}
						if (c>0) {
							if (grid[r][c-1]=='G') bad=true;
							else if (grid[r][c-1]!='B') grid[r][c-1]='#';
						}
						if (c<cols-1) {
							if (grid[r][c+1]=='G') bad=true;
							else if (grid[r][c+1]!='B') grid[r][c+1]='#';
						}
					}
					if (bad) break;
				}
				if (bad) break;
			}
			/*for (int r = 0; r < rows; r++) {
				for (int c = 0; c < cols; c++) {
					System.out.print(grid[r][c]);
				}
				System.out.print("\n");
			}*/
			//if (grid[rows-1][cols-1]=='#') bad=true;
			if (!bad) { //Actual BFS needed if test case is not trivial
				boolean[][] outvis = new boolean[rows][cols];
				for (int r = 0; r < rows; r++) {
					for (int c = 0; c < cols; c++) {
						if (grid[r][c]=='G'&&!outvis[r][c]) {
							outvis[r][c]=true;
							int[] start = {r,c};
							int[] end = {rows-1,cols-1};
							if (!BFS(start,end,grid,rows,cols,outvis)) {
								bad=true;
								break;
							}
						}
					}
					if (bad) break;
				}
			}
			w.println(bad?"No":"Yes");
			w.flush();
		}
	}
	public static boolean BFS(int[] start, int[] end, char[][] grid,int rows, int cols,
	boolean[][] outvis) {
		Queue<int[]> cur = new LinkedList<int[]>();
		boolean[][] vis = new boolean[rows][cols];
		vis[start[0]][start[1]]=true;
		cur.add(start);
		while (!cur.isEmpty()) {
			for (int i = 0; i < cur.size(); i++) {
				int[] pair = cur.poll(); //Current coordinates
				int r = pair[0];
				int c = pair[1];
				int[] U = {r-1,c};
				int[] D = {r+1,c};
				int[] L = {r,c-1};
				int[] R = {r,c+1}; //Up, Down, Left, Right
				if (r>0&&!vis[r-1][c]&&grid[r-1][c]!='#') {
					cur.add(U);
					vis[r-1][c]=true;
					if (grid[r-1][c]=='G') outvis[r-1][c]=true;
					if (r-1==end[0]&&c==end[1]) return true;
				} 
				if (r<rows-1&&!vis[r+1][c]&&grid[r+1][c]!='#') {
					cur.add(D);
					vis[r+1][c]=true;
					if (grid[r+1][c]=='G') outvis[r+1][c]=true;
					if (r+1==end[0]&&c==end[1]) return true;
				} 
				if (c>0&&!vis[r][c-1]&&grid[r][c-1]!='#') {
					cur.add(L);
					vis[r][c-1]=true;
					if (grid[r][c-1]=='G') outvis[r][c-1]=true;
					if (r==end[0]&&c-1==end[1]) return true;
				} 
				if (c<cols-1&&!vis[r][c+1]&&grid[r][c+1]!='#') {
					cur.add(R);
					vis[r][c+1]=true;
					if (grid[r][c+1]=='G') outvis[r][c+1]=true;
					if (r==end[0]&&c+1==end[1]) return true;
				} 
				//if (cur.contains(end)) return true; This only checks address 
				//not individual content...
			}
		}
		return false;
	}
	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());
		}
	}
}
