/* $Id: RegexRulesTestCase.java 1212599 2011-12-09 19:46:42Z simonetripodi $
    *
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You under the Apache License, Version 2.0
    * (the "License"); you may not use this file except in compliance with
    * the License.  You may obtain a copy of the License at
    *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package org.apache.commons.digester3;
  
  import static org.junit.Assert.assertEquals;
  
  import java.util.List;
  
  import org.apache.commons.digester3.RegexMatcher;
  import org.apache.commons.digester3.RegexRules;
  import org.apache.commons.digester3.Rule;
  import org.apache.commons.digester3.SimpleRegexMatcher;
  import org.junit.Test;
  
  /**
   * Test case for RegexRules
   *
   * @author Robert Burrell Donkin
   */
  public class RegexRulesTestCase
  {
  
      /** Test regex that matches everything */
      @Test
      public void testMatchAll()
      {
          // set up which should match every rule
          RegexRules rules = new RegexRules( new RegexMatcher()
          {
              @Override
              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<Rule> matches = rules.match( "", "x/g/e", null, null );
          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", null, null );
          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 matcher that matches nothing */
      @Test
      public void testMatchNothing()
      {
          // set up which should match every rule
          RegexRules rules = new RegexRules( new RegexMatcher()
          {
              @Override
              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<Rule> matches = rules.match( "", "/b/c", null, null );
          assertEquals( "Wrong number of rules returned (1)", 0, matches.size() );
  
          matches = rules.match( "", "/b/c/f", null, null );
          assertEquals( "Wrong number of rules returned (2)", 0, matches.size() );
      }
  
      /** Test a mixed regex - in other words, one that sometimes returns true and sometimes false */
     @Test
     public void testMatchMixed()
     {
         // set up which should match every rule
         RegexRules rules = new RegexRules( new RegexMatcher()
         {
             @Override
             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<Rule> matches = rules.match( "", "/match", null, null );
         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", null, null );
         assertEquals( "Wrong Rule (2)", "beta", ( (TestRule) matches.get( 0 ) ).getIdentifier() );
     }
 
     /** Test rules and clear methods */
     @Test
     public void testClear()
     {
         // set up which should match every rule
         RegexRules rules = new RegexRules( new RegexMatcher()
         {
             @Override
             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<Rule> 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", null, null );
         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", null, null );
         assertEquals( "Wrong number of rules returned (4)", 0, matches.size() );
     }
 
     @Test
     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" ) );
     }
 }