@Parameterized.Parameters(name = "{0}.test({1},{2}) = {3}")
    public static Iterable<Object[]> data() {
        final List<Object[]> testCases = new ArrayList<>(Arrays.asList(new Object[][]{
                {Compare.eq, "1", "1", true},
                {Compare.eq, 100, 99, false},
                {Compare.eq, 100, 101, false},
                {Compare.eq, "z", "a", false},
                {Compare.eq, "a", "z", false},
                {Compare.eq, new Object(), new Object(), false},
                {Compare.neq, "1", "1", false},
                {Compare.neq, 100, 99, true},
                {Compare.neq, 100, 101, true},
                {Compare.neq, "z", "a", true},
                {Compare.neq, "a", "z", true},
                {Compare.neq, new Object(), new Object(), true},
                {Compare.gt, "1", "1", false},
                {Compare.gt, 100, 99, true},
                {Compare.gt, 100, 101, false},
                {Compare.gt, "z", "a", true},
                {Compare.gt, "a", "z", false},
                {Compare.lt, "1", "1", false},
                {Compare.lt, 100, 99, false},
                {Compare.lt, 100, 101, true},
                {Compare.lt, "z", "a", false},
                {Compare.lt, "a", "z", true},
                {Compare.gte, "1", "1", true},
                {Compare.gte, 100, 99, true},
                {Compare.gte, 100, 101, false},
                {Compare.gte, "z", "a", true},
                {Compare.gte, "a", "z", false},
                {Compare.lte, "1", "1", true},
                {Compare.lte, 100, 99, false},
                {Compare.lte, 100, 101, true},
                {Compare.lte, "z", "a", false},
                {Compare.lte, "a", "z", true},
                {Compare.lte, new A(), new A(), true},
                {Compare.lte, new B(), new B(), true},
                {Compare.gte, new B(), new C(), true},
                {Compare.lte, new B(), new D(), true},
                {Compare.lte, new C(), new C(), true},
                {Compare.lte, new D(), new D(), true},

                // type promotion
                {Compare.eq,  1, 1.0d, true},
                {Compare.neq, 1, 1.0d, false},
                {Compare.lt,  1, 1.0d, false},
                {Compare.lte, 1, 1.0d, true},
                {Compare.gt,  1, 1.0d, false},
                {Compare.gte, 1, 1.0d, true},

                // Incomparable types produce ERROR
                {Compare.gt,  23, "23", GremlinTypeErrorException.class},
                {Compare.gte, 23, "23", GremlinTypeErrorException.class},
                {Compare.lt,  23, "23", GremlinTypeErrorException.class},
                {Compare.lte, 23, "23", GremlinTypeErrorException.class},
                {Compare.lte, new CompareTest.A(), new CompareTest.B(), GremlinTypeErrorException.class},
                {Compare.lte, new CompareTest.B(), new CompareTest.A(), GremlinTypeErrorException.class},
                {Compare.lte, new CompareTest.C(), new CompareTest.D(), GremlinTypeErrorException.class},
                {Compare.gte, new Object(), new Object(), GremlinTypeErrorException.class},
                {Compare.gte, new Object(), new Object(), GremlinTypeErrorException.class},
                {Compare.gte, new Object(), new Object(), GremlinTypeErrorException.class},

                /*
                 * NaN has pretty much the same comparability behavior against any argument (including itself):
                 * P.eq(NaN, any) = FALSE
                 * P.neq(NaN, any) = TRUE
                 * P.lt/lte/gt/gte(NaN, any) = ERROR -> FALSE
                 */
                {Compare.eq,  NaN, NaN, false},
                {Compare.neq, NaN, NaN, true},
                {Compare.gt,  NaN, NaN, GremlinTypeErrorException.class},
                {Compare.gte, NaN, NaN, GremlinTypeErrorException.class},
                {Compare.lt,  NaN, NaN, GremlinTypeErrorException.class},
                {Compare.lte, NaN, NaN, GremlinTypeErrorException.class},

                {Compare.eq,  NaN, 0, false},
                {Compare.neq, NaN, 0, true},
                {Compare.gt,  NaN, 0, GremlinTypeErrorException.class},
                {Compare.gte, NaN, 0, GremlinTypeErrorException.class},
                {Compare.lt,  NaN, 0, GremlinTypeErrorException.class},
                {Compare.lte, NaN, 0, GremlinTypeErrorException.class},

                {Compare.eq,  NaN, "foo", false},
                {Compare.neq, NaN, "foo", true},
                {Compare.gt,  NaN, "foo", GremlinTypeErrorException.class},
                {Compare.gte, NaN, "foo", GremlinTypeErrorException.class},
                {Compare.lt,  NaN, "foo", GremlinTypeErrorException.class},
                {Compare.lte, NaN, "foo", GremlinTypeErrorException.class},

                /*
                 * We consider null to be in its own type space, and thus not comparable (lt/lte/gt/gte) with
                 * anything other than null:
                 *
                 * P.eq(null, any non-null) = FALSE
                 * P.neq(null, any non-null) = TRUE
                 * P.lt/lte/gt/gte(null, any non-null) = ERROR -> FALSE
                 */
                {Compare.eq,  null, null, true},
                {Compare.neq, null, null, false},
                {Compare.gt,  null, null, false},
                {Compare.gte, null, null, true},
                {Compare.lt,  null, null, false},
                {Compare.lte, null, null, true},

                {Compare.eq,  "foo", null, false},
                {Compare.neq, "foo", null, true},
                {Compare.gt,  "foo", null, GremlinTypeErrorException.class},
                {Compare.gte, "foo", null, GremlinTypeErrorException.class},
                {Compare.lt,  "foo", null, GremlinTypeErrorException.class},
                {Compare.lte, "foo", null, GremlinTypeErrorException.class},

                {Compare.eq,  null, 1, false},
                {Compare.eq,  1, null, false},
                {Compare.neq, null, 1, true},
                {Compare.neq, 1, null, true},
                {Compare.gt,  null, 1, GremlinTypeErrorException.class},
                {Compare.gt,  1, null, GremlinTypeErrorException.class},
                {Compare.gte, null, 1, GremlinTypeErrorException.class},
                {Compare.gte, 1, null, GremlinTypeErrorException.class},
                {Compare.lt,  null, 1, GremlinTypeErrorException.class},
                {Compare.lt,  1, null, GremlinTypeErrorException.class},
                {Compare.lte, null, 1, GremlinTypeErrorException.class},
                {Compare.lte, 1, null, GremlinTypeErrorException.class},

                {Compare.eq,  NaN, null, false},
                {Compare.neq, NaN, null, true},
                {Compare.gt,  NaN, null, GremlinTypeErrorException.class},
                {Compare.gte, NaN, null, GremlinTypeErrorException.class},
                {Compare.lt,  NaN, null, GremlinTypeErrorException.class},
                {Compare.lte, NaN, null, GremlinTypeErrorException.class},

                /*
                 * Collections
                 */
                {Compare.eq, asList(0), asList(0), true},
                {Compare.neq, asList(0), asList(0), false},
                {Compare.lt, asList(0), asList(0), false},
                {Compare.lte, asList(0), asList(0), true},
                {Compare.gt, asList(0), asList(0), false},
                {Compare.gte, asList(0), asList(0), true},

                {Compare.eq, asList(0), asList(1), false},
                {Compare.neq, asList(0), asList(1), true},
                {Compare.lt, asList(0), asList(1), true},
                {Compare.lte, asList(0), asList(1), true},
                {Compare.gt, asList(0), asList(1), false},
                {Compare.gte, asList(0), asList(1), false},

                {Compare.eq, asList(1,2,3), asList(1,2,4), false},
                {Compare.neq, asList(1,2,3), asList(1,2,4), true},
                {Compare.lt, asList(1,2,3), asList(1,2,4), true},
                {Compare.lte, asList(1,2,3), asList(1,2,4), true},
                {Compare.gt, asList(1,2,3), asList(1,2,4), false},
                {Compare.gte, asList(1,2,3), asList(1,2,4), false},

                {Compare.eq, asList(Double.NaN), asList(Double.NaN), false},
                {Compare.neq, asList(Double.NaN), asList(Double.NaN), true},
                {Compare.lt, asList(Double.NaN), asList(Double.NaN), GremlinTypeErrorException.class},
                {Compare.lte, asList(Double.NaN), asList(Double.NaN), GremlinTypeErrorException.class},
                {Compare.gt, asList(Double.NaN), asList(Double.NaN), GremlinTypeErrorException.class},
                {Compare.gte, asList(Double.NaN), asList(Double.NaN), GremlinTypeErrorException.class},

                {Compare.eq, asList(Double.NaN), asList(0), false},
                {Compare.neq, asList(Double.NaN), asList(0), true},
                {Compare.lt, asList(Double.NaN), asList(0), GremlinTypeErrorException.class},
                {Compare.lte, asList(Double.NaN), asList(0), GremlinTypeErrorException.class},
                {Compare.gt, asList(Double.NaN), asList(0), GremlinTypeErrorException.class},
                {Compare.gte, asList(Double.NaN), asList(0), GremlinTypeErrorException.class},

                {Compare.eq, asMap(1, 1), asMap(1, null), false},
                {Compare.neq, asMap(1, 1), asMap(1, null), true},
                {Compare.lt, asMap(1, 1), asMap(1, null), GremlinTypeErrorException.class},
                {Compare.lte, asMap(1, 1), asMap(1, null), GremlinTypeErrorException.class},
                {Compare.gt, asMap(1, 1), asMap(1, null), GremlinTypeErrorException.class},
                {Compare.gte, asMap(1, 1), asMap(1, null), GremlinTypeErrorException.class},

                {Compare.eq, asList(0), asList("foo"), false},
                {Compare.neq, asList(0), asList("foo"), true},
                {Compare.lt, asList(0), asList("foo"), GremlinTypeErrorException.class},
                {Compare.lte, asList(0), asList("foo"), GremlinTypeErrorException.class},
                {Compare.gt, asList(0), asList("foo"), GremlinTypeErrorException.class},
                {Compare.gte, asList(0), asList("foo"), GremlinTypeErrorException.class},

                // sets are sorted
                {Compare.eq, asSet(1.0, 2.0), asSet(2, 1), true},
                {Compare.neq, asSet(1.0, 2.0), asSet(2, 1), false},
                {Compare.lt, asSet(1.0, 2.0), asSet(2, 1), false},
                {Compare.lte, asSet(1.0, 2.0), asSet(2, 1), true},
                {Compare.gt, asSet(1.0, 2.0), asSet(2, 1), false},
                {Compare.gte, asSet(1.0, 2.0), asSet(2, 1), true},

                // maps are sorted
                {Compare.eq, asMap(1.0, "foo", 2.0, "bar"), asMap(2, "bar", 1, "foo"), true},
                {Compare.neq, asMap(1.0, "foo", 2.0, "bar"), asMap(2, "bar", 1, "foo"), false},
                {Compare.lt, asMap(1.0, "foo", 2.0, "bar"), asMap(2, "bar", 1, "foo"), false},
                {Compare.lte, asMap(1.0, "foo", 2.0, "bar"), asMap(2, "bar", 1, "foo"), true},
                {Compare.gt, asMap(1.0, "foo", 2.0, "bar"), asMap(2, "bar", 1, "foo"), false},
                {Compare.gte, asMap(1.0, "foo", 2.0, "bar"), asMap(2, "bar", 1, "foo"), true},

        }));
        // Compare Numbers of mixed types.
        final List<Object> one = Arrays.asList(1, 1l, 1d, 1f, BigDecimal.ONE, BigInteger.ONE);
        for (Object i : one) {
            for (Object j : one) {
                testCases.addAll(Arrays.asList(new Object[][]{
                        {Compare.eq, i, j, true},
                        {Compare.neq, i, j, false},
                        {Compare.gt, i, j, false},
                        {Compare.lt, i, j, false},
                        {Compare.gte, i, j, true},
                        {Compare.lte, i, j, true},
                }));
            }
        }
        // Compare large numbers of different types that cannot convert to doubles losslessly.
        final BigInteger big1 = new BigInteger("123456789012345678901234567890");
        final BigDecimal big1d = new BigDecimal("123456789012345678901234567890");
        final BigDecimal big2 = new BigDecimal(big1.add(BigInteger.ONE));
        testCases.addAll(Arrays.asList(new Object[][]{
                // big1 == big1d
                {Compare.eq, big1, big1d, true},
                {Compare.neq, big1, big1d, false},
                {Compare.gt, big1, big1d, false},
                {Compare.lt, big1, big1d, false},
                {Compare.gte, big1, big1d, true},
                {Compare.lte, big1, big1d, true},
                // big1 < big2
                {Compare.eq, big1, big2, false},
                {Compare.neq, big1, big2, true},
                {Compare.gt, big1, big2, false},
                {Compare.lt, big1, big2, true},
                {Compare.gte, big1, big2, false},
                {Compare.lte, big1, big2, true},
                // Reverse the operands for symmetric test coverage (big2 > big1)
                {Compare.eq, big2, big1, false},
                {Compare.neq, big2, big1, true},
                {Compare.gt, big2, big1, true},
                {Compare.lt, big2, big1, false},
                {Compare.gte, big2, big1, true},
                {Compare.lte, big2, big1, false},
        }));

        // Compare bigdecimal numbers with double infinite
        final BigDecimal big500 = new BigDecimal("500.00");

        final Double doubleInfinite = Double.POSITIVE_INFINITY;
        testCases.addAll(Arrays.asList(new Object[][]{
            // big500 - doubleInfinite
            {Compare.eq, big500, doubleInfinite, false},
            {Compare.neq, big500, doubleInfinite, true},
            {Compare.gt, big500, doubleInfinite, false},
            {Compare.lt, big500, doubleInfinite, true},
            {Compare.gte, big500, doubleInfinite, false},
            {Compare.lte, big500, doubleInfinite, true},
            // doubleInfinite - big500
            {Compare.eq, doubleInfinite, big500, false},
            {Compare.neq, doubleInfinite, big500, true},
            {Compare.gt, doubleInfinite, big500, true},
            {Compare.lt, doubleInfinite, big500, false},
            {Compare.gte, doubleInfinite, big500, true},
            {Compare.lte, doubleInfinite, big500, false},
        }));

        // Compare bigdecimal numbers with float infinite
        final Float floatInfinite = Float.POSITIVE_INFINITY;
        testCases.addAll(Arrays.asList(new Object[][]{
            // big500 - floatInfinite
            {Compare.eq, big500, floatInfinite, false},
            {Compare.neq, big500, floatInfinite, true},
            {Compare.gt, big500, floatInfinite, false},
            {Compare.lt, big500, floatInfinite, true},
            {Compare.gte, big500, floatInfinite, false},
            {Compare.lte, big500, floatInfinite, true},
            // floatInfinite - big500
            {Compare.eq, floatInfinite, big500, false},
            {Compare.neq, floatInfinite, big500, true},
            {Compare.gt, floatInfinite, big500, true},
            {Compare.lt, floatInfinite, big500, false},
            {Compare.gte, floatInfinite, big500, true},
            {Compare.lte, floatInfinite, big500, false},
        }));

        final Double doubleNegativeInfinite = Double.NEGATIVE_INFINITY;
        testCases.addAll(Arrays.asList(new Object[][]{
            // big500 - doubleNegativeInfinite
            {Compare.eq, big500, doubleNegativeInfinite, false},
            {Compare.neq, big500, doubleNegativeInfinite, true},
            {Compare.gt, big500, doubleNegativeInfinite, true},
            {Compare.lt, big500, doubleNegativeInfinite, false},
            {Compare.gte, big500, doubleNegativeInfinite, true},
            {Compare.lte, big500, doubleNegativeInfinite, false},
            // doubleNegativeInfinite - big500
            {Compare.eq, doubleNegativeInfinite, big500, false},
            {Compare.neq, doubleNegativeInfinite, big500, true},
            {Compare.gt, doubleNegativeInfinite, big500, false},
            {Compare.lt, doubleNegativeInfinite, big500, true},
            {Compare.gte, doubleNegativeInfinite, big500, false},
            {Compare.lte, doubleNegativeInfinite, big500, true},
        }));

        // Compare bigdecimal numbers with float infinite
        final Float floatNegativeInfinite = Float.NEGATIVE_INFINITY;
        testCases.addAll(Arrays.asList(new Object[][]{
            // big500 - floatNegativeInfinite
            {Compare.eq, big500, floatNegativeInfinite, false},
            {Compare.neq, big500, floatNegativeInfinite, true},
            {Compare.gt, big500, floatNegativeInfinite, true},
            {Compare.lt, big500, floatNegativeInfinite, false},
            {Compare.gte, big500, floatNegativeInfinite, true},
            {Compare.lte, big500, floatNegativeInfinite, false},
            // floatNegativeInfinite - big500
            {Compare.eq, floatNegativeInfinite, big500, false},
            {Compare.neq, floatNegativeInfinite, big500, true},
            {Compare.gt, floatNegativeInfinite, big500, false},
            {Compare.lt, floatNegativeInfinite, big500, true},
            {Compare.gte, floatNegativeInfinite, big500, false},
            {Compare.lte, floatNegativeInfinite, big500, true},
        }));

        return testCases;
    }
@author Stephen Mallette (http://stephen.genoprime.com)
@author Matt Frantz (http://github.com/mhfrantz)
gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/CompareTest.java