/// Till I Collapse
#pragma GCC optimize("O3")
#pragma GCC optimize ("unroll-loops")
#pragma GCC target("avx,avx2,fma")

#include "bits/stdc++.h"

#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp> // Including tree_order_statistics_node_update

using namespace std;
using namespace __gnu_pbds;

#define pb push_back
#define F first
#define S second
#define f(i, a, b)  for(int i = a; i < b; i++)
#define all(a)  a.begin(),a.end()
#define rall(a) a.rbegin(),a.rend()
#define sz(x) (int)(x).size()
#define mp(x, y) make_pair(x,y)
#define popCnt(x) (__builtin_popcountll(x))
//#define int ll

using ll = long long;
using ii = pair<int, int>;
using ull = unsigned long long;

const int N = (1 << 20) + 5, LG = 19, MOD = 1e9 + 7, MOD2 = 1e9 + 7;
const long double PI = acos(-1);
const long double EPS = 1e-7;
mt19937_64 mrand(chrono::steady_clock::now().time_since_epoch().count());
const int dx[] = {-1, 1, -1, 1};
const int dy[] = {1, -1, -1, 1};
using ld = long double;
int n, m;
multiset<int> r, c;

struct DSU {
    vector<int> p, sz;

    DSU() {}

    DSU(int n) {
        f(i, 0, n + 1)p.push_back(i), sz.push_back(1);
    }

    int get(int i) { return i == p[i] ? i : p[i] = get(p[i]); }

    bool same(int i, int j) { return get(i) == get(j); }

    int getSize(int i) { return sz[get(i)]; }

    bool mrg(int u, int v) {
        if (!same(u, v)) {
            u = get(u);
            v = get(v);
//            if (sz[u] > sz[v])
//                swap(u, v);
            p[u] = v;
            sz[v] += sz[u];
            return true;
        }
        return false;
    }
};

void doWork() {
    r.clear();
    c.clear();
    cin >> n >> m;
    vector<DSU> rDSU(n + 1, DSU(m));
    vector<DSU> cDSU(m + 1, DSU(n));
    auto grid = vector<vector<char>>(n + 1, vector<char>(m + 1));
    f(i, 1, n + 1) rDSU[i] = DSU(m);
    f(i, 1, m + 1) cDSU[i] = DSU(n);
    f(i, 1, n + 1)f(j, 1, m + 1) {
            cin >> grid[i][j];
            if (grid[i][j] == '.') {
                if (grid[i][j - 1] == '.') {
                    rDSU[i].mrg(j, j - 1);
                }
                if (grid[i - 1][j] == '.') {
                    cDSU[j].mrg(i, i - 1);
                }
            }
        }
    f(i, 1, n + 1)f(j, 1, m + 1)if (grid[i][j] == '.') {
                if (rDSU[i].get(j) == j) {
                    r.insert(rDSU[i].getSize(j));
                }
                if (cDSU[j].get(i) == i) {
                    c.insert(cDSU[j].getSize(i));
                }
            }
    int ans = 0;
    r.insert(0);
    r.insert(0);
    c.insert(0);
    c.insert(0);
    ans = max(ans, *(--r.end()) + *(-- --r.end()));
    ans = max(ans, *(--c.end()) + *(-- --c.end()));
    f(i, 1, n + 1)f(j, 1, m + 1) if (grid[i][j] == '.' && rDSU[i].get(j) == j) {
                for (int k = j; k <= m && grid[i][k] == '.'; k++) {
                    int val1 = i - cDSU[k].get(i);
                    int val2 = cDSU[k].getSize(i) - val1 - 1;
                    c.erase(c.find(cDSU[k].getSize(i)));
                    c.insert(val1);
                    c.insert(val2);
                }
                ans = max(ans, rDSU[i].getSize(j) + *(--c.end()));
                for (int k = j; k <= m && grid[i][k] == '.'; k++) {
                    int val1 = i - cDSU[k].get(i);
                    int val2 = cDSU[k].getSize(i) - val1 - 1;
                    c.insert(cDSU[k].getSize(i));
                    c.erase(c.find(val1));
                    c.erase(c.find(val2));
                }
            }
    f(i, 1, n + 1)f(j, 1, m + 1) if (grid[i][j] == '.' && cDSU[j].get(i) == i) {
                for (int k = i; k <= n && grid[k][j] == '.'; k++) {
                    int val1 = j - rDSU[k].get(j);
                    int val2 = rDSU[k].getSize(j) - val1 - 1;
                    r.erase(r.find(rDSU[k].getSize(j)));
                    r.insert(val1);
                    r.insert(val2);
                }
                ans = max(ans, cDSU[j].getSize(i) + *(--r.end()));
                for (int k = i; k <= n && grid[k][j] == '.'; k++) {
                    int val1 = j - rDSU[k].get(j);
                    int val2 = rDSU[k].getSize(j) - val1 - 1;
                    r.insert(rDSU[k].getSize(j));
                    r.erase(r.find(val1));
                    r.erase(r.find(val2));
                }
            }
    cout << ans << '\n';
}


int32_t main() {
#ifdef ONLINE_JUDGE
    ios_base::sync_with_stdio(0);
    cin.tie(0);
#endif // ONLINE_JUDGE
    int t = 1;
    cin >> t;
    while (t--) {
        doWork();
    }
    return 0;
}