//package codeforces.practice.oneVone.Nov03_2020;

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

public class E {
    static InputReader in;
    static PrintWriter out;

    public static void main(String[] args) {
        //initReaderPrinter(true);
        initReaderPrinter(false);
        solve(in.nextInt());
        //solve(1);        
    }

    static int n, m;
    static int[] dx = {-1,0,1,0}, dy = {0,1,0,-1};
    static void solve(int testCnt) {
        for (int testNumber = 0; testNumber < testCnt; testNumber++) {
            n = in.nextInt();
            m = in.nextInt();
            char[][] maze = new char[n][m];
            for(int i = 0; i < n; i++) {
                maze[i] = in.next().toCharArray();
            }
            int gCnt = 0, bCnt = 0;
            for(int i = 0; i < n; i++) {
                for(int j = 0; j < m; j++) {
                    if(maze[i][j] == 'G') gCnt++;
                    if(maze[i][j] == 'B') bCnt++;
                }
            }
            int[] cnt = bfs(maze);
            boolean can = (cnt[0] == gCnt && cnt[1] == 0);
            if(!can) {
                can = true;
                for(int i = 0; i < n; i++) {
                    for(int j = 0; j < m; j++) {
                        if(maze[i][j] == 'G') {
                            for(int k = 0; k < 4; k++) {
                                int x = i + dx[k];
                                int y = j + dy[k];
                                if(x >= 0 && x < n && y >= 0 && y < m && maze[x][y] == 'B') {
                                    can = false;
                                    break;
                                }
                            }
                        }
                        else if(maze[i][j] == '.') {
                            for(int k = 0; k < 4; k++) {
                                int x = i + dx[k];
                                int y = j + dy[k];
                                if(x >= 0 && x < n && y >= 0 && y < m && maze[x][y] == 'B') {
                                    maze[i][j] = '#';
                                    break;
                                }
                            }
                        }
                        if(!can) break;
                    }
                    if(!can) break;
                }
                if(can) {
                    cnt = bfs(maze);
                    can = (cnt[0] == gCnt && cnt[1] == 0);
                }
            }
            out.println(can ? "Yes" : "No");
        }
        out.close();
    }

    static int[] bfs(char[][] maze) {
        int[] cnt = new int[2];
        if(maze[n - 1][m - 1] == '.') {
            ArrayDeque<int[]> q = new ArrayDeque<>();
            boolean[][] visited = new boolean[n][m];
            q.add(new int[]{n - 1, m - 1});
            visited[n - 1][m - 1] = true;

            while(!q.isEmpty()) {
                int[] curr = q.pollFirst();
                for(int i = 0; i < 4; i++) {
                    int x = curr[0] + dx[i];
                    int y = curr[1] + dy[i];
                    if(x >= 0 && x < n && y >= 0 && y < m && !visited[x][y] && maze[x][y] != '#') {
                        if(maze[x][y] == 'G') cnt[0]++;
                        else if(maze[x][y] == 'B') cnt[1]++;
                        q.add(new int[]{x,y});
                        visited[x][y] = true;
                    }
                }
            }
        }
        return cnt;
    }

    static void initReaderPrinter(boolean test) {
        if (test) {
            try {
                in = new InputReader(new FileInputStream("src/input.in"));
                out = new PrintWriter(new FileOutputStream("src/output.out"));
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            in = new InputReader(System.in);
            out = new PrintWriter(System.out);
        }
    }

    static class InputReader {
        BufferedReader br;
        StringTokenizer st;

        InputReader(InputStream stream) {
            try {
                br = new BufferedReader(new InputStreamReader(stream), 32768);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        String next() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

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

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


