/*学习古代文章，诗词
逍遥游
北冥有鱼，其名为鲲。
鲲之大，不知其几千里也；化而为鸟，其名为鹏。
鹏之背，不知其几千里也；怒而飞，其翼若垂天之云。
是鸟也，海运则将徙于南冥。
南冥者，天池也。
《齐谐》者，志怪者也。
《谐》之言曰：“鹏之徙于南冥也，水击三千里，抟扶摇而上者九万里，去以六月息者也。”
野马也，尘埃也，生物之以息相吹也。
天之苍苍，其正色邪？其远而无所至极邪？其视下也，亦若是则已矣。
且夫水之积也不厚，则其负大舟也无力。
覆杯水于坳堂之上，则芥为之舟；置杯焉则胶，水浅而舟大也。
风之积也不厚，则其负大翼也无力。
故九万里，则风斯在下矣，而后乃今培风；背负青天，而莫之夭阏者，而后乃今将图南。
蜩与学鸠笑之曰：“我决起而飞，抢榆枋而止，时则不至，而控于地而已矣，奚以之九万里而南为？”
适莽苍者，三餐而反，腹犹果然；适百里者，宿舂粮；适千里者，三月聚粮。
之二虫又何知！小知不及大知，小年不及大年。
奚以知其然也？朝菌不知晦朔，蟪蛄不知春秋，此小年也。
楚之南有冥灵者，以五百岁为春，五百岁为秋；上古有大椿者，以八千岁为春，八千岁为秋。
此大年也。
而彭祖乃今以久特闻，众人匹之，不亦悲乎？
汤之问棘也是已：“穷发之北，有冥海者，天池也。
有鱼焉，其广数千里，未有知其修者，其名为鲲。
有鸟焉，其名为鹏，背若泰山，翼若垂天之云；抟扶摇羊角而上者九万里，绝云气，负青天，然后图南，且适南冥也。
斥鷃笑之曰：‘彼且奚适也？我腾跃而上，不过数仞而下，翱翔蓬蒿之间，此亦飞之至也。
而彼且奚适也？’”此小大之辩也。
故夫知效一官、行比一乡、德合一君、而征一国者，其自视也，亦若此矣。
而宋荣子犹然笑之。
且举世誉之而不加劝，举世非之而不加沮，定乎内外之分，辩乎荣辱之境，斯已矣。
彼其于世，未数数然也。
虽然，犹有未树也。
夫列子御风而行，泠然善也，旬有五日而后反。
彼于致福者，未数数然也。
此虽免乎行，犹有所待者也。
若夫乘天地之正，而御六气之辩，以游无穷者，彼且恶乎待哉？故曰：至人无己，神人无功，圣人无名。
尧让天下于许由，曰：“日月出矣，而爝火不息；其于光也，不亦难乎？
时雨降矣，而犹浸灌；其于泽也，不亦劳乎？
夫子立而天下治，而我犹尸之；吾自视缺然，请致天下。”
许由曰：“子治天下，天下既已治也；而我犹代子，吾将为名乎？名者，实之宾也；吾将为宾乎？
鹪鹩巢于深林，不过一枝；偃鼠饮河，不过满腹。
归休乎君，予无所用天下为！庖人虽不治庖，尸祝不越樽俎而代之矣！”
肩吾问于连叔曰：“吾闻言于接舆，大而无当，往而不反。
吾惊怖其言。
犹河汉而无极也；大有径庭，不近人情焉。”
连叔曰：“其言谓何哉？”
曰：“藐姑射之山，有神人居焉。
肌肤若冰雪，淖约若处子，不食五谷，吸风饮露，乘云气，御飞龙，而游乎四海之外；其神凝，使物不疵疠而年谷熟。
吾以是狂而不信也。”
连叔曰：“然。
瞽者无以与乎文章之观，聋者无以与乎钟鼓之声。
岂唯形骸有聋盲哉？夫知亦有之！是其言也犹时女也。
之人也，之德也，将旁礴万物以为一，世蕲乎乱，孰弊弊焉以天下为事！之人也，物莫之伤：大浸稽天而不溺，大旱金石流，土山焦而不热。
是其尘垢秕糠将犹陶铸尧舜者也，孰肯以物为事？”
宋人资章甫而适诸越，越人断发文身，无所用之。
尧治天下之民，平海内之政，往见四子藐姑射之山，汾水之阳，窅然丧其天下焉。
惠子谓庄子曰：“魏王贻我大瓠之种，我树之成，而实五石。
以盛水浆，其坚不能自举也。
剖之以为瓠，则瓠落无所容。
非不呺然大也，吾为其无用而掊之。”
庄子曰：“夫子固拙于用大矣。
宋人有善为不龟手之药者，世世以洴澼絖为事。
客闻之，请买其方百金。
聚族而谋曰：‘我世世为洴澼絖，不过数金，今一朝而鬻技百金，请与之。’
客得之，以说吴王。
越有难，吴王使之将，冬，与越人水战，大败越人。
裂地而封之。
能不龟手一也，或以封，或不免于洴澼絖，则所用之异也。
今子有五石之瓠，何不虑以为大樽，而浮于江湖，而忧其瓠落无所容？则夫子犹有蓬之心也夫！”
惠子谓庄子曰：“吾有大树，人谓之樗。
其大本拥肿而不中绳墨，其小枝卷曲而不中规矩，立之涂，匠人不顾。
今子之言大而无用，众所同去也。
”庄子曰：“子独不见狸狌乎？卑身而伏，以候敖者；东西跳梁，不辟高下；中于机辟，死于罔罟。
今夫斄牛，其大若垂天之云。
此能为大矣，而不能执鼠。
今子有大树，患其无用，何不树之于无何有之乡，广莫之野，彷徨乎无为其侧，逍遥乎寝卧其下。
不夭斤斧，物无害者，无所可用，安所困苦哉！”
*/
//Generated at 2024-06-12 23:09:42 UTC+8
//Created by Alphagocc
#ifndef TYPE_HPP
#define TYPE_HPP
#include <type_traits>
#ifndef __cpp_lib_void_t
namespace std
{
template <typename...> using void_t = void;
}
#endif
template <typename T, typename _ = void> struct is_container : std::false_type
{};
template <typename... Ts> struct is_container_helper
{};
template <typename T>
struct is_container<T,
    typename std::conditional<false,
        is_container_helper<decltype(std::declval<T>().size()),
            decltype(std::declval<T>().begin()),
            decltype(std::declval<T>().end())>,
        void>::type> : public std::true_type
{};
#endif
#include <cstdio>
#include <string>
#include <utility>
#include <vector>
#define FI __inline__ __attribute__((always_inline))
class IO
{
    static const int bufSize = 1 << 20;

