import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

//import graph_representation.edge;
public class hacker49 {
	public static int r1=0;
	static class FastReader 
    { 
        BufferedReader br; 
        StringTokenizer st; 
  
        public FastReader() 
        { 
            br = new BufferedReader(new
                     InputStreamReader(System.in)); 
        } 
  
        String next() 
        { 
            while (st == null || !st.hasMoreElements()) 
            { 
                try
                { 
                    st = new StringTokenizer(br.readLine()); 
                } 
                catch (IOException  e) 
                { 
                    e.printStackTrace(); 
                } 
            } 
            return st.nextToken(); 
        } 
  
        int nextInt() 
        { 
            return Integer.parseInt(next()); 
        } 
  
        long nextLong() 
        { 
            return Long.parseLong(next()); 
        } 
  
        double nextDouble() 
        { 
            return Double.parseDouble(next()); 
        } 
  
        String nextLine() 
        { 
            String str = ""; 
            try
            { 
                str = br.readLine(); 
            } 
            catch (IOException e) 
            { 
                e.printStackTrace(); 
            } 
            return str; 
        } 
    } 
//static 	ArrayList<Integer>[] f=new ArrayList[200001];
static 	int[] deg=new int[100001];
	static HashMap<Long,Integer> e=new HashMap<>();
	public static void main(String[] args) {
		OutputStream outputStream =System.out;
	    PrintWriter out =new PrintWriter(outputStream);
		FastReader s=new FastReader();
int t=s.nextInt();
while(t>0) {
	int n=s.nextInt();
	Stack<Integer> s1=new Stack<>();
	Stack<Integer> s2=new Stack<>();
	Stack<Integer> s3=new Stack<>();
	int[] a=new int[n+1];
	for(int i=1;i<=n;i++) {
		a[i]=s.nextInt();
		
	}
	int i=1;
	int g=a[1];
	while(a[i]==g && i<=n/2) {
		s1.add(a[i]);
		i++;
	}
	g=a[i];
	while(a[i]==g && i<=n/2) {
		s2.add(a[i]);
		i++;
	}
	while(i<=n/2) {
		s3.add(a[i]);
		i++;
	}
	if(s2.isEmpty() || s3.isEmpty()) {
		out.println(0+" "+0+" "+0 );
	}else {
		while(!s3.isEmpty() && s3.peek()==a[n/2+1]) {
			s3.pop();
		}
		if(s3.isEmpty()) {
			out.println(0+" "+0+" "+0);
		}else {
			out.println(s1.size()+" "+s2.size()+" "+s3.size());
			
		}
		
		
	}
	t--;
}
out.close();
	}
	
	static ArrayList<Integer>[] f=new ArrayList[100001];
	public static long binary_exponentiation_1(long a,long n) {
		long res=1;
		while(n>0) {
			if(n%2!=0) {
				res=((res)%(1000000007) * (a)%(1000000007))%(1000000007);
				n--;
				
			}else {
				a=((a)%(1000000007) *(a)%(1000000007))%(1000000007);
				n/=2;
			}
		}
		return (res)%(1000000007);
		
	}
	public static long im(long a) {
		return binary_exponentiation_1(a,MOD-2)%MOD;
	}
	public static long[] fac=new long[10000001];
	public static void find_factorial() {
		fac[0]=1;
		fac[1]=1;
		for(int i=2;i<=200000;i++) {
			fac[i]=(fac[i-1]*i)%(MOD);
		}
	}
	static int l=1;
	static int r=1;
	static int[][] vis=new int[301][301];
	static boolean isvalid(int x,int y,int n,int m) {
		if(x>=1 && x<=n && y>=1 && y<=m) {
			return true;
		}
	return false;
	}
static void dfs(int n,int m,int count,int g) {
System.out.print(l+" "+r+" ");
vis[l][r]=1;
if(count==g) {
	return;
}
if(isvalid(l,r+1,n,m) && vis[l][r+1]==0) {
	r++;
	dfs(n,m,count+1,g);
	
}else if(isvalid(l,r-1,n,m) && vis[l][r-1]==0) {
	r--;
	dfs(n,m,count+1,g);
//	l++;
}else {
	l++;
	dfs(n,m,count+1,g);
//	l--;
}

}
	public static long be(long a,long n) {
		long res=1;
		while(n>0) {
			if(n%2!=0) {
				res=((res)%(1000000007) * (a)%(1000000007))%(1000000007);
				n--;
			}else {
				a=((a)%(1000000007) *(a)%(1000000007))%(1000000007);
				n/=2;
			}
		}
		return (res)%(1000000007);
		
	}
//	
	static class pair2 implements Comparable<pair2>{
		private int a;
		private int b;
		private long  c;
		pair2(int a,int b,long c){
			this.a=a;
			this.b=b;
			this.c=c;
		}
		public int compareTo(pair2 o) {
//			
//			return Long.compare(o.c,this.c);
			if(Long.compare(o.c, this.c)!=0) {
				return Long.compare(o.c,this.c);}
			else {
				return Long.compare(deg[this.a]+deg[this.b], deg[o.a]+deg[o.b]);
			}
		}
		
	}
	


		
	public static int upper_bound(int[] a ,int n,int x) {
		int l=-1;
		int r=n;
		while(r>l+1) {
			int mid=(l+r)/2;
			if(a[mid]<x) {
				l=mid;
			}else {
				r=mid;
			}
		}
		return r;
				
	}

//	
//	
	public static int lower_bound(long[] pre,long x,int n) {
		int l=-1;
		int r=n;
		while(r>l+1) {
			int mid=(l+r)/2;
			if(pre[mid]<=x) {
				l=mid;
			}else {
				r=mid;
			}
		}
		return l;
				
	}
	

	
	
	public static long[] merge_sort(long[] A, int start, int end) {
		if (end > start) {
			int mid = (end + start) / 2;
			long[] v = merge_sort(A, start, mid);
			long[] o = merge_sort(A, mid + 1, end);
			return (merge(v, o));
		} else {
			long[] y = new long[1];
			y[0] = A[start];
			return y;
		}
	}
	public static long[] merge(long a[], long b[]) {
//		int count=0;
		long[] temp = new long[a.length + b.length];
		int m = a.length;
		int n = b.length;
		int i = 0;
		int j = 0;
		int c = 0;
		while (i < m && j < n) {
			if (a[i] < b[j]) {
				temp[c++] = a[i++];
			
			} else {
				temp[c++] = b[j++];
			}
		}
		while (i < m) {
			temp[c++] = a[i++];
		}
		while (j < n) {
			temp[c++] = b[j++];
		}
		return temp;
	}
	
	public static int[] merge_sort1(int[] A, int start, int end) {
		if (end > start) {
			int mid = (end + start) / 2;
			int[] v = merge_sort1(A, start, mid);
			int[] o = merge_sort1(A, mid + 1, end);
			return (merge1(v, o));
		} else {
			int[] y = new int[1];
			y[0] = A[start];
			return y;
		}
	}
	public static int[] merge1(int a[], int b[]) {
//		int count=0;
		int[] temp = new int[a.length + b.length];
		int m = a.length;
		int n = b.length;
		int i = 0;
		int j = 0;
		int c = 0;
		while (i < m && j < n) {
			if (a[i] < b[j]) {
				temp[c++] = a[i++];
			
			} else {
				temp[c++] = b[j++];
			}
		}
		while (i < m) {
			temp[c++] = a[i++];
		}
		while (j < n) {
			temp[c++] = b[j++];
		}
		return temp;
	}
	
	static long MOD=1000000007;
	




//	for(int i=2;i<=100000;i++) {
		
	
}