org.apache.commons.digester: public class: RegexRulesTestCase

org.apache.commons.digester
public class: RegexRulesTestCase [javadoc | source]

java.lang.Object
   junit.framework.TestCase
      org.apache.commons.digester.RegexRulesTestCase

Test case for RegexRules

author: Robert - Burrell Donkin

version: $ - Revision: 155412 $ $Date: 2005-02-27 01:58:36 +1300 (Sun, 27 Feb 2005) $

Constructor:
public RegexRulesTestCase(String name) { super(name); } Base constructor

Constructor:

 public RegexRulesTestCase(String name) {
        super(name);
}

Base constructor

Method from org.apache.commons.digester.RegexRulesTestCase Summary:
testClear, testMatchAll, testMatchMixed, testMatchNothing, testSimpleRegexMatch

Methods from java.lang.Object:
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method from org.apache.commons.digester.RegexRulesTestCase Detail:
public void testClear() { // set up which should match every rule RegexRules rules = new RegexRules( new RegexMatcher() { public boolean match(String pathPattern, String rulePattern) { return true; } }); rules.add("/abba", new TestRule("alpha")); rules.add("/ad/ma", new TestRule("beta")); rules.add("/gamma", new TestRule("gamma")); // check that rules returns all rules in the order which they were added List matches = rules.rules(); assertEquals("Wrong number of rules returned (1)", 3, matches.size()); assertEquals("Rule Out Of Order (1)", "alpha", ((TestRule) matches.get(0)).getIdentifier()); assertEquals("Rule Out Of Order (2)", "beta", ((TestRule) matches.get(1)).getIdentifier()); assertEquals("Rule Out Of Order (3)", "gamma", ((TestRule) matches.get(2)).getIdentifier()); matches = rules.match("", "/eggs"); assertEquals("Wrong number of rules returned (2)", 3, matches.size()); assertEquals("Rule Out Of Order (4)", "alpha", ((TestRule) matches.get(0)).getIdentifier()); assertEquals("Rule Out Of Order (5)", "beta", ((TestRule) matches.get(1)).getIdentifier()); assertEquals("Rule Out Of Order (6)", "gamma", ((TestRule) matches.get(2)).getIdentifier()); rules.clear(); matches = rules.rules(); assertEquals("Wrong number of rules returned (3)", 0, matches.size()); matches = rules.match("", "/eggs"); assertEquals("Wrong number of rules returned (4)", 0, matches.size()); } Test rules and clear methods
public void testMatchAll() { // set up which should match every rule RegexRules rules = new RegexRules( new RegexMatcher() { public boolean match(String pathPattern, String rulePattern) { return true; } }); rules.add("/a/b/b", new TestRule("alpha")); rules.add("/a/d", new TestRule("beta")); rules.add("/b", new TestRule("gamma")); // now test a few patterns // check that all are return in the order which they were added List matches = rules.match("", "x/g/e"); assertEquals("Wrong number of rules returned (1)", 3, matches.size()); assertEquals("Rule Out Of Order (1)", "alpha", ((TestRule) matches.get(0)).getIdentifier()); assertEquals("Rule Out Of Order (2)", "beta", ((TestRule) matches.get(1)).getIdentifier()); assertEquals("Rule Out Of Order (3)", "gamma", ((TestRule) matches.get(2)).getIdentifier()); matches = rules.match("", "/a"); assertEquals("Wrong number of rules returned (2)", 3, matches.size()); assertEquals("Rule Out Of Order (4)", "alpha", ((TestRule) matches.get(0)).getIdentifier()); assertEquals("Rule Out Of Order (5)", "beta", ((TestRule) matches.get(1)).getIdentifier()); assertEquals("Rule Out Of Order (6)", "gamma", ((TestRule) matches.get(2)).getIdentifier()); } Test regex that matches everything
public void testMatchMixed() { // set up which should match every rule RegexRules rules = new RegexRules( new RegexMatcher() { public boolean match(String pathPattern, String rulePattern) { return (rulePattern.equals("/match/me")); } }); rules.add("/match", new TestRule("alpha")); rules.add("/match/me", new TestRule("beta")); rules.add("/match", new TestRule("gamma")); // now test a few patterns // check that all are return in the order which they were added List matches = rules.match("", "/match"); assertEquals("Wrong number of rules returned (1)", 1, matches.size()); assertEquals("Wrong Rule (1)", "beta", ((TestRule) matches.get(0)).getIdentifier()); matches = rules.match("", "/a/match"); assertEquals("Wrong Rule (2)", "beta", ((TestRule) matches.get(0)).getIdentifier()); } Test a mixed regex - in other words, one that sometimes returns true and sometimes false
public void testMatchNothing() { // set up which should match every rule RegexRules rules = new RegexRules( new RegexMatcher() { public boolean match(String pathPattern, String rulePattern) { return false; } }); rules.add("/b/c/f", new TestRule("alpha")); rules.add("/c/f", new TestRule("beta")); rules.add("/b", new TestRule("gamma")); // now test a few patterns // check that all are return in the order which they were added List matches = rules.match("", "/b/c"); assertEquals("Wrong number of rules returned (1)", 0, matches.size()); matches = rules.match("", "/b/c/f"); assertEquals("Wrong number of rules returned (2)", 0, matches.size()); } Test regex matcher that matches nothing
public void testSimpleRegexMatch() { SimpleRegexMatcher matcher = new SimpleRegexMatcher(); // SimpleLog log = new SimpleLog("{testSimpleRegexMatch:SimpleRegexMatcher]"); // log.setLevel(SimpleLog.LOG_LEVEL_TRACE); assertEquals( "Simple Regex Match '/alpha/beta/gamma' to '/alpha/beta/gamma' ", true, matcher.match("/alpha/beta/gamma", "/alpha/beta/gamma")); assertEquals( "Simple Regex Match '/alpha/beta/gamma' to '/alpha/beta/gamma/epsilon' ", false, matcher.match("/alpha/beta/gamma", "/alpha/beta/gamma/epsilon")); assertEquals( "Simple Regex Match '/alpha/beta/gamma' to '/alpha/' ", true, matcher.match("/alpha/beta/gamma", "/alpha/")); assertEquals( "Simple Regex Match '/alpha/beta/gamma' to '/alpha//gamma' ", true, matcher.match("/alpha/beta/gamma", "/alpha//gamma")); assertEquals( "Simple Regex Match '/alpha/beta/gamma' to '/alpha/me' ", false, matcher.match("/alpha/beta/gamma", "/alpha/me")); assertEquals( "Simple Regex Match '/alpha/beta/gamma' to '/beta/gamma' ", true, matcher.match("/alpha/beta/gamma", "/beta/gamma")); assertEquals( "Simple Regex Match '/alpha/beta/gamma' to '/alpha/beta/gamma' ", true, matcher.match("/alpha/beta/gamma", "/alpha/beta/gamma")); assertEquals( "Simple Regex Match '/alpha/beta/gamma' to '/bet/gamma' ", false, matcher.match("/alpha/beta/gamma", "/bet/gamma")); assertEquals( "Simple Regex Match '/alpha/beta/gamma' to 'alph?/beta/gamma' ", true, matcher.match("/alpha/beta/gamma", "/alph?/beta/gamma")); assertEquals( "Simple Regex Match '/alpha/beta/gamma' to '/?lpha/beta/gamma' ", true, matcher.match("/alpha/beta/gamma", "/?lpha/beta/gamma")); assertEquals( "Simple Regex Match '/alpha/beta/gamma' to '/alpha/?beta/gamma' ", false, matcher.match("/alpha/beta/gamma", "/alpha/?beta/gamma")); assertEquals( "Simple Regex Match '/alpha/beta/gamma' to '/alpha/?eta/' ", true, matcher.match("/alpha/beta/gamma", "/alpha/?eta/")); assertEquals( "Simple Regex Match '/alpha/beta/gamma' to '/alpha/?eta/e' ", false, matcher.match("/alpha/beta/gamma", "/alpha/?eta/e")); assertEquals( "Simple Regex Match '/alpha/beta/gamma' to '/?et?/?amma' ", true, matcher.match("/alpha/beta/gamma", "/?et?/?amma")); assertEquals( "Simple Regex Match '/alpha/beta/gamma/beta/epsilon/beta/gamma/epsilon' to " + " '/beta/gamma/?pn' ", true, matcher.match("/alpha/beta/gamma/beta/epsilon/beta/gamma/epsilon", "/beta/gamma/?pn")); assertEquals( "Simple Regex Match '/alpha/beta/gamma/beta/epsilon/beta/gamma/epsilon' to " + " '/beta/gamma/?pno' ", false, matcher.match("/alpha/beta/gamma", "/beta/gamma/?pno")); }

Method from org.apache.commons.digester.RegexRulesTestCase Detail:

 public  void testClear() {
        // set up which should match every rule
        RegexRules rules = new RegexRules(
            new RegexMatcher() {
                public boolean match(String pathPattern, String rulePattern) {
                    return true;
                }
            });
        rules.add("/abba", new TestRule("alpha"));
        rules.add("/ad/ma", new TestRule("beta"));
        rules.add("/gamma", new TestRule("gamma"));
        // check that rules returns all rules in the order which they were added
        List matches = rules.rules();
        assertEquals("Wrong number of rules returned (1)", 3, matches.size());
        assertEquals("Rule Out Of Order (1)", "alpha", ((TestRule) matches.get(0)).getIdentifier());
        assertEquals("Rule Out Of Order (2)", "beta", ((TestRule) matches.get(1)).getIdentifier());
        assertEquals("Rule Out Of Order (3)", "gamma", ((TestRule) matches.get(2)).getIdentifier());
        matches = rules.match("", "/eggs");
        assertEquals("Wrong number of rules returned (2)", 3, matches.size());
        assertEquals("Rule Out Of Order (4)", "alpha", ((TestRule) matches.get(0)).getIdentifier());
        assertEquals("Rule Out Of Order (5)", "beta", ((TestRule) matches.get(1)).getIdentifier());
        assertEquals("Rule Out Of Order (6)", "gamma", ((TestRule) matches.get(2)).getIdentifier());
        rules.clear();
        matches = rules.rules();
        assertEquals("Wrong number of rules returned (3)", 0, matches.size());
        matches = rules.match("", "/eggs");
        assertEquals("Wrong number of rules returned (4)", 0, matches.size());
}

Test rules and clear methods

 public  void testMatchAll() {
        // set up which should match every rule
        RegexRules rules = new RegexRules(
            new RegexMatcher() {
                public boolean match(String pathPattern, String rulePattern) {
                    return true;
                }
            });
        rules.add("/a/b/b", new TestRule("alpha"));
        rules.add("/a/d", new TestRule("beta"));
        rules.add("/b", new TestRule("gamma"));
        // now test a few patterns
        // check that all are return in the order which they were added
        List matches = rules.match("", "x/g/e");
        assertEquals("Wrong number of rules returned (1)", 3, matches.size());
        assertEquals("Rule Out Of Order (1)", "alpha", ((TestRule) matches.get(0)).getIdentifier());
        assertEquals("Rule Out Of Order (2)", "beta", ((TestRule) matches.get(1)).getIdentifier());
        assertEquals("Rule Out Of Order (3)", "gamma", ((TestRule) matches.get(2)).getIdentifier());
        matches = rules.match("", "/a");
        assertEquals("Wrong number of rules returned (2)", 3, matches.size());
        assertEquals("Rule Out Of Order (4)", "alpha", ((TestRule) matches.get(0)).getIdentifier());
        assertEquals("Rule Out Of Order (5)", "beta", ((TestRule) matches.get(1)).getIdentifier());
        assertEquals("Rule Out Of Order (6)", "gamma", ((TestRule) matches.get(2)).getIdentifier());
}

Test regex that matches everything

 public  void testMatchMixed() {
        // set up which should match every rule
        RegexRules rules = new RegexRules(
            new RegexMatcher() {
                public boolean match(String pathPattern, String rulePattern) {
                    return (rulePattern.equals("/match/me"));
                }
            });
        rules.add("/match", new TestRule("alpha"));
        rules.add("/match/me", new TestRule("beta"));
        rules.add("/match", new TestRule("gamma"));
        // now test a few patterns
        // check that all are return in the order which they were added
        List matches = rules.match("", "/match");
        assertEquals("Wrong number of rules returned (1)", 1, matches.size());
        assertEquals("Wrong Rule (1)", "beta", ((TestRule) matches.get(0)).getIdentifier());
        matches = rules.match("", "/a/match");
        assertEquals("Wrong Rule (2)", "beta", ((TestRule) matches.get(0)).getIdentifier());
}

Test a mixed regex - in other words, one that sometimes returns true and sometimes false

 public  void testMatchNothing() {
        // set up which should match every rule
        RegexRules rules = new RegexRules(
            new RegexMatcher() {
                public boolean match(String pathPattern, String rulePattern) {
                    return false;
                }
            });
        rules.add("/b/c/f", new TestRule("alpha"));
        rules.add("/c/f", new TestRule("beta"));
        rules.add("/b", new TestRule("gamma"));
        // now test a few patterns
        // check that all are return in the order which they were added
        List matches = rules.match("", "/b/c");
        assertEquals("Wrong number of rules returned (1)", 0, matches.size());
        matches = rules.match("", "/b/c/f");
        assertEquals("Wrong number of rules returned (2)", 0, matches.size());
}

Test regex matcher that matches nothing

 public  void testSimpleRegexMatch() {
        
        SimpleRegexMatcher matcher = new SimpleRegexMatcher();
//        SimpleLog log = new SimpleLog("{testSimpleRegexMatch:SimpleRegexMatcher]");
//        log.setLevel(SimpleLog.LOG_LEVEL_TRACE);
        assertEquals(
                "Simple Regex Match '/alpha/beta/gamma' to '/alpha/beta/gamma' ", 
                true, 
                matcher.match("/alpha/beta/gamma", "/alpha/beta/gamma"));
        assertEquals(
                "Simple Regex Match '/alpha/beta/gamma' to '/alpha/beta/gamma/epsilon' ", 
                false, 
                matcher.match("/alpha/beta/gamma", "/alpha/beta/gamma/epsilon"));
        assertEquals(
                "Simple Regex Match '/alpha/beta/gamma' to '/alpha/*' ", 
                true, 
                matcher.match("/alpha/beta/gamma", "/alpha/*"));
        assertEquals(
                "Simple Regex Match '/alpha/beta/gamma' to '/alpha/*/gamma' ", 
                true, 
                matcher.match("/alpha/beta/gamma", "/alpha/*/gamma"));
        assertEquals(
                "Simple Regex Match '/alpha/beta/gamma' to '/alpha/*me' ", 
                false, 
                matcher.match("/alpha/beta/gamma", "/alpha/*me"));
        assertEquals(
                "Simple Regex Match '/alpha/beta/gamma' to '*/beta/gamma' ", 
                true, 
                matcher.match("/alpha/beta/gamma", "*/beta/gamma"));
        assertEquals(
                "Simple Regex Match '/alpha/beta/gamma' to '*/alpha/beta/gamma' ", 
                true, 
                matcher.match("/alpha/beta/gamma", "*/alpha/beta/gamma"));
        assertEquals(
                "Simple Regex Match '/alpha/beta/gamma' to '*/bet/gamma' ", 
                false, 
                matcher.match("/alpha/beta/gamma", "*/bet/gamma"));
        assertEquals(
                "Simple Regex Match '/alpha/beta/gamma' to 'alph?/beta/gamma' ", 
                true, 
                matcher.match("/alpha/beta/gamma", "/alph?/beta/gamma"));
        assertEquals(
                "Simple Regex Match '/alpha/beta/gamma' to '/?lpha/beta/gamma' ", 
                true, 
                matcher.match("/alpha/beta/gamma", "/?lpha/beta/gamma"));
        assertEquals(
                "Simple Regex Match '/alpha/beta/gamma' to '/alpha/?beta/gamma' ", 
                false, 
                matcher.match("/alpha/beta/gamma", "/alpha/?beta/gamma"));
        assertEquals(
                "Simple Regex Match '/alpha/beta/gamma' to '/alpha/?eta/*' ", 
                true, 
                matcher.match("/alpha/beta/gamma", "/alpha/?eta/*"));
        assertEquals(
                "Simple Regex Match '/alpha/beta/gamma' to '/alpha/?eta/*e' ", 
                false, 
                matcher.match("/alpha/beta/gamma", "/alpha/?eta/*e"));
        assertEquals(
                "Simple Regex Match '/alpha/beta/gamma' to '*/?et?/?amma' ", 
                true, 
                matcher.match("/alpha/beta/gamma", "*/?et?/?amma"));
        assertEquals(
                "Simple Regex Match '/alpha/beta/gamma/beta/epsilon/beta/gamma/epsilon' to "
                + " '*/beta/gamma/?p*n' ", 
                true, 
                matcher.match("/alpha/beta/gamma/beta/epsilon/beta/gamma/epsilon", "*/beta/gamma/?p*n"));     
        assertEquals(
                "Simple Regex Match '/alpha/beta/gamma/beta/epsilon/beta/gamma/epsilon' to "
                + " '*/beta/gamma/?p*no' ", 
                false, 
                matcher.match("/alpha/beta/gamma", "*/beta/gamma/?p*no"));
}