    char inBuf[bufSize], outBuf[bufSize];
    char *ip1 = inBuf, *ip2 = inBuf;
    int goodReadBit = 1, op1 = -1, op2 = bufSize - 1;
    template <typename T> FI void __RI(T &x)
    {
        int ch = gc(), neg = 1;
        x = 0;
        for (; !(isdigit(ch) || ch == '-' || ch == EOF); ch = gc()) {}
        if (ch == EOF) [[unlikely]]
            return;
        if (ch == '-') neg = -1, ch = gc();
        for (; isdigit(ch); ch = gc()) x = x * 10 + (ch - 48) * neg;
    }
    template <typename T> FI void __RC(T &x)
    {
        int ch;
        while (isspace(ch = gc())) {}
        if (ch == EOF) return;
        x = ch;
    }
    FI void __RS(std::string &x)
    {
        int ch;
        x.clear();
        for (ch = gc(); isspace(ch); ch = gc()) {}
        if (ch == EOF) return;
        for (; !isspace(ch) && ch != EOF; ch = gc()) x.push_back(ch);
    }

public:
    FI int gc()
    {
        return ip1 == ip2 && (ip2 = (ip1 = inBuf) + fread(inBuf, 1, bufSize, stdin), ip1 == ip2)
            ? (goodReadBit = 0, EOF)
            : *ip1++;
    }
    FI IO &R(char &x) { return __RC(x), (*this); }
    FI IO &R(unsigned char &x) { return __RC(x), (*this); }
    FI IO &R(std::string &x) { return __RS(x), (*this); }
    template <typename T1, typename T2> FI IO &R(std::pair<T1, T2> &x)
    {
        return R(x.first, x.second), (*this);
    }
    template <typename T, typename... Args> FI IO &RA(T *a, int n)
    {
        for (int i = 0; i < n; ++i) R(a[i]);
        return (*this);
    }
    template <typename T, typename... Args> FI IO &R(T &x, Args &...args)
    {
        return R(x), R(args...), (*this);
    }
    template <typename T, typename... Args> FI IO &RA(T *a, int n, Args... args)
    {
        for (int i = 0; i < n; ++i) RA(a[i], args...);
        return (*this);
    }
    template <typename T> FI typename std::enable_if<std::is_integral<T>::value, IO>::type &R(T &x)
    {
        return __RI(x), (*this);
    }
    template <typename T> FI typename std::enable_if<is_container<T>::value, IO>::type &R(T &x)
    {
        for (auto &i : x) R(i);
        return (*this);
    }
    template <typename T>
    FI typename std::enable_if<std::is_void<std::void_t<decltype(std::declval<T>().read())>>::value,
        IO>::type &
        R(T &x)
    {
        return x.read(), (*this);
    }

private:
    const char space = ' ';
    template <typename T> FI void __WI(T _x)
    {
        typename std::make_unsigned<T>::type x = _x;
        if (_x < 0) pc('-'), x = ~x + 1;
        static char buf[sizeof(T) * 16 / 5];
        static int len = -1;
        static constexpr char digits[201] = "0001020304050607080910111213141516171819"
                                            "2021222324252627282930313233343536373839"
                                            "4041424344454647484950515253545556575859"
                                            "6061626364656667686970717273747576777879"
                                            "8081828384858687888990919293949596979899";
        while (x >= 100) {
            auto num = (x % 100) * 2;
            x /= 100;
            buf[++len] = digits[num + 1];
            buf[++len] = digits[num];
        }
        if (x >= 10) {
            auto num = (x % 100) * 2;
            buf[++len] = digits[num + 1];
            buf[++len] = digits[num];
        } else {
            buf[++len] = '0' + x;
        }
        while (len >= 0) { pc(buf[len]), --len; }
    }

public:
    FI void pc(const char &x)
    {
        if (op1 == op2) flush();
        outBuf[++op1] = x;
    }
    FI void flush() { fwrite(outBuf, 1, op1 + 1, stdout), op1 = -1; }
    FI IO &W() { return (*this); }
    FI IO &W(const char &x) { return pc(x), (*this); }
    FI IO &W(const char *x)
    {
        while (*x != '\0') pc(*(x++));
        return (*this);
    }
    FI IO &W(const std::string &x) { return W(x.c_str()), (*this); }
    template <typename T1, typename T2> FI IO &W(const std::pair<T1, T2> &x)
    {
        W(x.first, x.second);
        return (*this);
    }
    FI IO &WL() { return W('\n'), (*this); }
    FI IO &WS() { return W(space), (*this); }
    template <typename T> FI IO &WA(T *a, int n)
    {
        for (int i = 0; i < n; i++) WS(a[i]);
        WL();
        return (*this);
    }
    template <typename T, typename... Args> FI IO &W(const T &x, const Args &...args)
    {
        W(x), W(space), W(args...);
        return (*this);
    }
    template <typename... Args> FI IO &WS(const Args &...args)
    {
        return W(args...), W(space), (*this);
    }
    template <typename... Args> FI IO &WL(const Args &...args)
    {
        return W(args...), W('\n'), (*this);
    }
    template <typename T, typename... Args> FI IO &WA(T *a, int n, Args... args)
    {
        for (int i = 0; i < n; i++) WA(a[i], args...);
        return (*this);
    }
    template <typename T>
    FI typename std::enable_if<std::is_integral<T>::value, IO>::type &W(const T &x)
    {
        return __WI(x), (*this);
    }
    template <typename T>
    FI typename std::enable_if<is_container<T>::value, IO>::type &W(const T &x)
    {
        for (auto &i : x) { is_container<decltype(i)>::value ? W(i) : WS(i); }
        WL();
        return (*this);
    }
    template <typename T>
    FI typename std::enable_if<
        std::is_void<std::void_t<decltype(std::declval<T>().write())>>::value, IO>::type &
        W(const T &x)
    {
        return x.write(), (*this);
    }
    template <typename T> FI IO &operator>>(T &x)
    {
        R(x);
        return (*this);
    }
    template <typename T> FI IO &operator<<(const T &x)
    {
        W(x);
        return (*this);
    }
    int good() { return goodReadBit; }
    IO() {}
    ~IO() { flush(); }
} io;
#undef FI

