import sys, math
input = sys.stdin.readline

def getInts():
    return [int(s) for s in input().split()]

def getInt():
    return int(input())

def getStrs():
    return [s for s in input().split()]

def getStr():
    return input().strip()

def listStr():
    return list(input().strip())

import collections as col
import math

"""

BB#...GG
###.GG..
...####.
...#BB#.

first thing to note: if any B and G are adjacent, it's impossible
if any G is already unable to reach the end, it's also impossible
if any G has only paths on which there are Bs already, or Bs adjacent, it's impossible
the simple thing to do is to put a minimum-sized fence around all Bs, and then DFS from the end-point to see if:
1) we reach all Gs
2) we don't reach any Bs


"""
from types import GeneratorType

def solve(T0,_):
    def bootstrap(f, stack=[]):
        def wrappedfunc(*args, **kwargs):
            if stack:
                return f(*args, **kwargs)
            else:
                to = f(*args, **kwargs)
                while True:
                    if type(to) is GeneratorType:
                        stack.append(to)
                        to = next(to)
                    else:
                        stack.pop()
                        if not stack:
                            break
                        to = stack[-1].send(to)
                return to
        return wrappedfunc
    @bootstrap
    def dfs(graph,visited,node):
        if node not in visited:
            visited.add(node)
            #print(visited)
        #else:
            #print(node)
        for neighbour in graph[node]:
            if neighbour not in visited:
                yield dfs(graph,visited,neighbour)
        yield visited
                
    N, M = getInts()
    grid = []
    graph = col.defaultdict(set)
    G_count = 0
    global flag
    if flag:
        print(N,M)
    for n in range(N):
        grid.append(listStr())
        if flag and n > 25:
            print(*grid[n],sep='')
        G_count += grid[n].count('G')
    if G_count == 0:
        return "Yes"
    for n in range(N):
        for m in range(M):
            flag1 = (n > 0 and grid[n-1][m] == 'B')
            flag2 = (n < N-1 and grid[n+1][m] == 'B')
            flag3 = (m > 0 and grid[n][m-1] == 'B')
            flag4 = (m < M-1 and grid[n][m-1] == 'B')
            if flag1 or flag2 or flag3 or flag4:
                if grid[n][m] == 'G':
                    return "No"
                if n == N-1 and m == M-1:
                    return "No"
                if grid[n][m] == 'B':
                    continue
                assert(grid[n][m] in ('.','#'))
                grid[n][m] = '#'
    for n in range(N):
        for m in range(M):
            if n > 0 and grid[n-1][m] != '#':
                graph[(n,m)].add((n-1,m))
            if n < N-1 and grid[n+1][m] != '#':
                graph[(n,m)].add((n+1,m))    
            if m > 0 and grid[n][m-1] != '#':
                graph[(n,m)].add((n,m-1))
            if m < M-1 and grid[n][m+1] != '#':
                graph[(n,m)].add((n,m+1))
    visited = dfs(graph,set(),(N-1,M-1))
    G_count2 = 0
    for n, m in visited:
        if grid[n][m] == 'B':
            return "No"
        if grid[n][m] == 'G':
            G_count2 += 1
    if T0 == 100 and _ == 1 and N == 20 and M == 34:
        flag = True
    return "Yes" if G_count2 == G_count else "No"

global flag
flag = False
T0 = getInt()

for _ in range(T0):
    print(solve(T0,_))
    


