
import java.io.*;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.TreeSet;

public class TaskB {

	// Union-Find Disjoint Sets Library written in OOP manner, using both path
	// compression and union by rank heuristics
	static class UnionFind {
		int[] p, rank, setSize;
		boolean[] usedSets;
		int numSets;
		// HashSet<Integer> sets;

		public UnionFind(int N) {
			p = new int[numSets = N];
			rank = new int[N];
			usedSets = new boolean[N];
			setSize = new int[N];
			for (int i = 0; i < N; i++) {
				p[i] = i;
				setSize[i] = 1;
			}
		}

		public void addnew(int a) {
			usedSets[a] = true;
		}

		public int findSet(int i) {
			return p[i] == i ? i : (p[i] = findSet(p[i]));
		}

		public boolean isSameSet(int i, int j) {
			return findSet(i) == findSet(j);
		}

		public void unionSet(int i, int j) {
			if (isSameSet(i, j))
				return;
			numSets--;
			int x = findSet(i), y = findSet(j);
			if (rank[x] > rank[y]) {
				p[y] = x;
				setSize[x] += setSize[y];
			} else {
				p[x] = y;
				setSize[y] += setSize[x];
				if (rank[x] == rank[y])
					rank[y]++;
			}
		}

		public int numDisjointSets() {
			return numSets;
		}

		public int sizeOfSet(int i) {
			return setSize[findSet(i)];
		}
	}

	public static void main(String[] args) throws IOException {

		Scanner sc = new Scanner(System.in);
		PrintWriter pw = new PrintWriter(System.out);

		int t = sc.nextInt();

		O: while (t-- > 0) {
			int n = sc.nextInt();

			int[] arr = new int[n];

			for (int i = 0; i < n; i++) {
				arr[i] = sc.nextInt();
			}
			int last = (n / 2) - 1;
			for (; last > 0; last--) {
				if (arr[last] > arr[last + 1]) {
					break;
				}
			}

			int first = 0;

			for (; first < last; first++) {
				if (arr[first] > arr[first + 1]) {
					break;
				}
			}

			if (first + 1 >= last / 2) {
				pw.println("0 0 0");
				continue O;
			}

			int mid = first + 1;
			int mida = 0;

			for (; mid < last; mid++) {
				mida++;
				if (arr[mid] > arr[mid + 1] && mida - 1 > first) {
					break;
				}
			}

			if (mid == last) {
				pw.println("0 0 0");
				continue O;
			}
			if ((first + 1 >= mid) || first + 1 >= last - mid)
				pw.println("0 0 0");
			else
				pw.println((first + 1) + " " + mida + " " + (last - mid));
		}
		pw.close();
	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

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

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

		public String nextLine() throws IOException {
			return br.readLine();
		}

		public double nextDouble() throws IOException {
			String x = next();
			StringBuilder sb = new StringBuilder("0");
			double res = 0, f = 1;
			boolean dec = false, neg = false;
			int start = 0;
			if (x.charAt(0) == '-') {
				neg = true;
				start++;
			}
			for (int i = start; i < x.length(); i++)
				if (x.charAt(i) == '.') {
					res = Long.parseLong(sb.toString());
					sb = new StringBuilder("0");
					dec = true;
				} else {
					sb.append(x.charAt(i));
					if (dec)
						f *= 10;
				}
			res += Long.parseLong(sb.toString()) / f;
			return res * (neg ? -1 : 1);
		}

		public boolean ready() throws IOException {
			return br.ready();
		}

	}

}