import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;
import java.util.StringTokenizer;
public class hacker51 {
	static class FastReader 
    { 
        BufferedReader br; 
        StringTokenizer st; 
  
        public FastReader() 
        { 
            br = new BufferedReader(new
                     InputStreamReader(System.in)); 
        } 
  
        String next() 
        { 
            while (st == null || !st.hasMoreElements()) 
            { 
                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; 
        } 
    } 
	
	static class Node {
		int pos;
		ArrayList<Node> child;
 
		Node(int a) {
			pos = a;
			child = new ArrayList<>();
		}
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		 OutputStream outputStream =System.out;
		    PrintWriter out =new PrintWriter(outputStream);
FastReader s=new FastReader();
int t=s.nextInt();
while(t>0) {
	int n=s.nextInt();
	int m=s.nextInt();
	int c=0;
	for(int i=1;i<=50;i++) {
		for(int j=1;j<=50;j++) {
			vis3[i][j]=0;
		}
	}
		count1=0;
	char[][] a=new char[n+1][m+1];
	for(int i=1;i<=n;i++) {
		String str=s.next();
		for(int j=1;j<=m;j++) {
			a[i][j]=str.charAt(j-1);
if(a[i][j]=='G') {
	c++;
}
		}
	}
	boolean p=true;
	out:for(int i=1;i<=n;i++) 
	{
		for(int j=1;j<=m;j++) {
			if(a[i][j]=='B') {
			for(int k=0;k<4;k++) {
				if(isValid(i+dx[k],j+dy[k],n,m) ) {
					if(a[i+dx[k]][j+dy[k]]=='G') {
						p=false;
						break out;
							
					}else if(a[i+dx[k]][j+dy[k]]=='.') {
						a[i+dx[k]][j+dy[k]]='#';
					}
				}
			}
		}
			
	}
		}
	if(!p) {
		out.println("No");
	}else {
		if(a[n][m]!='#') {
		dfs(n,m,n,m,a);}
		if(count1==c) {
			out.println("Yes");
		}else {
			out.println("No");
		}
	}
	
	t--;
}
	out.close();
}
	static boolean isValid(int x,int y,int n,int m) {
		if(x<=n && x>=1 && y<=m && y>=1) {
			return true;
		}
		return false;
	}
	static int[] dx= {1,-1,0,0};
	static int[] dy= {0,0,-1,1};
	static int[][] vis3=new int[51][51];
	static int count1=0;
	static void dfs(int x,int y,int  n,int m,char[][]a) {
		vis3[x][y]=1;
		if(a[x][y]=='G') {
			count1++;
		}
		for(int i=0;i<4;i++) {
			if(isValid(x+dx[i],y+dy[i],n,m) && vis3[x+dx[i]][y+dy[i]]==0) {
				if(a[x+dx[i]][y+dy[i]]=='.' || a[x+dx[i]][y+dy[i]]=='G') {
					dfs(x+dx[i],y+dy[i],n,m,a);
				}
			}
		}
	}
	public static void CreateSegmentTreeOfSum(long[] a,long[] b,int low,int high,int pos) {
		if(low==high) {
			b[pos]=a[low];
			return;
		}
		int mid=(low+high)/2;
		CreateSegmentTreeOfSum(a,b,low,mid,2*pos+1);
		CreateSegmentTreeOfSum(a,b,mid+1,high,2*pos+2);
		b[pos]=(b[2*pos+1]+b[2*pos+2]);
	}
	public static long QueryRangeOfSum(long[] b,int qlow,int qhigh,int low,int high,int pos) {
		if(low>=qlow && high<=qhigh) {
			return b[pos];
		}
		if(qhigh<low || qlow>high) {
			return 0;
		}
		int mid=(low+high)/2;
	return  QueryRangeOfSum(b,qlow,qhigh,low,mid,2*pos+1)
			+QueryRangeOfSum(b,qlow,qhigh,mid+1,high,2*pos+2);
	}
	public static void updateSum(long[] b,int low,int high,int pos ,long diff,int index) {
		if(low==high) {
			b[pos]=diff;
			return;
		}
		int mid=(low+high)/2;
		if(index<=mid) {
			updateSum(b,low,mid,2*pos+1,diff,index);
		}else {
			updateSum(b,mid+1,high,2*pos+2,diff,index);
		}
		b[pos]=b[2*pos+1]+b[2*pos+2];
	}
	static int nextPowerOf2(int n) 
	{ 
	    n--; 
	    n |= n >> 1; 
	    n |= n >> 2; 
	    n |= n >> 4; 
	    n |= n >> 8; 
	    n |= n >> 16; 
	    n++; 
	      
	    return n; 
	} 
}