import math
#import math 
#------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
 
BUFSIZE = 8192
 
 
class FastIO(IOBase):
    newlines = 0
 
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
 
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
 
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
 
    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
 
 
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
 
 
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
 
#-------------------game starts now----------------------------------------------------import math
class Graph: 
    def __init__(self): 
        self.graph = defaultdict(list) 
      
    # add edge to graph 
    def addEdge(self, u, v): 
        self.graph[u].append(v) 
  
    # BFS function to find path from source to sink      
    def BFS(self,a): 
          
        # Base case 
        # Mark all the vertices as not visited  
        visited = [False]*(n*m + 1) 
        queue = [] 
        queue.append(n*m) 
  
        # Mark the current node as visited and  
        # enqueue it  
        visited[n*m] = True
        while(queue): 
  
            # Dequeue a vertex from queue 
            s = queue.pop(0) 
  
            # Get all adjacent vertices of the  
            # dequeued vertex s. If a adjacent has  
            # not been visited, then mark it visited  
            # and enqueue it  
            for i in self.graph[s]: 
                  
                # If this adjacent node is the destination  
                # node, then return true  
  
                # Else, continue to do BFS  
                if visited[i] == False: 
                    queue.append(i) 
                    visited[i] = True
  
        for i in range(len(a)):
            if visited[a[i]]==False:
                return False
        return True
  
def isSafe(i, j, matrix): 
    if i >= 0 and i < len(matrix) and j >= 0 and j < len(matrix[0]) and matrix[i][j]!='#': 
        return True
    else: 
        return False
  
# Returns true if there is a path from a source (a  
# cell with value 1) to a destination (a cell with  
# value 2) 
def findPath(M): 
    #s, d = None, None # source and destination  
    N = len(M)
    m=len(M[0])
    g = Graph() 
  
    # create graph with n * n node  
    # each cell consider as node  
    k = 1
    a=[]# Number of current vertex 
    for i in range(N): 
        for j in range(m): 
            if (M[i][j] != '#'): 
  
                # connect all 4 adjacent cell to  
                # current cell  
                if (isSafe(i, j + 1, M)): 
                    g.addEdge(k, k + 1) 
                if (isSafe(i, j - 1, M)): 
                    g.addEdge(k, k - 1) 
                if (isSafe(i + 1, j, M)): 
                    g.addEdge(k, k + m) 
                if (isSafe(i - 1, j, M)): 
                    g.addEdge(k, k - m) 
                if (M[i][j]=='G'):
                    a.append(k)
            
            k += 1
    
    return g.BFS(a)
for i in range(int(input())):
 n,m=map(int,input().split())
 matrix=[[0 for i in range(m)]for j in range(n)]
 from collections import defaultdict    
 s=[]
 c=0
 f=0
 c1=0
 w=[]
 for j in range(n):
     s.append(list(input()))
     c+=s[-1].count('G')
 if c==0:
     print("Yes")
     continue
 for i in range(n):
     for j in range(m):
         if s[i][j]=='B':
             w.append((i,j))
 for y in w:
             i=y[0]
             j=y[1]
             if i>0:
                 if s[i-1][j]=='G':
                     f=1
                     break
                 s[i-1][j]='#'
             if j>0:
                 if s[i][j-1]=='G':
                     f=1
                     break
                 s[i][j-1]='#'
             if i<n-1:
                 if s[i+1][j]=='G':
                     f=1
                     break
                 s[i+1][j]='#'
             if j<m-1:
                 if s[i][j+1]=='G':
                     f=1
                     break
                 s[i][j+1]='#'
     
 e=[] 
 if f==1:
     print("No")
     continue
 else:
     if findPath(s)==True:
         print("Yes")
     else:
            print("No")
     
 