#include <iostream>
#include <set>
#include <list>
#include <memory.h>
#include <stdio.h>
#include <algorithm>

using namespace std;

class Dish;
class Cell;

class Dish {
private:
    list<Cell*> cells;

public:
    void insertCell(Cell*);
    int processResult();

};

class Cell {
private:
   set<Cell*> neighbors;

public:

    void destroy();
    void noticeDeath(Cell*);
    void connectWithNeighbor(Cell*);
    int getNCnt();
};

void Cell::destroy() {
    for (set<Cell*>::iterator itr = neighbors.begin(); itr != neighbors.end(); itr++) {
        (*itr)->noticeDeath(this);
    }
}

int Dish::processResult() {
    int result = 0;
    list<Cell*> detonate;
    unsigned int stable;
    while (cells.size() > 0) {
        stable = 0;
        for (list<Cell*>::iterator itr = cells.begin(); itr != cells.end(); itr++) {
            Cell* cell = *itr;
            if (cell->getNCnt() != 2) {
                detonate.push_back(cell);
            } else {
                stable++;
            }
        }

        if (cells.size() != 0 && cells.size() == stable) {
            return -1;
        }

        for (list<Cell*>::iterator ditr = detonate.begin(); ditr != detonate.end(); ditr++) {
            Cell *cell = *ditr;
            cell->destroy();
            list<Cell*>::iterator i = find(cells.begin(), cells.end(), cell);
            cells.erase(i);
            //delete cell;
        }

        detonate.clear();

        result++;
    }
    return result;
}

void Dish::insertCell(Cell* cell) {
    cells.push_back(cell);
}



void Cell::noticeDeath(Cell* cell) {
    neighbors.erase(cell);
}

void Cell::connectWithNeighbor(Cell* cell) {
    cell->neighbors.insert(this);
    neighbors.insert(cell);
}

int Cell::getNCnt() {
    return neighbors.size();
}

int main()
{
    int caseSize = 0;
    int w;
    int h;
    char inputChar[2000];
    Cell *prevBuffer[2000];
    Cell *inputBuffer[2000];
    Cell *prevCell;
    Cell *cell;

    cin >> caseSize;

    for (int caseCnt = 0; caseCnt < caseSize; caseCnt++) {
        cin >> w;
        cin >> h;

        Dish dish;
fgets(inputChar, 3, stdin);
        memset(prevBuffer, 0x00, sizeof(Cell*) * w);
        for (int hCnt = 0; hCnt < h; hCnt++) {
            memset(inputBuffer, 0x00, sizeof(Cell*) * w);
            //cin >> inputChar;
            fgets(inputChar, 1024, stdin);
            prevCell = 0x00;
            for (int wCnt = 0; wCnt < w; wCnt++) {
                if (inputChar[wCnt] == '*') {
                    cell = new Cell();
                    dish.insertCell(cell);
                    inputBuffer[wCnt] = cell;
                    if (prevBuffer[wCnt] != 0x00) {
                        cell->connectWithNeighbor(prevBuffer[wCnt]);
                    }
                    if (prevCell != 0x00) {
                        cell->connectWithNeighbor(prevCell);
                    }
                } else {
                    cell = 0x00;
                }
                prevCell = cell;
            }
            memcpy(prevBuffer, inputBuffer, sizeof(Cell*) * w);
        }

        cout << dish.processResult() << endl;
    }
}