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

const int N  = 2e5 + 10;
int dfn[N],low[N],dfs_clock;

int n, m;
int h[N], to[N], nx[N], sz;

int bridge[N];

int belong[N];
int block;

int p1, p2;
int dis1, dis2;
int f[N];

vector<int> g[N];

void add(int a, int b) {
  to[sz] = b;
  nx[sz] = h[a];
  h[a] = sz ++;
}

void tarjan(int u, int fa)
{
  dfn[u] = low[u] = ++dfs_clock;
  bool flag = false;
  for(int i=h[u]; i != -1; i = nx[i])
  {
    int v = to[i];
    if(v==fa && !flag)//如果有重邊，那麼邊(u,v)被存了兩次，所以，如果第二次訪問，就讓他通過
    {
      flag = true;
      continue;
    }
    if(dfn[v] == 0)
      tarjan(v,u);
    low[u] = min(low[u],low[v]);
    if(low[v] > dfn[u]) {
      //cntCut++;
      bridge[i] = 1;
    }
  }
}

void dfs(int x) {
  belong[x] = block;
  for(int i = h[x]; i != -1; i = nx[i]) {
    if(bridge[i]) continue;
    if(belong[to[i]]) continue;
    dfs(to[i]);
  }
}

void dfs1(int x, int y) {
  f[x] = 1;
  if(y > dis1) {
    dis1 = y;
    p1 = x;
  }
  for(int i = 0; i < g[x].size(); i ++) {
    if(f[g[x][i]]) continue;
    dfs1(g[x][i], y + 1);
  }
}

void dfs2(int x, int y) {
  f[x] = 1;
  if(y > dis2) {
    dis2 = y;
    p2 = x;
  }
  for(int i = 0; i < g[x].size(); i ++) {
    if(f[g[x][i]]) continue;
    dfs2(g[x][i], y + 1);
  }
}

int main()
{
  int T;
  scanf("%d", &T);
  while(T--) {
    scanf("%d%d",&n,&m);
    
    sz = 0;
    dfs_clock = 0;
    memset(dfn, 0, sizeof dfn);
    memset(low,0,sizeof low);
    
    for(int i = 0; i <= n; i ++) {
      h[i] = -1;
    }
    for(int i=0; i<m; ++i)
    {
      int a, b;
      scanf("%d%d",&a,&b);
      add(a, b);
      add(b, a);
    }
  
    memset(bridge, 0, sizeof bridge);
    tarjan(1, -1);
    for(int i = 0; i < sz; i ++) {
      if(bridge[i]) bridge[i ^ 1] = 1;
    }
    
    /*
    for(int from = 1; from <= n; from ++) {
      for(int i = h[from]; i != - 1; i = nx[i]) {
        if(bridge[i])
          printf("%d - %d\n", from, to[i]);
      }
    }
     */
    
    memset(belong,0,sizeof belong);
    block = 0;
    for(int i = 1; i <= n; i ++) {
      if(belong[i] == 0) {
        block ++;
        dfs(i);
      }
    }
    
    /*
    for(int i = 1; i <= n; i ++) {
      cout << i << " " << belong[i] << endl;
    }
     */
    
    for(int i = 1; i <= block; i ++) {
      g[i].clear();
    }
    
    for(int from = 1; from <= n; from ++) {
      for(int i = h[from]; i != - 1; i = nx[i]) {
        if(bridge[i]) {
       //   cout << belong[from] << " " << belong[to[i]] << endl;
          g[belong[from]].push_back(belong[to[i]]);
          g[belong[to[i]]].push_back(belong[from]);
        }
      }
    }
    
    memset(f,0,sizeof f);
    p1 = 0;
    dis1 = 0;
    dfs1(1, 0);
    
    memset(f,0,sizeof f);
    p2 = 0;
    dis2 = 0;
    dfs2(p1,0);
    
    printf("%d\n", block - 1 - dis2);
  }
  return 0;
}