package main

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

const MOD int64 = 1000000007

type FastScanner struct {
	r *bufio.Reader
}

func NewFastScanner() *FastScanner {
	return &FastScanner{r: bufio.NewReader(os.Stdin)}
}

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

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

func main() {
	in := NewFastScanner()
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	t := in.NextInt()
	maxN := 5000
	fact := make([]int64, maxN+1)
	ifact := make([]int64, maxN+1)
	fact[0] = 1
	for i := 1; i <= maxN; i++ {
		fact[i] = fact[i-1] * int64(i) % MOD
	}
	ifact[maxN] = modPow(fact[maxN], MOD-2)
	for i := maxN; i >= 1; i-- {
		ifact[i-1] = ifact[i] * int64(i) % MOD
	}
	comb := func(n, k int) int64 {
		if k < 0 || k > n || n < 0 {
			return 0
		}
		return (((fact[n] * ifact[k]) % MOD) * ifact[n-k]) % MOD
	}

	for ; t > 0; t-- {
		n := in.NextInt()
		a := make([]int, n+1)
		isNeg := make([]bool, n+2)
		P := make([]int, 0)
		for i := 1; i <= n; i++ {
			a[i] = in.NextInt()
			if a[i] == -1 {
				isNeg[i] = true
				P = append(P, i)
			}
		}
		S := len(P)
		posOf := make([]int, n)
		for i := 0; i < n; i++ {
			posOf[i] = -1
		}
		for i := 1; i <= n; i++ {
			if a[i] != -1 {
				posOf[a[i]] = i
			}
		}
		prefixNeg := make([]int, n+1)
		for i := 1; i <= n; i++ {
			prefixNeg[i] = prefixNeg[i-1]
			if isNeg[i] {
				prefixNeg[i]++
			}
		}

		var singles int64 = 0
		w := make([]int64, 0)
		if S >= 1 {
			for _, p := range P {
				singles = (singles + int64(p)*int64(n-p+1)) % MOD
			}
			if S >= 2 {
				w = make([]int64, S-1)
				for i := 0; i < S-1; i++ {
					pi := int64(P[i])
					for j := i + 1; j < S; j++ {
						tgap := j - i - 1
						add := (pi * int64(n-P[j]+1)) % MOD
						w[tgap] += add
						if w[tgap] >= MOD {
							w[tgap] -= MOD
						}
					}
				}
			}
		}

		var ans int64 = 0
		missSmall := 0
		fCount := 0
		lF, rF := 0, 0
		stateValid := false
		var conv []int64
		aCnt, bCnt, cCnt := 0, 0, 0

		buildState := func() {
			aCnt = prefixNeg[lF-1]
			cCnt = prefixNeg[n] - prefixNeg[rF]
			if rF-1 >= lF {
				bCnt = prefixNeg[rF-1] - prefixNeg[lF]
			} else {
				bCnt = 0
			}
			Lcount := make([]int64, aCnt+1)
			x := 0
			Lcount[0]++
			for l := lF - 1; l >= 1; l-- {
				if isNeg[l] {
					x++
				}
				Lcount[x]++
			}
			Rcount := make([]int64, cCnt+1)
			y := 0
			Rcount[0]++
			for r := rF + 1; r <= n; r++ {
				if isNeg[r] {
					y++
				}
				Rcount[y]++
			}
			conv = make([]int64, aCnt+cCnt+1)
			for i := 0; i <= aCnt; i++ {
				li := Lcount[i]
				if li == 0 {
					continue
				}
				for j := 0; j <= cCnt; j++ {
					if Rcount[j] == 0 {
						continue
					}
					s := i + j
					conv[s] = (conv[s] + li*Rcount[j]) % MOD
				}
			}
			stateValid = true
		}

		for k := 0; k < n; k++ {
			stateChanged := false
			if posOf[k] != -1 {
				fCount++
				if fCount == 1 {
					lF, rF = posOf[k], posOf[k]
					stateChanged = true
				} else {
					p := posOf[k]
					if p < lF {
						lF = p
						stateChanged = true
					}
					if p > rF {
						rF = p
						stateChanged = true
					}
				}
			} else {
				missSmall++
			}
			m := missSmall
			sgt := S - m
			var U int64 = 0
			if fCount == 0 {
				if m == 1 {
					U = singles
				} else if m >= 2 {
					if S >= 2 {
						var sum int64 = 0
						for tgap := 0; tgap <= S-2; tgap++ {
							c := comb(tgap, m-2)
							if c != 0 && w[tgap] != 0 {
								sum = (sum + w[tgap]*c) % MOD
							}
						}
						U = sum
					} else {
						U = 0
					}
				} else {
					U = 0
				}
			} else {
				if stateChanged || !stateValid {
					buildState()
				}
				var sum int64 = 0
				maxs := aCnt + cCnt
				for s := 0; s <= maxs; s++ {
					if conv[s] == 0 {
						continue
					}
					c := comb(bCnt+s, m)
					if c != 0 {
						sum = (sum + conv[s]*c) % MOD
					}
				}
				U = sum
			}
			U = U * fact[m] % MOD
			if sgt >= 0 {
				U = U * fact[sgt] % MOD
			} else {
				U = 0
			}
			ans += U
			if ans >= MOD {
				ans -= MOD
			}
		}
		if ans < 0 {
			ans += MOD
		}
		fmt.Fprintln(out, ans%MOD)
	}
}