import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Stack;
import java.util.StringTokenizer;

public class Main
	{
		static InputReader sc = new InputReader(System.in);
		static PrintWriter out = new PrintWriter(System.out);

		public static void main(String[] args)
		{
			int t = sc.nextInt();
			while (t-- > 0)
			{
				int n = sc.nextInt();
				int[] sz = new int[n + 2];
				int c = 1;
				for (int i = 1; i <= n; i++)
				{
					int x = sc.nextInt();
					sz[i] = x;

				}
				Stack<Integer> st1 = new Stack<Integer>();
				int[] right = new int[n + 2];
				Stack<Integer> st2 = new Stack<Integer>();
				int[] left = new int[n + 2];
				sz[0] = Integer.MAX_VALUE;
				sz[n + 1] = Integer.MAX_VALUE;
				// (从左往右放入)当ai被放入单调递增栈时，如果有元素bi出栈，那么ai就是bi的右边第一个>=bi的数
				for (int i = 0; i <= n + 1; i++)
				{
					// 单调递增 注意相等的也要叉出去
					while (!st1.isEmpty() && sz[st1.peek()] <= sz[i])
					{
						right[st1.peek()] = i;
						st1.pop();// 栈顶比当前大
					}
					st1.add(i);
				}
//				System.out.println("right[]=" + Arrays.toString(right));

				// 反向求左边 同理
				for (int i = n + 1; i >= 0; i--)
				{
					while (!st2.isEmpty() && sz[st2.peek()] <= sz[i])
					{
						left[st2.peek()] = i;
						st2.pop();// 栈顶比当前大
					}
					st2.add(i);
				}
//				System.out.println("left[]=" + Arrays.toString(left));

				long sum = 0;
				for (int i = 1; i <= n; i++)
				{
					sum += right[i] - left[i] - 1 - 1;
				}
				System.out.println(sum);
			}
			out.flush();// 最后输出
		}

		static class InputReader
			{

				public BufferedReader reader;
				public StringTokenizer tokenizer;

				public InputReader(InputStream stream)
				{
					reader = new BufferedReader(new InputStreamReader(stream), 32768);
					tokenizer = null;
				}

				public String next()
				{
					while (tokenizer == null || !tokenizer.hasMoreTokens())
					{
						try
						{
							tokenizer = new StringTokenizer(reader.readLine());
						} catch (IOException e)
						{
							throw new RuntimeException(e);
						}
					}
					return tokenizer.nextToken();
				}

				boolean hasNext()
				{
					while (tokenizer == null || !tokenizer.hasMoreTokens())
					{
						try
						{
							tokenizer = new StringTokenizer(reader.readLine());
						} catch (Exception e)
						{
							return false;
						}
					}
					return true;
				}

				public String nextLine()
				{
					String str = null;
					try
					{
						str = reader.readLine();
					} catch (IOException e)
					{
						e.printStackTrace();
					}
					return str;
				}

				public int nextInt()
				{
					return Integer.parseInt(next());
				}

				public long nextLong()
				{
					return Long.parseLong(next());
				}

				public Double nextDouble()
				{
					return Double.parseDouble(next());
				}

				public BigInteger nextBigInteger()
				{
					return new BigInteger(next());
				}

				public BigDecimal nextBigDecimal()
				{
					return new BigDecimal(next());
				}
			}
	}