#ifndef UTIL_HPP
#define UTIL_HPP
#include <bits/stdc++.h>
#include <cstdint>
#define var auto
#define ALL(x) x.begin(), x.end()
#define If(x, y, z) ((x) ? (y) : (z))
using i128 = __int128_t;
using i64 = int64_t;
using i32 = int32_t;
using i16 = int16_t;
using u128 = __uint128_t;
using u64 = uint64_t;
using u32 = uint32_t;
using u16 = uint16_t;
constexpr i32 INF = 0x3f3f3f3f;
constexpr i64 INFL = 0x3f3f3f3f3f3f3f3f;
#define FILEIO(x)                                                                                  \
    do {                                                                                           \
        freopen(#x ".in", "r", stdin);                                                             \
        freopen(#x ".out", "w", stdout);                                                           \
    } while (0)
#endif

#ifndef MULTIVECTOR_HPP
#define MULTIVECTOR_HPP
#include <vector>
template <typename T, int Dimension>
struct MultiVector : public std::vector<MultiVector<T, Dimension - 1>>
{
    MultiVector(std::size_t n = 0)
        : std::vector<MultiVector<T, Dimension - 1>>(
            n, MultiVector<T, Dimension - 1>())
    {}
    template <typename... Args>
    MultiVector(std::size_t n, const Args &...args)
        : std::vector<MultiVector<T, Dimension - 1>>(
            n, MultiVector<T, Dimension - 1>(args...))
    {}
    template <typename... Args> void resize(std::size_t n, const Args &...args)
    {
        std::vector<MultiVector<T, Dimension - 1>>::resize(n);
        for (auto &i : (*this)) i.resize(args...);
    }
    void resize() {}
    template <typename... Args> void assign(std::size_t n, const Args &...args)
    {
        std::vector<MultiVector<T, Dimension - 1>>::resize(n);
        for (auto &i : (*this)) i.assign(args...);
    }
};
template <typename T> struct MultiVector<T, 1> : public std::vector<T>
{
    MultiVector(std::size_t n = 0)
        : std::vector<T>(n)
    {}
    MultiVector(std::size_t n, const T &x)
        : std::vector<T>(n, x)
    {}
    void resize(std::size_t n = 0) { std::vector<T>::resize(n); }
    void resize(std::size_t n, const T &x) { std::vector<T>::resize(n, x); }
};
#endif
using namespace std;
const int dir[4][2] = { { 0, 1 }, { -1, 0 }, { 0, -1 }, { 1, 0 } };
void solve()
{
    int n, m;
    io >> n >> m;
    MultiVector<char, 2> a(n, m);
    io >> a;
    vector<bitset<1234>> b;
    auto dfs = [&](auto &dfs, int x, int y, int tx, int ty) {
        if (x >= n || y >= m || x < 0 || y < 0) return;
        if (a[x][y] == 'O') return;
        b.back()[tx * m + ty] = 1;
        a[x][y] = 'O';
        for (const auto &[dx, dy] : dir) { dfs(dfs, x + dx, y + dy, tx + dx, ty + dy); }
    };
    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++) {
            if (a[i][j] == '.') {
                b.push_back({});
                dfs(dfs, i, j, 0, 0);
            }
        }
    auto in = [](auto i, auto j) { return ((i | j) == j); };
    int ans = 0;
    for (int i = 0; i < b.size(); i++) {
        bool ok = 1;
        for (int j = 0; j < b.size(); j++) {
            if (i == j) continue;
            if (in(b[i], b[j])) {
                ok = 0;
                break;
            }
        }
        if (ok) ans += b[i].count();
    }
    io.WL(ans);
}
int main()
{
    int T;
    io >> T;
    while (T--) { solve(); }
    return 0;
}