//---------- begin union_find ----------
pub struct DSU {
    p: Vec<i32>,
}
impl DSU {
    pub fn new(n: usize) -> DSU {
        assert!(n < std::i32::MAX as usize);
        DSU { p: vec![-1; n] }
    }
    pub fn init(&mut self) {
        self.p.iter_mut().for_each(|p| *p = -1);
    }
    pub fn root(&self, mut x: usize) -> usize {
        assert!(x < self.p.len());
        while self.p[x] >= 0 {
            x = self.p[x] as usize;
        }
        x
    }
    pub fn same(&self, x: usize, y: usize) -> bool {
        assert!(x < self.p.len() && y < self.p.len());
        self.root(x) == self.root(y)
    }
    pub fn unite(&mut self, x: usize, y: usize) -> Option<(usize, usize)> {
        assert!(x < self.p.len() && y < self.p.len());
        let mut x = self.root(x);
        let mut y = self.root(y);
        if x == y {
            return None;
        }
        if self.p[x] > self.p[y] {
            std::mem::swap(&mut x, &mut y);
        }
        self.p[x] += self.p[y];
        self.p[y] = x as i32;
        Some((x, y))
    }
    pub fn parent(&self, x: usize) -> Option<usize> {
        assert!(x < self.p.len());
        let p = self.p[x];
        if p >= 0 {
            Some(p as usize)
        } else {
            None
        }
    }
    pub fn sum<F>(&self, mut x: usize, mut f: F) -> usize
    where
        F: FnMut(usize),
    {
        while let Some(p) = self.parent(x) {
            f(x);
            x = p;
        }
        x
    }
    pub fn size(&self, x: usize) -> usize {
        assert!(x < self.p.len());
        let r = self.root(x);
        (-self.p[r]) as usize
    }
}
//---------- end union_find ----------
// ---------- begin scannner ----------
#[allow(dead_code)]
mod scanner {
    use std::str::FromStr;
    pub struct Scanner<'a> {
        it: std::str::SplitWhitespace<'a>,
    }
    impl<'a> Scanner<'a> {
        pub fn new(s: &'a String) -> Scanner<'a> {
            Scanner {
                it: s.split_whitespace(),
            }
        }
        pub fn next<T: FromStr>(&mut self) -> T {
            self.it.next().unwrap().parse::<T>().ok().unwrap()
        }
        pub fn next_bytes(&mut self) -> Vec<u8> {
            self.it.next().unwrap().bytes().collect()
        }
        pub fn next_chars(&mut self) -> Vec<char> {
            self.it.next().unwrap().chars().collect()
        }
        pub fn next_vec<T: FromStr>(&mut self, len: usize) -> Vec<T> {
            (0..len).map(|_| self.next()).collect()
        }
    }
}
// ---------- end scannner ----------

use std::collections::*;
use std::io::Write;

type Map<K, V> = BTreeMap<K, V>;
type Set<T> = BTreeSet<T>;
type Deque<T> = VecDeque<T>;

fn main() {
    use std::io::Read;
    let mut s = String::new();
    std::io::stdin().read_to_string(&mut s).unwrap();
    let mut sc = scanner::Scanner::new(&s);
    let out = std::io::stdout();
    let mut out = std::io::BufWriter::new(out.lock());
    run(&mut sc, &mut out);
}

fn run<W: Write>(sc: &mut scanner::Scanner, out: &mut std::io::BufWriter<W>) {
    let t: u32 = sc.next();
    for _ in 0..t {
        let h: usize = sc.next();
        let w: usize = sc.next();
        let s = (0..h).map(|_| sc.next_bytes()).collect::<Vec<_>>();
        let mut dsu = DSU::new(h * w);
        let mut v = (0..(h * w))
            .map(|k| vec![(k / w, k % w)])
            .collect::<Vec<_>>();
        let pos = |x, y| x * w + y;
        for (i, s) in s.windows(2).enumerate() {
            for (j, (a, b)) in s[0].iter().zip(s[1].iter()).enumerate() {
                if (*a, *b) == (b'.', b'.') {
                    if let Some((p, c)) = dsu.unite(pos(i, j), pos(i + 1, j)) {
                        let src = std::mem::take(&mut v[c]);
                        v[p].extend(&src);
                    }
                }
            }
        }
        for (i, s) in s.iter().enumerate() {
            for (j, s) in s.windows(2).enumerate() {
                let (a, b) = (s[0], s[1]);
                if (a, b) == (b'.', b'.') {
                    if let Some((p, c)) = dsu.unite(pos(i, j), pos(i, j + 1)) {
                        let src = std::mem::take(&mut v[c]);
                        v[p].extend(&src);
                    }
                }
            }
        }
        let mut ans = 0;
        let mut used = vec![false; h * w];
        for i in 0..h {
            for j in 0..w {
                if s[i][j] == b'O' || used[dsu.root(pos(i, j))] {
                    continue;
                }
                let r = dsu.root(pos(i, j));
                let mut v = std::mem::take(&mut v[r]);
                let x = v.iter().map(|p| p.0).min().unwrap();
                let y = v.iter().map(|p| p.1).min().unwrap();
                v.iter_mut().for_each(|v| *v = (v.0 - x, v.1 - y));
                used[r] = true;
                let ok = (|| {
                    for i in 0..h {
                        for j in 0..w {
                            if v.iter().all(|v| {
                                let x = i + v.0;
                                let y = j + v.1;
                                x < h && y < w && s[x][y] == b'.' && dsu.root(pos(x, y)) != r
                            }) {
                                return false;
                            }
                        }
                    }
                    true
                })();
                if ok {
                    ans += dsu.size(r);
                }
            }
        }
        writeln!(out, "{}", ans).ok();
    }
}