/**
 * @author vivek
 * programming is thinking, not typing
 */

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Main {
    static HashMap<Pair, Boolean> maap;

    private static void solveTC(int __) {

        /* For Google */
//		ans.append("Case #").append(__).append(": ");

        //code start

        maap = new HashMap<>();

        int n = scn.nextInt();
        int m = scn.nextInt();

        char[][] array = new char[n][];

        HashSet<Pair> god = new HashSet<>();
        HashSet<Pair> bad = new HashSet<>();
        HashSet<Pair> wall = new HashSet<>();

        for (int i = 0; i < n; i++) {
            array[i] = scn.next().toCharArray();
            for (int j = 0; j < m; j++) {
                if (array[i][j] == 'B') {
                    bad.add(new Pair(i, j));
                } else if (array[i][j] == 'G') {
                    god.add(new Pair(i, j));
                } else if (array[i][j] == '#') {
                    wall.add(new Pair(i, j));
                }
            }
        }

        for (Pair p : bad) {
            int a = p.a;
            int b = p.b;
            int x = a - 1, y = b;
            if (x >= 0) {
                if (array[x][y] == 'G') {
                    print("No\n");
                    return;
                }
                array[x][y] = '#';
            }
            x = a + 1;
            if (x < n) {
                if (array[x][y] == 'G') {
                    print("No\n");
                    return;
                }
                array[x][y] = '#';
            }
            x = a;
            y = b - 1;
            if (y >= 0) {
                if (array[x][y] == 'G') {
                    print("No\n");
                    return;
                }
                array[x][y] = '#';
            }
            y = b + 1;
            if (y < m) {
                if (array[x][y] == 'G') {
                    print("No\n");
                    return;
                }
                array[x][y] = '#';
            }
        }

        for (Pair p : god) {
            if (!isPath(p.a, p.b, array)) {
                print("No\n");
                return;
            }
        }

        print("Yes");

        //code end

        print("\n");
    }

    private static boolean isPath(int a, int b, char[][] array) {
        if (a == array.length - 1 && b == array[a].length - 1) {
            return true;
        }
        HashSet<Pair> set = new HashSet<>();
        set.add(new Pair(a, b));
        return isPath(a + 1, b, array, set) ||
                isPath(a - 1, b, array, set) ||
                isPath(a, b + 1, array, set) ||
                isPath(a, b - 1, array, set);
    }

    private static boolean isPath(int a, int b, char[][] array, HashSet<Pair> visited) {
        Pair paa = new Pair(a, b);
        if (maap.containsKey(paa)) {
            if (maap.get(paa))
                return true;
        }
        if (a < 0 || b < 0) {
            return false;
        }
        if (a == array.length - 1 && b == array[a].length - 1) {
            return array[a][b] == '.' || array[a][b] == 'G';
        }
        if (a >= array.length || b >= array[a].length) {
            return false;
        }
        if (array[a][b] != '.' && array[a][b] != 'G') {
            return false;
        }
        Pair p = new Pair(a, b);
        if (visited.contains(p)) {
            return false;
        } else {
            visited.add(p);
        }

        maap.put(paa, isPath(a - 1, b, array, visited) ||
                isPath(a + 1, b, array, visited) ||
                isPath(a, b - 1, array, visited) ||
                isPath(a, b + 1, array, visited));
        return maap.get(paa);

    }

    static class Pair {
        int a, b;

        public Pair(int a, int b) {
            this.a = a;
            this.b = b;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Pair pair = (Pair) o;
            return a == pair.a &&
                    b == pair.b;
        }

        @Override
        public int hashCode() {
            return Objects.hash(a, b);
        }
    }

    public static void main(String[] args) {

//        int limit=               ;
//        sieve(limit);

        scn = new Scanner();
        ans = new StringBuilder();
        int t = scn.nextInt();
//        int t = 1;
        for (int i = 1; i <= t; i++) {
            solveTC(i);
        }
        System.out.print(ans);
    }
    //Stuff for prime start
    /**
     * List containing prime numbers <br>
     * <b>i<sup>th</sup></b> position contains <b>i<sup>th</sup></b> prime number <br>
     * 0th index is <b>null</b>
     */
    private static ArrayList<Integer> listOfPrimes;

    /**
     * query <b>i<sup>th</sup></b> element to get if its prime of not
     */
    private static boolean[] isPrime;

    /**
     * Performs Sieve of Erathosnesis and initialise isPrime array and listOfPrimes list
     *
     * @param limit the number till which sieve is to be performed
     */
    private static void sieve(int limit) {
        listOfPrimes = new ArrayList<>();
        listOfPrimes.add(null);
        boolean[] array = new boolean[limit + 1];

        Arrays.fill(array, true);
        array[0] = false;
        array[1] = false;

        for (int i = 2; i <= limit; i++) {
            if (array[i]) {
                for (int j = i * i; j <= limit; j += i) {
                    array[j] = false;
                }
            }
        }
        isPrime = array;
        for (int i = 0; i <= limit; i++) {
            if (array[i]) {
                listOfPrimes.add(i);
            }
        }
    }
    //stuff for prime end

    /**
     * Calculates the Least Common Multiple of two numbers
     *
     * @param a First number
     * @param b Second Number
     * @return Least Common Multiple of <b>a</b> and <b>b</b>
     */
    private static long lcm(long a, long b) {
        return a * b / gcd(a, b);
    }

    /**
     * Calculates the Greatest Common Divisor of two numbers
     *
     * @param a First number
     * @param b Second Number
     * @return Greatest Common Divisor of <b>a</b> and <b>b</b>
     */
    private static long gcd(long a, long b) {
        return (b == 0) ? a : gcd(b, a % b);
    }

    static void print(Object obj) {
        ans.append(obj.toString());
    }


    static Scanner scn;
    static StringBuilder ans;

    //Fast Scanner
    static class Scanner {
        BufferedReader br;
        StringTokenizer st;

        public Scanner() {
            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;
        }

        int[] nextIntArray(int n) {
            int[] array = new int[n];
            for (int i = 0; i < n; i++) {
                array[i] = nextInt();
            }
            return array;
        }

        Integer[] nextIntegerArray(int n) {
            Integer[] array = new Integer[n];
            for (int i = 0; i < n; i++) {
                array[i] = nextInt();
            }
            return array;
        }

        long[] nextLongArray(int n) {
            long[] array = new long[n];
            for (int i = 0; i < n; i++) {
                array[i] = nextLong();
            }
            return array;
        }

        String[] nextStringArray() {
            return nextLine().split(" ");
        }

        String[] nextStringArray(int n) {
            String[] array = new String[n];
            for (int i = 0; i < n; i++) {
                array[i] = next();
            }
            return array;
        }
    }
}