from collections import defaultdict
import sys
import math
input=sys.stdin.readline
class disjoint:
    def __init__(self,n,m):
        self.rank=[[1 for j in range(m)] for i in range(n)]
        self.parent=[[(i,j) for j in range(m)] for i in range(n)]
        
        
        
    def find(self,x,y):
       
        if(self.parent[x][y]!=(x,y)):
            self.parent[x][y]=self.find(self.parent[x][y][0],self.parent[x][y][1])
        return self.parent[x][y];
       
    def union(self,x,y):
        xid=self.find(x[0],x[1])
        yid=self.find(y[0],y[1])
        
        if(xid==yid):
            return;

        if(self.rank[xid[0]][xid[1]]<self.rank[yid[0]][yid[1]]):
            self.parent[xid[0]][xid[1]]=yid
        
           
        elif(self.rank[xid[0]][xid[1]]>self.rank[yid[0]][yid[1]]):
            self.parent[yid[0]][yid[1]]=xid # merging y into x
                      
        else:
            self.parent[yid[0]][yid[1]]=xid
            self.rank[xid[0]][xid[1]]+=1
            
   
           
          

a=int(input())
for i in range(a):
    x,y=map(int,input().split())
    n,m=x,y
    ans=[]
    obj=disjoint(n,m)
    for i in range(x):
        
        z=input()
        t=[]
        for i in range(len(z)-1):
            t.append(z[i])
        ans.append(t)
    flag=0
    
    for i in range(x):
        for j in range(y):
            if(ans[i][j]=='B'):
                if(i+1<x):
                    if(ans[i+1][j]=='G'):
                        flag=1
                    elif(ans[i+1][j]=='.'):
                        ans[i+1][j]='#'
                if(j+1<y):
                    if(ans[i][j+1]=='G'):
                        flag=1
                    elif(ans[i][j+1]=='.'):
                        ans[i][j+1]='#'
                if(i-1>=0):
                    if(ans[i-1][j]=='G'):
                        flag=1
                    elif(ans[i-1][j]=='.'):
                        ans[i-1][j]='#'

                if(j-1>=0):
                    if(ans[i][j-1]=='G'):
                        flag=1
                    elif(ans[i][j-1]=='.'):
                        ans[i][j-1]='#'
                
    if(flag==1):
        print('No')
        continue;
    else:
        
        for i in range(n):
            for j in range(m):
                if(ans[i][j]=='.' or ans[i][j]=='G'):
                    if(i+1<x and (ans[i+1][j]=='.' or ans[i+1][j]=='G')):
                        obj.union((i,j),(i+1,j))
                        
                    if(i-1>=0 and (ans[i-1][j]=='.' or ans[i-1][j]=='G')):
                        obj.union((i,j),(i-1,j))
                
                    if(j+1<y and (ans[i][j+1]=='.' or ans[i][j+1]=='G')):
                        obj.union((i,j),(i,j+1))
                
                    if(j-1>=0 and (ans[i][j-1]=='.' or ans[i][j-1]=='G')):
                        obj.union((i,j),(i,j-1))
                    
        
        for i in range(n):
            for j in range(m):
                if(ans[i][j]=='G'):
                    if(obj.find(i,j)!=obj.find(n-1,m-1)):
                        flag=1
        if(flag==1):
            print('No')
        else:
            print('Yes')
    

       
        
        
        

#init function sort of creates the parent and the rank list
#find function is used for to find rank
#union function is used for doing the union
#what does path function do , it makes find operation almost linear
#makes our tree of very less height


#use of log *n function -

#number times log has to be applied to make log value as 1

#by using path compression time complexty of each function is log*n

#
    
            
                            
    
