/** * Verify the pattern string computed for a parsed pattern matches the original pattern text */ private PathPattern checkStructure(String pattern) { PathPattern pp = parse(pattern); assertEquals(pattern, pp.computePatternString()); return pp; }
@Test public void noEncoding() { // Check no encoding of expressions or constraints PathPattern pp = parse("/{var:f o}"); assertEquals("Separator(/) CaptureVariable({var:f o})",pp.toChainString()); pp = parse("/{var:f o}_"); assertEquals("Separator(/) Regex({var:f o}_)",pp.toChainString()); pp = parse("{foo:f o}_ _{bar:b\\|o}"); assertEquals("Regex({foo:f o}_ _{bar:b\\|o})",pp.toChainString()); }
@Test public void patternPropertyGetLengthTests() { // Test all basic section types assertEquals(1, parse("{foo}").getNormalizedLength()); assertEquals(3, parse("foo").getNormalizedLength()); assertEquals(1, parse("{*foobar}").getNormalizedLength()); assertEquals(1, parse("/{*foobar}").getNormalizedLength()); assertEquals(1, parse("/**").getNormalizedLength()); assertEquals(5, parse("{abc}asdf").getNormalizedLength()); assertEquals(3, parse("{abc}_*").getNormalizedLength()); assertEquals(3, parse("{abc}_{def}").getNormalizedLength()); assertEquals(1, parse("/").getNormalizedLength()); assertEquals(3, parse("a?b").getNormalizedLength()); assertEquals(1, parse("*").getNormalizedLength()); // Test on full templates assertEquals(8, parse("/foo/bar").getNormalizedLength()); assertEquals(2, parse("/{foo}").getNormalizedLength()); assertEquals(4, parse("/{foo}/{bar}").getNormalizedLength()); assertEquals(16, parse("/{foo}/{bar}_{goo}_{wibble}/abc/bar").getNormalizedLength()); }
@Test public void patternPropertyGetCaptureCountTests() { // Test all basic section types assertEquals(1, parse("{foo}").getCapturedVariableCount()); assertEquals(0, parse("foo").getCapturedVariableCount()); assertEquals(1, parse("{*foobar}").getCapturedVariableCount()); assertEquals(1, parse("/{*foobar}").getCapturedVariableCount()); assertEquals(0, parse("/**").getCapturedVariableCount()); assertEquals(1, parse("{abc}asdf").getCapturedVariableCount()); assertEquals(1, parse("{abc}_*").getCapturedVariableCount()); assertEquals(2, parse("{abc}_{def}").getCapturedVariableCount()); assertEquals(0, parse("/").getCapturedVariableCount()); assertEquals(0, parse("a?b").getCapturedVariableCount()); assertEquals(0, parse("*").getCapturedVariableCount()); // Test on full templates assertEquals(0, parse("/foo/bar").getCapturedVariableCount()); assertEquals(1, parse("/{foo}").getCapturedVariableCount()); assertEquals(2, parse("/{foo}/{bar}").getCapturedVariableCount()); assertEquals(4, parse("/{foo}/{bar}_{goo}_{wibble}/abc/bar").getCapturedVariableCount()); }
p1 = parse("{a}"); p2 = parse("{a}/{b}"); p3 = parse("{a}/{b}/{c}"); assertEquals(-1, p1.compareTo(p2)); // Based on number of captures List<PathPattern> patterns = new ArrayList<>(); p1 = parse("/a/b/c"); p2 = parse("/a/boo/c/doo"); p3 = parse("/asdjflaksjdfjasdf"); assertEquals(1, p1.compareTo(p2)); patterns = new ArrayList<>(); p1 = parse("/*"); p2 = parse("/*/*"); p3 = parse("/*/*/*_*"); assertEquals(-1, p1.compareTo(p2)); patterns = new ArrayList<>(); p1 = parse("{*foobar}"); p2 = parse("{*goo}"); assertTrue(p1.compareTo(p2) != 0); p1 = parse("/{*foobar}"); p2 = parse("/abc/{*ww}"); assertEquals(+1, p1.compareTo(p2)); assertEquals(-1, p2.compareTo(p1)); p3 = parse("/this/that/theother"); assertTrue(p1.isCatchAll());
@Test public void patternPropertyGetWildcardCountTests() { // Test all basic section types assertEquals(computeScore(1, 0), parse("{foo}").getScore()); assertEquals(computeScore(0, 0), parse("foo").getScore()); assertEquals(computeScore(0, 0), parse("{*foobar}").getScore()); // assertEquals(1,parse("/**").getScore()); assertEquals(computeScore(1, 0), parse("{abc}asdf").getScore()); assertEquals(computeScore(1, 1), parse("{abc}_*").getScore()); assertEquals(computeScore(2, 0), parse("{abc}_{def}").getScore()); assertEquals(computeScore(0, 0), parse("/").getScore()); assertEquals(computeScore(0, 0), parse("a?b").getScore()); // currently deliberate assertEquals(computeScore(0, 1), parse("*").getScore()); // Test on full templates assertEquals(computeScore(0, 0), parse("/foo/bar").getScore()); assertEquals(computeScore(1, 0), parse("/{foo}").getScore()); assertEquals(computeScore(2, 0), parse("/{foo}/{bar}").getScore()); assertEquals(computeScore(4, 0), parse("/{foo}/{bar}_{goo}_{wibble}/abc/bar").getScore()); assertEquals(computeScore(4, 3), parse("/{foo}/*/*_*/{bar}_{goo}_{wibble}/abc/bar").getScore()); }
private void checkError(String pattern, int expectedPos, PatternMessage expectedMessage, String... expectedInserts) { try { pathPattern = parse(pattern); fail("Expected to fail"); } catch (PatternParseException ppe) { assertEquals(ppe.toDetailedString(), expectedPos, ppe.getPosition()); assertEquals(ppe.toDetailedString(), expectedMessage, ppe.getMessageType()); if (expectedInserts.length != 0) { assertEquals(ppe.getInserts().length, expectedInserts.length); for (int i = 0; i < expectedInserts.length; i++) { assertEquals("Insert at position " + i + " is wrong", expectedInserts[i], ppe.getInserts()[i]); } } } }
@Test public void captureTheRestPatterns() { pathPattern = parse("{*foobar}"); assertEquals("/{*foobar}", pathPattern.computePatternString()); assertPathElements(pathPattern, CaptureTheRestPathElement.class); pathPattern = checkStructure("/{*foobar}"); assertPathElements(pathPattern, CaptureTheRestPathElement.class); checkError("/{*foobar}/", 10, PatternMessage.NO_MORE_DATA_EXPECTED_AFTER_CAPTURE_THE_REST); checkError("/{*foobar}abc", 10, PatternMessage.NO_MORE_DATA_EXPECTED_AFTER_CAPTURE_THE_REST); checkError("/{*f%obar}", 4, PatternMessage.ILLEGAL_CHARACTER_IN_CAPTURE_DESCRIPTOR); checkError("/{*foobar}abc", 10, PatternMessage.NO_MORE_DATA_EXPECTED_AFTER_CAPTURE_THE_REST); checkError("/{f*oobar}", 3, PatternMessage.ILLEGAL_CHARACTER_IN_CAPTURE_DESCRIPTOR); checkError("/{*foobar}/abc", 10, PatternMessage.NO_MORE_DATA_EXPECTED_AFTER_CAPTURE_THE_REST); checkError("/{*foobar:.*}/abc", 9, PatternMessage.ILLEGAL_CHARACTER_IN_CAPTURE_DESCRIPTOR); checkError("/{abc}{*foobar}", 1, PatternMessage.CAPTURE_ALL_IS_STANDALONE_CONSTRUCT); checkError("/{abc}{*foobar}{foo}", 15, PatternMessage.NO_MORE_DATA_EXPECTED_AFTER_CAPTURE_THE_REST); }
checkError("/foobar/{abc}_{abc}", 8, PatternMessage.ILLEGAL_DOUBLE_CAPTURE); checkError("/foobar/{abc:..}_{abc:..}", 8, PatternMessage.ILLEGAL_DOUBLE_CAPTURE); PathPattern pp = parse("/{abc:foo(bar)}"); try { pp.matchAndExtract(toPSC("/foo"));