Are all brackets matched?

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;

public class Program
{
    public static void Main()
    {
        Console.WriteLine("Testing Started");
        Test(Tuple.Create("A", "B"));
        Test(Tuple.Create("A", "B"), Tuple.Create("C", "D"), Tuple.Create("E", "F"));
        Test(Tuple.Create(true, false));
        Test(Tuple.Create(new { Bracket = "Open" }, new { Bracket = "Close" }));
        Console.WriteLine("Testing Finished");
        Console.ReadLine();
    }

    public static void Test<T>(params Tuple<T, T>[] brackets)
    {
        Debug.Assert(brackets != null);
        Action<IEnumerable<T>> AssertT = d =>
           {
               if (!AreBracketsClosed(d, brackets) || !AreBracketsClosedReordered(d, brackets))
                   Debug.Assert(false); //insert breakpoint
           };
        Action<IEnumerable<T>> AssertF = d =>
           {
               if (AreBracketsClosed(d, brackets) || AreBracketsClosedReordered(d, brackets))
                   Debug.Assert(false); //insert breakpoint
           };

        AssertT(Enumerable.Empty<T>());
        AssertT(null);

        foreach (var b in brackets)
        {
            AssertF(new[] { b.Item2, b.Item1 });
            AssertT(new[] { b.Item1, b.Item2 });
        }

        AssertT(brackets.SelectMany(b => new[] { b.Item1, b.Item2 }));

        AssertT(Enumerable.Range(0, 10000000)
                .Select(i => brackets[0].Item1)
            .Concat(Enumerable.Range(0, 10000000)
                .Select(i => brackets[0].Item2)));

    }

    public static bool AreBracketsClosed<T>(IEnumerable<T> data, params Tuple<T, T>[] brackets)
    {
        return brackets.All(b => AreBracketsClosed(data, b.Item1, b.Item2));
    }

    public static bool AreBracketsClosed<T>(IEnumerable<T> data, T openBracket, T closeBracket)
    {
        if (data == null ||
            EqualityComparer<T>.Default.Equals(openBracket, closeBracket))
            return true;

        int count = 0;
        foreach (var d in data)
            if (EqualityComparer<T>.Default.Equals(d, openBracket)) count++;
            else if (EqualityComparer<T>.Default.Equals(d, closeBracket))
                if (--count < 0) return false;
        return count == 0;
    }

    public static bool AreBracketsClosedReordered<T>(IEnumerable<T> data, params Tuple<T, T>[] inBrackets)
    {
        if (data == null) return true;

        var brackets = inBrackets
                      .Where(b => !EqualityComparer<T>.Default.Equals(b.Item1, b.Item2))
                      .ToArray();

        if (brackets.Length == 0) return true;
        var bracketCount = new int[brackets.Length];
        foreach (var d in data)
            for (int i = 0; i < brackets.Length; i++)
                if (EqualityComparer<T>.Default.Equals(d, brackets[i].Item1)) bracketCount[i]++;
                else if (EqualityComparer<T>.Default.Equals(d, brackets[i].Item2))
                    if (--bracketCount[i] < 0) return false;
        return bracketCount.All(i => i == 0);
    }
}