#if __INCLUDE_LEVEL__ == 0

#include __BASE_FILE__

namespace {

using B = bitset<4096>;

void solve() {
  int h, w;
  scan(h, w);
  vector<string> s(h);
  scan(s);
  vector<B> f(h * w);
  for (int si : rep(h)) {
    for (int sj : rep(w)) {
      auto id = [&](int i, int j) { return (i + (h - si - 1)) * (w * 2 - 1) + (j + (w - sj - 1)); };
      if (s[si][sj] == '.') {
        f[si * w + sj][id(si, sj)] = 1;
        vector q{pair{si, sj}};
        for (int qi = 0; qi < len(q); ++qi) {
          auto [i, j] = q[qi];
          for (auto [di, dj] : {pair{0, 1}, {0, -1}, {1, 0}, {-1, 0}}) {
            int ni = i + di, nj = j + dj;
            if (ni < 0 || ni >= h || nj < 0 || nj >= w) continue;
            if (s[ni][nj] != '.') continue;
            if (f[si * w + sj][id(ni, nj)]) continue;
            f[si * w + sj][id(ni, nj)] = 1;
            q.emplace_back(ni, nj);
          }
        }
      }
    }
  }
  int ans = 0;
  for (int i : rep(h * w)) {
    bool ok = s[i / w][i % w] == '.';
    for (int j : rep(h * w)) {
      if (i != j) {
        if ((f[i] & ~f[j]).none()) {
          ok = false;
          break;
        }
      }
    }
    ans += ok;
  }
  print(ans);
}

}  // namespace

int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);

  int t;
  scan(t);
  while (t--) {
    solve();
  }
}

#else  // __INCLUDE_LEVEL__

#include <bits/stdc++.h>

using namespace std;

template <class T>
concept tuple_like = __is_tuple_like<T>::value && !ranges::range<T>;

template <class R>
concept nstr_range = ranges::range<R> && !convertible_to<R, string_view>;

namespace std {

istream& operator>>(istream& is, tuple_like auto&& t) {
  return apply([&is](auto&... xs) -> istream& { return (is >> ... >> xs); }, t);
}

istream& operator>>(istream& is, nstr_range auto&& r) {
  for (auto&& e : r) {
    is >> e;
  }
  return is;
}

ostream& operator<<(ostream& os, tuple_like auto&& t) {
  auto f = [&os](auto&... xs) -> ostream& {
    [[maybe_unused]] auto sep = "";
    ((os << exchange(sep, " ") << xs), ...);
    return os;
  };
  return apply(f, t);
}

ostream& operator<<(ostream& os, nstr_range auto&& r) {
  auto sep = "";
  for (auto&& e : r) {
    os << exchange(sep, " ") << e;
  }
  return os;
}

#define DEF_INC_OR_DEC(op) \
  auto& operator op(tuple_like auto&& t) { \
    apply([](auto&... xs) { (op xs, ...); }, t); \
    return t; \
  } \
  auto& operator op(nstr_range auto&& r) { \
    for (auto&& e : r) { \
      op e; \
    } \
    return r; \
  }

DEF_INC_OR_DEC(++)
DEF_INC_OR_DEC(--)

#undef DEF_INC_OR_DEC

}  // namespace std

void scan(auto&&... xs) { cin >> tie(xs...); }
void print(auto&&... xs) { cout << tie(xs...) << '\n'; }

using views::drop;
using views::take;
inline constexpr auto rev = views::reverse;
inline constexpr auto len = ranges::ssize;
inline auto rep(int l, int r) { return views::iota(min(l, r), r); }
inline auto rep(int n) { return rep(0, n); }
inline auto rep1(int l, int r) { return rep(l, r + 1); }
inline auto rep1(int n) { return rep(1, n + 1); }

#endif  // __INCLUDE_LEVEL__