#include <bits/stdc++.h>
using namespace std;
using namespace chrono;

using ll = long long;
using ull = unsigned long long;

string to_string(const string &s) { return '"' + s + '"'; }

string to_string(bool b) { return b ? "true" : "false"; }

template <typename A, typename B> string to_string(const pair<A, B> &p) {
  return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}

template <typename T> string to_string(const T &v) {
  string s = "{";
  bool first = true;
  for (const auto &it : v) {
    if (!first)
      s += ", ";
    else
      first = false;
    s += to_string(it);
  }
  return s += "}";
}

void debug_out() { cerr << endl; }

template <typename T, typename... Args>
void debug_out(const T &first, const Args &...rest) {
  cerr << to_string(first) << " ";
  debug_out(rest...);
}

#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

auto startTime = high_resolution_clock::now();
int get_time() {
  auto stopTime = chrono::high_resolution_clock::now();
  auto duration = duration_cast<milliseconds>(stopTime - startTime);
  return duration.count(); // in ms
}

const int dx[] = {-1, 1, 0, 0};
const int dy[] = {0, 0, -1, 1};

struct line {
  int x, y;
};

struct zone {
  int id, x, y, nr, dom;
  vector<line> l;
};

int n, m;
vector<string> a;
vector<vector<int>> viz;

void fill(int x, int y, zone &z) {
  z.l.push_back({x, y});

  viz[x][y] = z.id;
  ++z.nr;

  for (int k = 0; k < 4; ++k) {
    int x2 = dx[k] + x;
    int y2 = dy[k] + y;

    if (x2 >= 0 && y2 >= 0 && x2 < n && y2 < m && a[x2][y2] == '.' &&
        !viz[x2][y2]) {
      fill(x2, y2, z);
    }
  }
}

bool check_equal(zone &z, int x, int y) {
  int i = z.x;
  for (auto it : z.l) {
    int nx = x + (it.x - z.x);
    int ny = y + (it.y - z.y);

    if (nx < 0 || ny < 0 || nx >= n || ny >= m || a[it.x][it.y] != a[nx][ny])
      return false;
  }
  return true;
}

bool check(zone &z, zone &z2) {
  for (auto it : z2.l) {
    if (check_equal(z, it.x, it.y)) {
      return true;
    }
  }

  return false;
}

void solve() {
  cin >> n >> m;
  a.clear();
  for (int i = 0; i < n; ++i) {
    string s;
    cin >> s;
    a.push_back(s);
  }

  viz.resize(n);
  for (int i = 0; i < n; ++i) {
    viz[i].resize(m);
    for (int j = 0; j < m; ++j) {
      viz[i][j] = 0;
    }
  }

  vector<zone> z;
  int cnt_z = 0;
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < m; ++j) {
      if (viz[i][j] || a[i][j] != '.')
        continue;

      ++cnt_z;
      viz[i][j] = 1;
      z.push_back({cnt_z, i, j, 0, 0});
      z.back().l.clear();
      fill(i, j, z.back());
    }
  }

  for (auto &it : z) {
    for (auto it2 : z) {
      if (it.id == it2.id)
        continue;

      if (it2.nr < it.nr)
        continue;

      if (check(it, it2)) {
        it.dom = 1;
        break;
      }
    }
  }

  int sol = 0;
  for (auto it : z) {
    if (it.dom == 0)
      sol += it.nr;
  }

  cout << sol << '\n';
}

int main() {
  cin.tie(NULL);
  ios_base::sync_with_stdio(false);

  int t = 1;
  cin >> t;
  while (t--) {
    solve();
  }

  return 0;
}