```go
package main

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

type FastScanner struct {
	r *bufio.Reader
}

func NewFastScanner() *FastScanner {
	return &FastScanner{r: bufio.NewReaderSize(os.Stdin, 1<<20)}
}

func (fs *FastScanner) NextInt() int {
	sign := 1
	val := 0
	b, _ := fs.r.ReadByte()
	for (b < '0' || b > '9') && b != '-' {
		b, _ = fs.r.ReadByte()
	}
	if b == '-' {
		sign = -1
		b, _ = fs.r.ReadByte()
	}
	for b >= '0' && b <= '9' {
		val = val*10 + int(b-'0')
		b, _ = fs.r.ReadByte()
	}
	return sign * val
}

type Key struct {
	h1 int64
	h2 int64
	l  int
}

var (
	mod1 int64 = 1000000007
	mod2 int64 = 1000000009
	base int64 = 911382323
	add  int64 = 1000003

	pow1  = []int64{1}
	pow2  = []int64{1}
	invB1 int64
	invB2 int64
)

func powmod(a, e, m int64) int64 {
	res := int64(1)
	a %= m
	for e > 0 {
		if e&1 == 1 {
			res = (res * a) % m
		}
		a = (a * a) % m
		e >>= 1
	}
	return res
}

func ensurePow(k int) {
	for len(pow1) <= k {
		pow1 = append(pow1, (pow1[len(pow1)-1]*base)%mod1)
		pow2 = append(pow2, (pow2[len(pow2)-1]*base)%mod2)
	}
}

func main() {
	in := NewFastScanner()
	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer out.Flush()

	invB1 = powmod(base%mod1, mod1-2, mod1)
	invB2 = powmod(base%mod2, mod2-2, mod2)

	q := in.NextInt()
	for ; q > 0; q-- {
		n := in.NextInt()
		st := make([]int, 0, n)
		var h1, h2, rh1, rh2 int64
		L := 0
		cnt := make(map[Key]int64)
		cnt[Key{0, 0, 0}] = 1
		var ans int64

		for i := 0; i < n; i++ {
			x := in.NextInt()
			v := int64(x) + add
			if L > 0 && st[len(st)-1] == x {
				L--
				st = st[:len(st)-1]
				ensurePow(L)
				t1 := (v * pow1[L]) % mod1
				t2 := (v * pow2[L]) % mod2
				h1 -= t1
				if h1 < 0 {
					h1 += mod1
				}
				h2 -= t2
				if h2 < 0 {
					h2 += mod2
				}
				rh1 -= v
				if rh1 < 0 {
					rh1 += mod1
				}
				rh1 = (rh1 * invB1) % mod1
				rh2 -= v
				if rh2 < 0 {
					rh2 += mod2
				}
				rh2 = (rh2 * invB2) % mod2
			} else {
				ensurePow(L)
				st = append(st, x)
				t1 := (v * pow1[L]) % mod1
				t2 := (v * pow2[L]) % mod2
				h1 += t1
				if h1 >= mod1 {
					h1 -= mod1
				}
				h2 += t2
				if h2 >= mod2 {
					h2 -= mod2
				}
				rh1 = (rh1*base + v) % mod1
				rh2 = (rh2*base + v) % mod2
				L++
			}

			krev := Key{rh1, rh2, L}
			ans += cnt[krev]
			kfwd := Key{h1, h2, L}
			cnt[kfwd]++
		}
		fmt.Fprintln(out, ans)
	}
}
```