import java.util.*;
import java.io.*;
import static java.lang.Math.*;

public class MyClass {
    
    static class Pos{
        int x, y;
        
        public Pos(int x, int y){
            this.x = x;
            this.y = y;
        }
        
        public int hashCode(){
            return Objects.hash(x,y);
        }
        
        public boolean equals(Pos p){
            return this.x == p.x && this.y == p.y;
        }
    }
    
    static boolean checkNeighbourGood(int x, int y, int n, int m, char[][] maze){
        int[] dx = {1, 0, -1, 0};
        int[] dy = {0, 1, 0, -1};
        boolean ans = false;
        for(int i = 0; i < 4; i++){
            int newx = x+dx[i];
            int newy = y+dy[i];
            if(newx >= 0 && newx < n && newy >= 0 && newy < m){
                if(maze[newx][newy] == 'G'){
                    ans = true;
                    break;
                }else{
                    maze[newx][newy] = (maze[newx][newy] != 'B') ? '#' : 'B';
                }
            }
        }
        
        return ans;
    }
    
    
    static boolean ifPath(Pos start, int n, int m, char[][] maze){
        boolean[][] visited = new boolean[n][m];
        LinkedList<Pos> Q = new LinkedList<>();
        Q.add(start);
        visited[start.x][start.y] = true;
        boolean found = true;
        while(!Q.isEmpty()){
            Pos top = Q.pollFirst();
            int[] dx = {1, 0, -1, 0};
            int[] dy = {0, 1, 0, -1};    
            for(int i = 0; i < 4; i++){
                int newx = top.x + dx[i];
                int newy = top.y + dy[i];
                if(newx>=0 && newx < n && newy >=0 && newy< m &&!visited[newx][newy] && maze[newx][newy] != '#'){
                    Q.add(new Pos(newx, newy));
                    visited[newx][newy] = true;
                }
            }
        }
        
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                if((maze[i][j] == 'G' && !visited[i][j]) || (maze[i][j] == 'B' && visited[i][j])){
                    return false;
                }
            }
        }
        
        return found;
    }
    
    
    public static void main(String args[]) throws IOException {
        //Scanner sc = new Scanner(System.in);
        //Reader sc = new Reader();
        InputReader sc = new InputReader(System.in);
        PrintWriter pw = new PrintWriter(System.out);
            int T = sc.nextInt();
            while(T-- > 0){
                int n = sc.nextInt();
                int m =sc.nextInt();
                char[][] maze = new char[n][];
                for(int i = 0 ; i < n ; i++){
                    String s = sc.readString();
                    maze[i] = s.toCharArray();
                }
                int good = 0;
                String ans = "";
                for(int i = 0 ; i < n; i++){
                    for(int j = 0 ; j < m ; j++){
                        if(maze[i][j] == 'B'){
                            if(checkNeighbourGood(i, j, n, m, maze)){
                                ans = "No";
                                break;
                            }
                        }else if(maze[i][j] == 'G'){
                           good++;
                        }
                    }
                    if(ans.equals("No")){
                        break;
                    }
                }
                if(ans.equals("No")){
                    pw.println(ans);
                }else{
                    if((good == 0)  || ((maze[n-1][m-1] == '.' || maze[n-1][m-1] == 'G') && ifPath(new Pos(n-1,m-1),n, m,maze))){
                        ans = "Yes";
                    }else{
                        ans = "No";
                    }
                    pw.println(ans);
                }
            }
            
            pw.close();
          
    }
    
    static class InputReader
    {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;
 
        public InputReader(InputStream stream)
        {
            this.stream = stream;
        }
 
        public int read()
        {
            if (numChars==-1)
                throw new InputMismatchException();
 
            if (curChar >= numChars)
            {
                curChar = 0;
                try
                {
                    numChars = stream.read(buf);
                }
                catch (IOException e)
                {
                    throw new InputMismatchException();
                }
 
                if(numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }
 
        public String nextLine()
        {
            BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
            String stock = "";
            try
            {
                stock = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return stock;
        }
        public int nextInt()
        {
            int c = read();
 
            while(isSpaceChar(c))
                c = read();
 
            int sgn = 1;
 
            if (c == '-')
            {
                sgn = -1;
                c = read();
            }
 
            int res = 0;
            do
            {
                if(c<'0'||c>'9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));
 
            return res * sgn;
        }
 
        public long nextLong()
        {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-')
            {
                sgn = -1;
                c = read();
            }
            long res = 0;
 
            do
            {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));
            return res * sgn;
        }
 
        public double nextDouble()
        {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-')
            {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.')
            {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, nextInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.')
            {
                c = read();
                double m = 1;
                while (!isSpaceChar(c))
                {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, nextInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }
 
        public String readString()
        {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do
            {
                res.appendCodePoint(c);
                c = read();
            }
            while (!isSpaceChar(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;
        }
 
        public String next()
        {
            return readString();
        }
 
        public interface SpaceCharFilter
        {
            public boolean isSpaceChar(int ch);
        }
    }
 
    
    
    static class Reader 
    { 
        final private int BUFFER_SIZE = 1 << 20; 
        private DataInputStream din; 
        private byte[] buffer; 
        private int bufferPointer, bytesRead; 
  
        public Reader() 
        { 
            din = new DataInputStream(System.in); 
            buffer = new byte[BUFFER_SIZE]; 
            bufferPointer = bytesRead = 0; 
        } 
  
        public Reader(String file_name) throws IOException 
        { 
            din = new DataInputStream(new FileInputStream(file_name)); 
            buffer = new byte[BUFFER_SIZE]; 
            bufferPointer = bytesRead = 0; 
        } 
  
        public String nextLine() throws IOException 
        { 
            byte[] buf = new byte[64]; // line length 
            int cnt = 0, c; 
            while ((c = read()) != -1) 
            { 
                if (c == '\n') 
                    break; 
                buf[cnt++] = (byte) c; 
            } 
            return new String(buf, 0, cnt); 
        } 
  
        public int nextInt() throws IOException 
        { 
            int ret = 0; 
            byte c = read(); 
            while (c <= ' ') 
                c = read(); 
            boolean neg = (c == '-'); 
            if (neg) 
                c = read(); 
            do
            { 
                ret = ret * 10 + c - '0'; 
            }  while ((c = read()) >= '0' && c <= '9'); 
  
            if (neg) 
                return -ret; 
            return ret; 
        } 
  
        public long nextLong() throws IOException 
        { 
            long ret = 0; 
            byte c = read(); 
            while (c <= ' ') 
                c = read(); 
            boolean neg = (c == '-'); 
            if (neg) 
                c = read(); 
            do { 
                ret = ret * 10 + c - '0'; 
            } 
            while ((c = read()) >= '0' && c <= '9'); 
            if (neg) 
                return -ret; 
            return ret; 
        } 
  
        public double nextDouble() throws IOException 
        { 
            double ret = 0, div = 1; 
            byte c = read(); 
            while (c <= ' ') 
                c = read(); 
            boolean neg = (c == '-'); 
            if (neg) 
                c = read(); 
  
            do { 
                ret = ret * 10 + c - '0'; 
            } 
            while ((c = read()) >= '0' && c <= '9'); 
  
            if (c == '.') 
            { 
                while ((c = read()) >= '0' && c <= '9') 
                { 
                    ret += (c - '0') / (div *= 10); 
                } 
            } 
  
            if (neg) 
                return -ret; 
            return ret; 
        } 
  
        private void fillBuffer() throws IOException 
        { 
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE); 
            if (bytesRead == -1) 
                buffer[0] = -1; 
        } 
  
        private byte read() throws IOException 
        { 
            if (bufferPointer == bytesRead) 
                fillBuffer(); 
            return buffer[bufferPointer++]; 
        } 
  
        public void close() throws IOException 
        { 
            if (din == null) 
                return; 
            din.close(); 
        } 
    } 
    
    
    
}