import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import java.util.StringTokenizer;

public class SolveTheMaze { // Template for CF
    public static class ListComparator implements Comparator<List<Integer>> {

        @Override
        public int compare(List<Integer> l1, List<Integer> l2) {
            for (int i = 0; i < l1.size(); ++i) {
                if (l1.get(i).compareTo(l2.get(i)) != 0) {
                    return l1.get(i).compareTo(l2.get(i));
                }
            }
            return 0;
        }
    }

    public static class Pair {
        int first;
        int second;

        public Pair(int first, int second) {
            this.first = first;
            this.second = second;
        }

        public int getFirst() {
            return first;
        }

        public int getSecond() {
            return second;
        }
    }

    static int[] dir1 = { 1, 0, -1, 0 };
    static int[] dir2 = { 0, 1, 0, -1 };
    static boolean[][] visited;

    public static void main(String[] args) throws IOException {
        // Check for int overflow!!!!
        // Should you use a long to store the sum or smthn?
        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);
        int T = Integer.parseInt(f.readLine());
        for (int i = 0; i < T; i++) {
            StringTokenizer st = new StringTokenizer(f.readLine());
            int n = Integer.parseInt(st.nextToken());
            int m = Integer.parseInt(st.nextToken());
            List<List<Character>> grid = new ArrayList<>();
            List<Pair> good = new ArrayList<>();
            List<Pair> bad = new ArrayList<>();
            visited = new boolean[n][m];
            for (int j = 0; j < n; j++) {
                String str = f.readLine();
                List<Character> temp = new ArrayList<>();
                for (int k = 0; k < m; k++) {
                    temp.add(str.charAt(k));
                    if (str.charAt(k) == 'B') {
                        bad.add(new Pair(j, k));
                    } else if (str.charAt(k) == 'G') {
                        good.add(new Pair(j, k));
                    }
                }
                grid.add(temp);
            }
            boolean works = true;
            for (int k = 0; k < bad.size(); k++) {
                int a = bad.get(k).getFirst();
                int b = bad.get(k).getSecond();
                if (a == n - 1 && b == m - 1) {
                    works = false;
                }
                for (int j = 0; j < 4; j++) {
                    if ((a + dir1[j] >= 0 && a + dir1[j] < n) && (b + dir2[j] >= 0 && b + dir2[j] < m)) {
                        if (grid.get(a + dir1[j]).get(b + dir2[j]) == 'G') {
                            works = false;
                        } else if (grid.get(a + dir1[j]).get(b + dir2[j]) == '.') {
                            grid.get(a + dir1[j]).set(b + dir2[j], '#');
                        }
                    }
                }
            }
            /*
             * for (int j = 0; j < good.size(); j++) { boolean check = bfs(grid,
             * good.get(j), n, m); if (!check) { works = false; } }
             */
            if (good.size() > 0) {
                bfs(grid, good.get(0), n, m);
            }
            for (int j = 0; j < good.size(); j++) {
                if (!visited[good.get(j).getFirst()][good.get(j).getSecond()]) {
                    works = false;
                }
            }
            if (!visited[n - 1][m - 1]) {
                works = false;
            }
            if (good.size() == 0) {
                out.println("YES");
            } else if (works) {
                out.println("YES");
            } else {
                out.println("NO");
            }
        }
        out.close();
    }

    public static void bfs(List<List<Character>> grid, Pair start, int n, int m) {
        /*
         * if (start.getFirst() == n - 1 && start.getSecond() == m - 1) { return true; }
         */

        LinkedList<Pair> queue = new LinkedList<>();
        queue.add(start);
        while (queue.size() > 0) {

            Pair curr = queue.pollFirst();

            int a = curr.getFirst();
            int b = curr.getSecond();
            if (visited[a][b])
                continue;
            visited[a][b] = true;
            /*
             * for (int j = 0; j < visited.length; j++) {
             * System.out.println(Arrays.toString(visited[j])); }
             */
            for (int j = 0; j < 4; j++) {
                if ((a + dir1[j] >= 0 && a + dir1[j] < n) && (b + dir2[j] >= 0 && b + dir2[j] < m)) {
                    if (grid.get(a + dir1[j]).get(b + dir2[j]) != '#') {
                        // if (a + dir1[j] == n - 1 && b + dir2[j] == m - 1) {
                        // return;
                        // } else {
                        queue.add(new Pair(a + dir1[j], b + dir2[j]));
                        // }
                    }
                }
            }
        }

    }

}