public void testParsePredicateWithInvalidString()

in hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/core/TraversalUtilTest.java [176:337]
140 lines of code
1 McCabe index (conditional complexity)

    public void testParsePredicateWithInvalidString() {
        Assert.assertThrows(HugeException.class, () -> {
            TraversalUtil.parsePredicate("what(123)");
        }, e -> {
            Assert.assertEquals("Invalid predicate: what(123)",
                                e.getMessage());
        });

        Assert.assertThrows(HugeException.class, () -> {
            TraversalUtil.parsePredicate("P.what(123)");
        }, e -> {
            Assert.assertEquals("Not support predicate 'what'",
                                e.getMessage());
        });

        Assert.assertThrows(HugeException.class, () -> {
            TraversalUtil.parsePredicate("P .eq(123)");
        }, e -> {
            Assert.assertEquals("Invalid predicate: P .eq(123)",
                                e.getMessage());
        });

        Assert.assertThrows(HugeException.class, () -> {
            TraversalUtil.parsePredicate("P. eq(123)");
        }, e -> {
            Assert.assertEquals("Invalid predicate: P. eq(123)",
                                e.getMessage());
        });

        Assert.assertThrows(HugeException.class, () -> {
            TraversalUtil.parsePredicate("P.eq (123)");
        }, e -> {
            Assert.assertEquals("Invalid predicate: P.eq (123)",
                                e.getMessage());
        });

        Assert.assertThrows(HugeException.class, () -> {
            TraversalUtil.parsePredicate("P.eq(18m)");
        }, e -> {
            Assert.assertEquals("Invalid value '18m', expect a number",
                                e.getMessage());
        });

        Assert.assertThrows(HugeException.class, () -> {
            TraversalUtil.parsePredicate("P.neq(18m)");
        }, e -> {
            Assert.assertEquals("Invalid value '18m', expect a number",
                                e.getMessage());
        });

        Assert.assertThrows(HugeException.class, () -> {
            TraversalUtil.parsePredicate("P.lt(18m)");
        }, e -> {
            Assert.assertEquals("Invalid value '18m', expect a number",
                                e.getMessage());
        });

        Assert.assertThrows(HugeException.class, () -> {
            TraversalUtil.parsePredicate("P.lte(18m)");
        }, e -> {
            Assert.assertEquals("Invalid value '18m', expect a number",
                                e.getMessage());
        });

        Assert.assertThrows(HugeException.class, () -> {
            TraversalUtil.parsePredicate("P.gt(18m)");
        }, e -> {
            Assert.assertEquals("Invalid value '18m', expect a number",
                                e.getMessage());
        });

        Assert.assertThrows(HugeException.class, () -> {
            TraversalUtil.parsePredicate("P.gte(18m)");
        }, e -> {
            Assert.assertEquals("Invalid value '18m', expect a number",
                                e.getMessage());
        });

        Assert.assertThrows(HugeException.class, () -> {
            TraversalUtil.parsePredicate("P.between(18m, 20)");
        }, e -> {
            Assert.assertEquals("Invalid value '18m, 20', " +
                                "expect a list", e.getMessage());
        });

        Assert.assertThrows(HugeException.class, () -> {
            TraversalUtil.parsePredicate("P.between(18, 20m)");
        }, e -> {
            Assert.assertEquals("Invalid value '18, 20m', " +
                                "expect a list", e.getMessage());
        });

        Assert.assertThrows(HugeException.class, () -> {
            TraversalUtil.parsePredicate("P.between(18)");
        }, e -> {
            Assert.assertEquals("Invalid numbers size 1, expect 2",
                                e.getMessage());
        });

        Assert.assertThrows(HugeException.class, () -> {
            TraversalUtil.parsePredicate("P.between(18, 20, 30)");
        }, e -> {
            Assert.assertEquals("Invalid numbers size 3, expect 2",
                                e.getMessage());
        });

        Assert.assertThrows(HugeException.class, () -> {
            TraversalUtil.parsePredicate("P.between(\"18m\", 20)");
        }, e -> {
            Assert.assertEquals("Invalid value '\"18m\", 20', " +
                                "expect a list of number", e.getMessage());
        });

        Assert.assertThrows(HugeException.class, () -> {
            TraversalUtil.parsePredicate("P.inside(18m, 20)");
        }, e -> {
            Assert.assertEquals("Invalid value '18m, 20', " +
                                "expect a list", e.getMessage());
        });

        Assert.assertThrows(HugeException.class, () -> {
            TraversalUtil.parsePredicate("P.inside(\"18m\", 20)");
        }, e -> {
            Assert.assertEquals("Invalid value '\"18m\", 20', " +
                                "expect a list of number", e.getMessage());
        });

        Assert.assertThrows(HugeException.class, () -> {
            TraversalUtil.parsePredicate("P.inside(18)");
        }, e -> {
            Assert.assertEquals("Invalid numbers size 1, expect 2",
                                e.getMessage());
        });

        Assert.assertThrows(HugeException.class, () -> {
            TraversalUtil.parsePredicate("P.outside(18m, 20)");
        }, e -> {
            Assert.assertEquals("Invalid value '18m, 20', " +
                                "expect a list", e.getMessage());
        });

        Assert.assertThrows(HugeException.class, () -> {
            TraversalUtil.parsePredicate("P.outside(\"18m\", 20)");
        }, e -> {
            Assert.assertEquals("Invalid value '\"18m\", 20', " +
                                "expect a list of number", e.getMessage());
        });

        Assert.assertThrows(HugeException.class, () -> {
            TraversalUtil.parsePredicate("P.outside(18)");
        }, e -> {
            Assert.assertEquals("Invalid numbers size 1, expect 2",
                                e.getMessage());
        });

        Assert.assertThrows(HugeException.class, () -> {
            TraversalUtil.parsePredicate("P.within(18m, 20)");
        }, e -> {
            Assert.assertEquals("Invalid value '18m, 20', " +
                                "expect a list", e.getMessage());
        });
    }