package main

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

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

var treeMin []int
var treeMax []int
var a []int

func build(node, l, r int) {
	if l == r {
		treeMin[node] = a[l]
		treeMax[node] = a[l]
		return
	}
	mid := (l + r) / 2
	build(node*2, l, mid)
	build(node*2+1, mid+1, r)
	treeMin[node] = min(treeMin[node*2], treeMin[node*2+1])
	treeMax[node] = max(treeMax[node*2], treeMax[node*2+1])
}

func searchFirstGE(node, l, r, X int) int {
	if l == r {
		return l
	}
	mid := (l + r) / 2
	if treeMax[node*2] >= X {
		return searchFirstGE(node*2, l, mid, X)
	}
	return searchFirstGE(node*2+1, mid+1, r, X)
}

func findFirstGE(node, l, r, ql, qr, X int) int {
	if ql > r || qr < l || treeMax[node] < X {
		return len(a)
	}
	if ql <= l && r <= qr {
		return searchFirstGE(node, l, r, X)
	}
	mid := (l + r) / 2
	res := findFirstGE(node*2, l, mid, ql, qr, X)
	if res != len(a) {
		return res
	}
	return findFirstGE(node*2+1, mid+1, r, ql, qr, X)
}

func searchLastLE(node, l, r, X int) int {
	if l == r {
		return l
	}
	mid := (l + r) / 2
	if treeMin[node*2+1] <= X {
		return searchLastLE(node*2+1, mid+1, r, X)
	}
	return searchLastLE(node*2, l, mid, X)
}

func findLastLE(node, l, r, ql, qr, X int) int {
	if ql > r || qr < l || treeMin[node] > X {
		return 0
	}
	if ql <= l && r <= qr {
		return searchLastLE(node, l, r, X)
	}
	mid := (l + r) / 2
	res := findLastLE(node*2+1, mid+1, r, ql, qr, X)
	if res != 0 {
		return res
	}
	return findLastLE(node*2, l, mid, ql, qr, X)
}

type Fenwick struct {
	tree []int
}

func newFenwick(size int) *Fenwick {
	return &Fenwick{tree: make([]int, size+1)}
}

func (f *Fenwick) Add(i, delta int) {
	for ; i < len(f.tree); i += i & -i {
		f.tree[i] += delta
	}
}

func (f *Fenwick) Query(i int) int {
	sum := 0
	for ; i > 0; i -= i & -i {
		sum += f.tree[i]
	}
	return sum
}

func readInt(in *bufio.Reader) int {
	n := 0
	c, err := in.ReadByte()
	for err == nil && c <= ' ' {
		c, err = in.ReadByte()
	}
	for err == nil && c > ' ' {
		n = n*10 + int(c-'0')
		c, err = in.ReadByte()
	}
	return n
}

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

	t := readInt(in)
	for tc := 0; tc < t; tc++ {
		n := readInt(in)
		k := readInt(in)

		a = make([]int, n+1)
		for i := 1; i <= n; i++ {
			a[i] = readInt(in)
		}

		treeMin = make([]int, 4*n+4)
		treeMax = make([]int, 4*n+4)
		build(1, 1, n)

		Lmax := make([]int, n+1)
		Rmin := make([]int, n+1)

		for i := 1; i <= n; i++ {
			Lmax[i] = findLastLE(1, 1, n, 1, i-1, k-a[i])
			Rmin[i] = findFirstGE(1, 1, n, i+1, n, k-a[i])
		}

		events := make([][]int, n+2)
		for l := 1; l <= n; l++ {
			if Rmin[l] <= n {
				events[Rmin[l]] = append(events[Rmin[l]], l)
			}
		}

		fenwick := newFenwick(n)
		ans := int64(0)

		for r := 1; r <= n; r++ {
			for _, l := range events[r] {
				fenwick.Add(l, 1)
			}
			if Lmax[r] > 0 {
				ans += int64(fenwick.Query(Lmax[r]))
			}
		}

		for m := 2; m <= n-1; m++ {
			lChoices := int64(m - 1 - Lmax[m])
			rChoices := int64(Rmin[m] - 1 - m)
			if lChoices > 0 && rChoices > 0 {
				ans -= lChoices * rChoices
			}
		}

		fmt.Fprintln(out, ans)
	}
}