package main

import (
	"bytes"
	"io"
	"os"
	"strconv"
)

type FastScanner struct {
	data []byte
	idx  int
	n    int
}

func NewFastScanner() *FastScanner {
	data, _ := io.ReadAll(os.Stdin)
	return &FastScanner{data: data, n: len(data)}
}

func (fs *FastScanner) NextInt() int {
	for fs.idx < fs.n && (fs.data[fs.idx] < '0' || fs.data[fs.idx] > '9') {
		fs.idx++
	}
	val := 0
	for fs.idx < fs.n && fs.data[fs.idx] >= '0' && fs.data[fs.idx] <= '9' {
		val = val*10 + int(fs.data[fs.idx]-'0')
		fs.idx++
	}
	return val
}

func main() {
	in := NewFastScanner()
	t := in.NextInt()
	var out bytes.Buffer

	for ; t > 0; t-- {
		n := in.NextInt()
		m := 2 * (n - 1)
		head := make([]int, n+1)
		for i := 1; i <= n; i++ {
			head[i] = -1
		}
		to := make([]int, m)
		next := make([]int, m)
		idx := 0
		addEdge := func(u, v int) {
			to[idx] = v
			next[idx] = head[u]
			head[u] = idx
			idx++
		}

		for i := 0; i < n-1; i++ {
			u := in.NextInt()
			v := in.NextInt()
			addEdge(u, v)
			addEdge(v, u)
		}

		parent := make([]int, n+1)
		order := make([]int, 0, n)
		stack := make([]int, 0, n)
		stack = append(stack, 1)

		for len(stack) > 0 {
			u := stack[len(stack)-1]
			stack = stack[:len(stack)-1]
			order = append(order, u)
			for e := head[u]; e != -1; e = next[e] {
				v := to[e]
				if v == parent[u] {
					continue
				}
				parent[v] = u
				stack = append(stack, v)
			}
		}

		sz := make([]int, n+1)
		dp := make([]int, n+1)

		for i := len(order) - 1; i >= 0; i-- {
			u := order[i]
			sz[u] = 1
			c1, c2 := 0, 0
			for e := head[u]; e != -1; e = next[e] {
				v := to[e]
				if v == parent[u] {
					continue
				}
				sz[u] += sz[v]
				if c1 == 0 {
					c1 = v
				} else {
					c2 = v
				}
			}
			if c1 == 0 {
				dp[u] = 0
			} else if c2 == 0 {
				dp[u] = sz[c1] - 1
			} else {
				a := dp[c1] + sz[c2] - 1
				b := dp[c2] + sz[c1] - 1
				if a > b {
					dp[u] = a
				} else {
					dp[u] = b
				}
			}
		}

		out.WriteString(strconv.Itoa(dp[1]))
		out.WriteByte('\n')
	}

	os.Stdout.Write(out.Bytes())
}