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

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        boolean[][] visited;
        char[][] board;
        int[] moveR = new int[]{-1, 1, 0, 0};
        int[] moveC = new int[]{0, 0, -1, 1};
        int N;
        int M;

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int T = in.nextInt();
            while (T-- > 0) {
                N = in.nextInt();
                M = in.nextInt();
                board = new char[N + 2][M + 2];
                for (int i = 0; i <= N + 1; i++) {
                    if (i == 0 || i == N + 1) {
                        for (int j = 0; j <= M + 1; j++) {
                            board[i][j] = '#';
                        }
                    } else {
                        char[] a = in.next().toCharArray();
                        board[i][0] = '#';
                        board[i][M + 1] = '#';
                        for (int j = 0; j < M; j++) {
                            board[i][j + 1] = a[j];
                        }
                    }
                }
                boolean good = true;
                for (int i = 1; i <= N; i++) {
                    for (int j = 1; j <= M; j++) {
                        if (board[i][j] == 'B') {
                            for (int m = 0; m < 4; m++) {
                                int newR = i + moveR[m];
                                int newC = j + moveC[m];
                                if (board[newR][newC] == 'G') {
                                    good = false;
                                }
                            }
                        }
                    }
                }
                if (!good) {
                    out.println("No");
                } else {
                    for (int i = 1; i <= N; i++) {
                        for (int j = 1; j <= M; j++) {
                            if (board[i][j] == '.') {
                                for (int m = 0; m < 4; m++) {
                                    int newR = i + moveR[m];
                                    int newC = j + moveC[m];
                                    if (board[newR][newC] == 'B') {
                                        board[i][j] = '#';
                                    }
                                }
                            }
                        }
                    }
                    for (int i = 1; i <= N; i++) {
                        for (int j = 1; j <= M; j++) {
                            if (board[i][j] == 'B') {
                                board[i][j] = '#';
                            }
                        }
                    }
                    visited = new boolean[N + 2][M + 2];
                    if (board[N][M] != '#') {
                        hasPath(N, M);
                    }
                    good = true;
                    for (int i = 1; i <= N; i++) {
                        for (int j = 1; j <= M; j++) {
                            if (board[i][j] == 'G') {
                                if (!visited[i][j]) {
                                    good = false;
                                }
                            }
                        }
                    }
                    if (good) {
                        out.println("Yes");
                    } else {
                        out.println("No");
                    }
                }
            }
        }

        int hasPath(int i, int j) {
            int res = 0;
            for (int m = 0; m < 4; m++) {
                int newR = moveR[m] + i;
                int newC = moveC[m] + j;
                if (board[newR][newC] != '#' && !visited[newR][newC]) {
                    visited[newR][newC] = true;
                    hasPath(newR, newC);
                }
            }
            return res;
        }

    }

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

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

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

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

    }
}

