# ------------------- fast io --------------------
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")


# ------------------- fast io --------------------

def bfs(graph, start=0):
    used = [False] * len(graph)
    used[start] = True
    q = [start]
    for v in q:
        for w in graph[v]:
            if not used[w]:
                used[w] = True
                q.append(w)


def layers(graph, start=0):
    used = [False] * len(graph)
    used[start] = True
    q, ret = [start], []
    while q:
        nq = []
        ret.append(q)
        for v in q:
            for w in graph[v]:
                if not used[w]:
                    used[w] = True
                    nq.append(w)
        q = nq
    return ret


def dfs(graph, start=0):
    n = len(graph)

    dp = [0] * n
    visited, finished = [False] * n, [False] * n

    stack = [start]
    while stack:
        start = stack[-1]

        # push unvisited children into stack
        if not visited[start]:
            visited[start] = True
            for child in graph[start]:
                if not visited[child]:
                    stack.append(child)

        else:
            stack.pop()

            # base case
            dp[start] += 1

            # update with finished children
            for child in graph[start]:
                if finished[child]:
                    dp[start] += dp[child]

            finished[start] = True

    return visited


for _ in range(int(input())):
    n, m = map(int, input().split())
    grid = []
    for __ in range(n):
        s = [k for k in input()]
        grid += [s]

    check = []
    for i in range(n):
        for j in range(m):
            if grid[i][j] == 'G':
                check += [i*m + j + 1]
            if grid[i][j] == 'B':
                if i != n-1:
                    if grid[i+1][j] == '.':
                        grid[i+1][j] = '#'
                if i != 0:
                    if grid[i-1][j] == '.':
                        grid[i-1][j] = '#'
                if j != 0:
                    if grid[i][j-1] == '.':
                        grid[i][j-1] = '#'
                if j != m - 1:
                    if grid[i][j+1] == '.':
                        grid[i][j+1] = '#'

    graph = [[] for ___ in range(n*m + 1)]

    for i in range(n):
        for j in range(m):
            if grid[i][j] == '#':continue
            current = i * m + j + 1
            if i != 0:
                next_cell = grid[i-1][j]
                if next_cell != '#':
                    graph[current] += [(i-1)*m + (j) + 1]
                    graph[(i-1)*m + (j) + 1] += [current]
            if i != n-1:
                next_cell = grid[i+1][j]
                if next_cell != '#':
                    graph[current] += [(i+1)*m + (j) + 1]
                    graph[(i+1)*m + (j) + 1] += [current]
            if j != 0:
                next_cell = grid[i][j-1]
                if next_cell != '#':
                    graph[current] += [(i)*m + (j-1) + 1]
                    graph[(i)*m + (j-1) + 1] += [current]
            if j != m - 1:
                next_cell = grid[i][j+1]
                if next_cell != '#':
                    graph[current] += [(i)*m + (j+1) + 1]
                    graph[(i)*m + (j+1) + 1] += [current]

    vis = dfs(graph, n*m)
    #print(graph)
    pos = True
    for i in check:
        if not vis[i]:
            pos = False
            break
    print("Yes" if pos else "No")