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

public class SolveTheMaze {

    static class Kattio extends PrintWriter {
        private BufferedReader r;
        private StringTokenizer st;

        // standard input
        public Kattio() { this(System.in,System.out); }
        public Kattio(InputStream i, OutputStream o) {
            super(o);
            r = new BufferedReader(new InputStreamReader(i));
        }
        // USACO-style file input
        public Kattio(String problemName) throws IOException {
            super(new FileWriter(problemName+".out"));
            r = new BufferedReader(new FileReader(problemName+".in"));
        }

        // returns null if no more input
        public String next() {
            try {
                while (st == null || !st.hasMoreTokens())
                    st = new StringTokenizer(r.readLine());
                return st.nextToken();
            } catch (Exception e) {}
            return null;
        }

        public int nextInt() { return Integer.parseInt(next()); }
        public double nextDouble() { return Double.parseDouble(next()); }
        public long nextLong() { return Long.parseLong(next()); }
    }

    static int[] rowMovement = {0, 1, 0, -1};  // right, down, left, up
    static int[] columnMovement = {1, 0, -1, 0};
    static char[][] grid;
    static boolean[][] visited;
    static int numRows;
    static int numColumns;

    static void floodfill (int row, int column) {
        visited[row][column] = true;
        //System.out.println(row + " " + column);

        for (int x = 0; x < 4; x++) {  // the 4 directions
            int newRow = row + rowMovement[x];
            int newColumn = column + columnMovement[x];
            if (newRow >= 0 && newRow < numRows && newColumn >= 0 && newColumn < numColumns) {  // in boundaries
                if (! visited[newRow][newColumn] && grid[newRow][newColumn] != '#') {  // not visited, and not #
                    floodfill(newRow, newColumn);
                }
            }
        }
    }

    static String solve () {
        int ok = 1;
        // surround the bad
        for (int i = 0; i < numRows; i++) {
            for (int j = 0; j < numColumns; j++) {
                if (grid[i][j] == 'B') {
                    for (int x = 0; x < 4; x++) {  // the 4 directions
                        int newRow = i + rowMovement[x];
                        int newColumn = j + columnMovement[x];
                        // check if it is in the boundaries
                        if (newRow >= 0 && newRow < numRows && newColumn >= 0 && newColumn < numColumns) {
                            if (grid[newRow][newColumn] == 'G') {  // make false
                                ok = 0;
                            }
                            if (grid[newRow][newColumn] == '.') {  // turn it into #
                                grid[newRow][newColumn] = '#';
                            }
                        }
                    }
                }
            }
        }

        /*
        System.out.println("Grid:");
        for (int x = 0; x < numRows; x++) {
            for (int y = 0; y < numColumns; y++) {
                if (y == (numColumns - 1)) {
                    System.out.println(grid[x][y]);
                    break;
                }
                System.out.print(grid[x][y]);
            }
        }

         */

        if (ok == 0) {
            return "No";
        }
        ok = 1;

        if (grid[numRows - 1][numColumns - 1] != '#') {
            floodfill(numRows - 1, numColumns - 1);  // floodfill it
        }

        /*
        System.out.println("Floodfill");
        for (int x = 0; x < numRows; x++) {
            for (int y = 0; y < numColumns; y++) {
                if (y == (numColumns - 1)) {
                    System.out.println(grid[x][y]);
                    break;
                }
                System.out.print(grid[x][y]);
            }
        }

         */

        for (int i = 0; i < numRows; i++) {
            for (int j = 0; j < numColumns; j++) {
                // make false if we find an unvisited G
                if (grid[i][j] == 'G' && !visited[i][j]) {
                    ok = 0;
                    break;
                }
            }
        }

        /*
        for (int x = 0; x < numRows; x++) {
            for (int y = 0; y < numColumns; y++) {
                if (y == (numColumns - 1)) {
                    System.out.println(visited[x][y]);
                    break;
                }
                System.out.print(visited[x][y]);
            }
        }

         */

        if (ok == 0) {
            return "No";
        }
        return "Yes";
    }

    public static void main (String[] args) {
        Kattio io = new Kattio();
        int numTestCases = io.nextInt();
        for (int x = 0; x < numTestCases; x++) {
            numRows = io.nextInt();
            numColumns = io.nextInt();
            grid = new char[numRows][numColumns];
            visited = new boolean[numRows][numColumns];

            for (int row = 0; row < numRows; row++) {  // read grid
                String line = io.next();
                for (int column = 0; column < numColumns; column++) {
                    grid[row][column] = line.charAt(column);
                }
            }
            io.println(solve());
        }
        io.close();
    }
    //CodeSnip{Kattio}
}
