package main

import (
	"bufio"
	"fmt"
	"os"
)

const MOD int64 = 1000000007

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	var t int
	if _, err := fmt.Fscan(reader, &t); err != nil {
		return
	}

	for tc := 0; tc < t; tc++ {
		var n int
		fmt.Fscan(reader, &n)

		adj := make([][]int, n+1)
		for i := 0; i < n-1; i++ {
			var u, v int
			fmt.Fscan(reader, &u, &v)
			adj[u] = append(adj[u], v)
			adj[v] = append(adj[v], u)
		}

		pow2 := make([]int64, n+1)
		pow2[0] = 1
		for i := 1; i <= n; i++ {
			pow2[i] = (pow2[i-1] * 2) % MOD
		}

		var ans1 int64 = 0
		sz := make([]int, n+1)
		var dfs func(int, int)
		dfs = func(curr, parent int) {
			sz[curr] = 1
			for _, nxt := range adj[curr] {
				if nxt != parent {
					dfs(nxt, curr)
					sz[curr] += sz[nxt]
					L := sz[nxt]
					R := n - L
					ways := ((pow2[L] - 1 + MOD) % MOD * (pow2[R] - 1 + MOD) % MOD) % MOD
					ans1 = (ans1 + ways) % MOD
				}
			}
		}
		if n > 1 {
			dfs(1, 0)
		}

		var ans2 int64 = 0
		dist := make([]int, n+1)
		branch := make([]int, n+1)
		q := make([]int, n+1)
		headDist := make([]int, n+2)
		nextDist := make([]int, n+1)
		N := make([]int, n+1)

		for u := 1; u <= n; u++ {
			k := len(adj[u])
			if k < 3 {
				continue
			}

			for j := 1; j <= n; j++ {
				dist[j] = -1
			}
			dist[u] = 0

			head, tail := 0, 0
			for i, v := range adj[u] {
				dist[v] = 1
				branch[v] = i
				q[tail] = v
				tail++
			}

			max_d := 0
			for head < tail {
				curr := q[head]
				head++
				if dist[curr] > max_d {
					max_d = dist[curr]
				}
				for _, nxt := range adj[curr] {
					if dist[nxt] == -1 {
						dist[nxt] = dist[curr] + 1
						branch[nxt] = branch[curr]
						q[tail] = nxt
						tail++
					}
				}
			}

			for i := 0; i <= max_d; i++ {
				headDist[i] = 0
			}
			for j := 1; j <= n; j++ {
				if j != u {
					d := dist[j]
					nextDist[j] = headDist[d]
					headDist[d] = j
				}
			}

			for i := 0; i < k; i++ {
				N[i] = 0
			}
			N_total := 0

			for d := max_d; d >= 1; d-- {
				curr := headDist[d]
				for curr != 0 {
					b := branch[curr]
					N[b]++
					N_total++
					curr = nextDist[curr]
				}

				if N_total == 0 {
					continue
				}

				term1 := (int64(k-2) * pow2[N_total]) % MOD
				var term2, term3 int64 = 0, 0
				for i := 0; i < k; i++ {
					term2 = (term2 + pow2[N_total-N[i]]) % MOD
					term3 = (term3 + pow2[N[i]]) % MOD
				}

				E := (term1 - term2 + term3 + 2 - int64(k)) % MOD
				if E < 0 {
					E += MOD
				}
				ans2 = (ans2 + E) % MOD
			}
		}

		ans := (ans1 + ans2) % MOD
		fmt.Fprintln(writer, ans)
	}
}