```go
package main

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

const mod = 1000000007

type State struct {
	blocks int
	count  int64
}

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

	var t int
	fmt.Fscan(reader, &t)

	for ; t > 0; t-- {
		var n, k int
		fmt.Fscan(reader, &n, &k)
		c := make([]int, n)
		for i := 0; i < n; i++ {
			fmt.Fscan(reader, &c[i])
		}

		dp := make([][]State, n+1)
		for i := range dp {
			dp[i] = make([]State, k)
			for j := range dp[i] {
				dp[i][j].blocks = -1
				dp[i][j].count = 0
			}
		}
		dp[0][0] = State{0, 1}

		for i := 0; i < n; i++ {
			col := c[i]
			newDp := make([][]State, n+1)
			for i := range newDp {
				newDp[i] = make([]State, k)
				for j := range newDp[i] {
					newDp[i][j] = dp[i][j]
				}
			}

			if dp[0][0].blocks >= 0 {
				if k == 1 {
					newBlocks := dp[0][0].blocks + 1
					if newDp[0][0].blocks < newBlocks {
						newDp[0][0] = State{newBlocks, dp[0][0].count}
					} else if newDp[0][0].blocks == newBlocks {
						newDp[0][0].count = (newDp[0][0].count + dp[0][0].count) % mod
					}
				} else {
					if newDp[col][1].blocks < dp[0][0].blocks {
						newDp[col][1] = State{dp[0][0].blocks, dp[0][0].count}
					} else if newDp[col][1].blocks == dp[0][0].blocks {
						newDp[col][1].count = (newDp[col][1].count + dp[0][0].count) % mod
					}
				}
			}

			for r := 1; r < k; r++ {
				if dp[col][r].blocks < 0 {
					continue
				}
				if r+1 == k {
					newBlocks := dp[col][r].blocks + 1
					if newDp[0][0].blocks < newBlocks {
						newDp[0][0] = State{newBlocks, dp[col][r].count}
					} else if newDp[0][0].blocks == newBlocks {
						newDp[0][0].count = (newDp[0][0].count + dp[col][r].count) % mod
					}
				} else {
					if newDp[col][r+1].blocks < dp[col][r].blocks {
						newDp[col][r+1] = State{dp[col][r].blocks, dp[col][r].count}
					} else if newDp[col][r+1].blocks == dp[col][r].blocks {
						newDp[col][r+1].count = (newDp[col][r+1].count + dp[col][r].count) % mod
					}
				}
			}

			dp = newDp
		}

		if dp[0][0].blocks == 0 {
			fmt.Fprintln(writer, 0)
		} else {
			fmt.Fprintln(writer, dp[0][0].count%mod)
		}
	}
}
```