// 题意：给一张图，图中有两种点，一次只能覆盖相邻（上下左右）两点

 // 求最小覆盖数

 // 二分图最小覆盖数等于最大匹配数，匈牙利算法求最大匹配数

 // 此题建图方面有些繁琐，看了大佬的题解后，才建图成功

 #include <cstdio>

 #include <cstring>

 using namespace std;

 const int max_h = ;

 const int max_w = ;

 int h,w;

 char s[max_h][max_w];

 int n;

 int total=,save=,cur;

 int direct[][]={{,},{-,},{,},{,-}};

 const int max_n=+;

 int cx[max_n],cy[max_n],st[max_n];

 bool vis[max_n];

 struct node

 {

     int y,nxt;

 };

 // 这里数组开的小了点，但是刚好够用了，大佬在题解中开了比这大百倍的数组。不知道为什么

 // 这个数组的最大用量，应该由add函数的使用上限决定

 // 每遍历一个点，最多在上下左右四个方向进行一次add函数的调用，所以只需要4*max_n次即可

 node way[];

 // 计算在一维数组中的位置

 int get(int i,int j)

 {

     return i*w+j;

 }

 void add(int u,int v)

 {

     ++cur;

     // 当前数组中存储邻接点v和st【u】

     way[cur].y=v;

     way[cur].nxt=st[u];

     // st数组存储当u的边在数组中的位置

     st[u]=cur;

 }

 int match(int x)

 {

     for(int i=st[x];i;i=way[i].nxt)

     {

         int y=way[i].y;

         if(!vis[y])

         {

             vis[y]=;

             if(!cy[y] || match(cy[y]))

             {

                 cx[x]=y;

                 cy[y]=x;

                 return ;

             }

         }

     }

     return ;

 }

 int XYL()

 {

     memset(cx,,sizeof(cx));

     memset(cy,,sizeof(cy));

     int ans=;

     for(int i=;i<n;++i)

     {

         // 遍历所有节点，如果找到没有匹配的x，看能否找到与之匹配的y

         // 这里加了一步判断，对st[i]不为0的判断，也就是对当前节点不为'o'的判断

         // 不加这一个判断也可得出正确的结果，但加入后会有优化，不用再执行之后许多无用的操作

         // 毕竟只有'*'的点需要匹配不是吗？

         if(!cx[i] && st[i])

         {

             memset(vis,,sizeof(vis));

             ans+=match(i);

         }

     }

     return ans;

 }

 int main()

 {

     int T;

     scanf("%d",&T);

     while(T--)

     {

         // 输入数据

         scanf("%d %d",&h,&w);

         for(int i=;i<h;++i)

         {

             scanf("%s",s[i]);

         }

         // 初始化way数组和st数组

         cur=;

         memset(st,,sizeof(st));

         // n表示总节点数

         n=h*w;

         // total表示*的总数

         total=;

         for(int i=;i<h;++i)

         {

             for(int j=;j<w;++j)

             {

                 if(s[i][j]=='*')

                 {

                     ++ total;

                     // 检查相邻四个方向

                     for(int k=;k<;++k)

                     {

                         int tx=i+direct[k][];

                         int ty=j+direct[k][];

                         // 在图的范围内且为*时，加边

                         if(tx>= && tx<h && ty>= && ty<w)

                         {

                             if(s[tx][ty]=='*')

                             {

                                 int u=get(i,j);

                                 int v=get(tx,ty);

                                 add(u,v);

                                 // printf("add");

                             }

                         }

                     }

                 }

             }

         }

         //printf("cur:%d\n",tot);

         printf("%d\n",total-XYL()/);

     }

     return ;

 }

 /*

 2

 7 9

 ooo**oooo

 **oo*ooo*

 o*oo**o**

 ooooooooo

 *******oo

 o*o*oo*oo

 *******oo

 10 1

 *

 *

 *

 o

 *

 *

 *

 *

 *

 *

 */