import java.util.*;
import java.io.*;
import static java.lang.Math.*;

public class Main implements Runnable
{
    boolean multiple = true;

    @SuppressWarnings("Duplicates")
    void solve() throws Exception
    {
        int n = sc.nextInt();
        int[] arr = new int[n];
        for (int I = 0; I < n; I++)
            arr[I] = sc.nextInt();

        ArrayList<Node> list = new ArrayList<>();
        list.add(new Node(arr[0]));
        for (int i = 1; i < n; i++)
        {
            if (arr[i] == arr[i - 1])
                list.get(list.size() - 1).total++;
            else
                list.add(new Node(arr[i]));
        }

        if (list.size() < 4)
        {
            System.out.println("0 0 0");
            return;
        }

//        for (Node node : list)
//        {
//            System.out.println(node.total);
//        }

        int g = list.get(0).total, s = list.get(1).total;

        int ptr = 2;

        while (g >= s)
        {
            if (ptr >= list.size())
            {
                System.out.println("0 0 0");
                return;
            }

            s += list.get(ptr).total;
            ptr++;
        }

        int b = 0;

        while (g >= b)
        {
            if (ptr >= list.size())
            {
                System.out.println("0 0 0");
                return;
            }

            b += list.get(ptr).total;
            ptr++;
        }

        if (g + s + b > n / 2)
        {
//            System.out.println("what");
//            System.out.println(g + " " + s + " " + b);
            System.out.println("0 0 0");
            return;
        }

        while (ptr < list.size() && g + s + b + list.get(ptr).total <= n / 2)
        {
            b += list.get(ptr).total;
            ptr++;
        }

        System.out.println(g + " " + s + " " + b);
    }

    long inv(long a, long b)
    {
        return 1 < a ? b - inv(b % a, a) * b / a : 1;
    }

    long gcd(long a, long b)
    {
        return a == 0 ? b : gcd(b % a, a);
    }

    class Node implements Comparable<Node>
    {
        int score, total = 1;

        Node(int i)
        {
            score = i;
        }

        @Override
        public int compareTo(Node o)
        {
            return Integer.compare(score, o.score);
        }
    }

    void print(int[] arr)
    {
        for (int i = 0; i < arr.length; i++)
            System.out.print(arr[i] + " ");
        System.out.println();
    }

    @Override
    public void run()
    {
        try
        {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
            sc = new FastScanner(in);
            if (multiple)
            {
                int q = sc.nextInt();
                for (int i = 0; i < q; i++)
                    solve();
            }
            else
                solve();
        }
        catch (Throwable uncaught)
        {
            Main.uncaught = uncaught;
        }
        finally
        {
            out.close();
        }
    }

    public static void main(String[] args) throws Throwable
    {
        Thread thread = new Thread(null, new Main(), "", (1 << 26));
        thread.start();
        thread.join();
        if (Main.uncaught != null) {
            throw Main.uncaught;
        }
    }

    static Throwable uncaught; BufferedReader in; FastScanner sc; PrintWriter out;
}

class FastScanner
{
    BufferedReader in;
    StringTokenizer st;

    public FastScanner(BufferedReader in)
    {
        this.in = in;
    }

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

    public int nextInt() throws Exception {
        return Integer.parseInt(nextToken());
    }

    public long nextLong() throws Exception {
        return Long.parseLong(nextToken());
    }

    public double nextDouble() throws Exception {
        return Double.parseDouble(nextToken());
    }
}