/*
Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.
But if it had to perish twice,
I think I know enough of hate
To say that for destruction ice
Is also great
And would suffice.
*/
import java.io.*;
import java.util.*;
 
public final class Main{

    static class DSU{
        int[] parent;
        int[] size;
        DSU(int n){
            parent = new int[n + 1];
            size = new int[n + 1];
            for(int i = 0; i <= n; i++){
                parent[i] = i;
                size[i] = 1;
            }
        }
        int getRoot(int i){
            while(i != parent[i]){
                parent[i] = parent[parent[i]];
                i = parent[i];
            }
            return i;
        }
        boolean find(int i, int j){
            return (getRoot(i) == getRoot(j)) ? true : false;
        }
        void union(int i, int j){
            if(find(i, j))  return;
            int rooti = getRoot(i);
            int rootj = getRoot(j);
            if(size[rooti] > size[rootj]){
                parent[rootj] = rooti;
                size[rooti] += size[rootj];
            }
            else{
                parent[rooti] = rootj;
                size[rootj] += size[rooti];
            }
        }
    }
    
    public static long GCD(long a, long b) {
        while(b != 0){
            long temp = a;
            a = b;
            b = temp % b;
        }
        return a;
    }
    
    public static final long MOD = 1000000007;
    public static final int limit = 500005;
    
    static class InputReader {
 
        private final InputStream stream;
        private final byte[] buf = new byte[8192];
        private int curChar, snumChars;
        private SpaceCharFilter filter;
 
        public InputReader(InputStream stream) {
            this.stream = stream;
        }
 
        public int snext() {
            if (snumChars == -1)
                throw new InputMismatchException();
            if (curChar >= snumChars) {
                curChar = 0;
                try {
                    snumChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (snumChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }
 
        public int nextInt() {
            int c = snext();
            while (isSpaceChar(c)) {
                c = snext();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = snext();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = snext();
            } while (!isSpaceChar(c));
            return res * sgn;
        }
 
        public long nextLong() {
            int c = snext();
            while (isSpaceChar(c)) {
                c = snext();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = snext();
            }
            long res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = snext();
            } while (!isSpaceChar(c));
            return res * sgn;
        }
 
        public int[] nextIntArray(int n) {
            int a[] = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = nextInt();
            }
            return a;
        }
 
        public String readString() {
            int c = snext();
            while (isSpaceChar(c)) {
                c = snext();
            }
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = snext();
            } while (!isSpaceChar(c));
            return res.toString();
        }
 
        public String nextLine() {
            int c = snext();
            while (isSpaceChar(c))
                c = snext();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = snext();
            } while (!isEndOfLine(c));
            return res.toString();
        }
 
        public boolean isSpaceChar(int c) {
            if (filter != null)
                return filter.isSpaceChar(c);
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }
 
        private boolean isEndOfLine(int c) {
            return c == '\n' || c == '\r' || c == -1;
        }
 
        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
    }

    public static void canReach(char[][] A, int i, int j, boolean[][] vis){
        vis[i][j] = true;
        int n = A.length, m = A[0].length;
        int[] di = {1, 0, -1, 0};
        int[] dj = {0, 1, 0, -1};
        for(int k = 0; k < 4; k++){
            int x = i + di[k];
            int y = j + dj[k];
            if( x < 0 || x >= n || y < 0 || y >= m || A[x][y] == '#')  continue;
            if(!vis[x][y])  canReach(A, x, y, vis);
        }  
    }

    public static void main(String[] args) {
        InputReader in = new InputReader(System.in);
        PrintWriter w = new PrintWriter(System.out);
 
        int t = in.nextInt();
        //int t=1;
        while (t-- > 0) {
            if (System.getProperty("ONLINE_JUDGE") == null) w.println("=========================================");
            int n = in.nextInt();
            int m = in.nextInt();
            char[][] A = new char[n][m];
            for(int i = 0; i < n; i++){
                String s = in.nextLine();
                A[i] = s.toCharArray();
            }

            int[] di = {1, 0, -1, 0};
            int[] dj = {0, 1, 0, -1};
            boolean isPossible = true;

            //block all neighbours around bad people
            for(int i = 0; i < n; i++){
                for(int j = 0; j < m; j++){
                    if(A[i][j] == 'B'){
                        for(int k = 0; k < 4; k++){
                            int x = i + di[k];
                            int y = j + dj[k];
                            if( x < 0 || x >= n || y < 0 || y >= m)  continue;
                            if(A[x][y] == 'G')          isPossible = false;
                            else if(A[x][y] == '.')     A[x][y] = '#';
                        }
                    }
                    if(!isPossible)     break;
                }
                if(!isPossible)     break;
            }

            if(isPossible){
                if(A[n - 1][m - 1] != '#'){
                    boolean[][] vis = new boolean[n][m];
                    canReach(A, n - 1, m - 1, vis);
                    for(int i = 0; i < n; i++){
                        for(int j = 0; j < m; j ++){
                            if(A[i][j] == 'G' && !vis[i][j]){
                                isPossible = false;
                                break;
                            }
                            if(A[i][j] == 'B' && vis[i][j]){
                                isPossible = false;
                                break;
                            }
                        }
                        if(!isPossible)     break;
                    }
                }
                else{
                    for(int i = 0; i < n; i++){
                        for(int j= 0; j < m; j++){
                            if(A[i][j] == 'G'){
                                isPossible = false;
                                break;
                            }
                        }
                        if(!isPossible) break;
                    }
                }
            }

            w.println((isPossible)? "Yes" : "No");
        }
        w.close();
    }
}