/* $Id: RulesBaseTestCase.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.Iterator;
  import java.util.List;
  
  import org.apache.commons.digester3.Digester;
  import org.apache.commons.digester3.Rule;
  import org.apache.commons.digester3.Rules;
  import org.apache.commons.digester3.RulesBase;
  import org.junit.After;
  import org.junit.Before;
  import org.junit.Test;
  
  /**
   * <p>
   * Test Case for the RulesBase matching rules. Most of this material was original contained in the digester test case
   * but was moved into this class so that extensions of the basic matching rules behaviour can extend this test case.
   * </p>
   *
   * @author Craig R. McClanahan
   */
  public class RulesBaseTestCase
  {
  
      // ----------------------------------------------------- Instance Variables
  
      /**
       * The digester instance we will be processing.
       */
      protected Digester digester = null;
  
      // -------------------------------------------------- Overall Test Methods
  
      /**
       * Set up instance variables required by this test case.
       */
      @Before
      public void setUp()
      {
  
          digester = new Digester();
          digester.setRules( createMatchingRulesForTest() );
  
      }
  
      /**
       * <p>
       * This should be overriden by subclasses.
       *
       * @return the matching rules to be tested.
       */
      protected Rules createMatchingRulesForTest()
      {
          return new RulesBase();
      }
  
      /**
       * Tear down instance variables required by this test case.
       */
      @After
      public void tearDown()
      {
  
          digester = null;
  
      }
  
      // ------------------------------------------------ Individual Test Methods
  
      /**
       * Basic test for rule creation and matching.
       */
      @Test
      public void testRules()
      {
  
          // clear any existing rules
          digester.getRules().clear();
  
         // perform tests
 
         assertEquals( "Initial rules list is empty", 0, digester.getRules().match( null, "a", null, null ).size() );
         digester.addSetProperties( "a" );
         assertEquals( "Add a matching rule", 1, digester.getRules().match( null, "a", null, null ).size() );
         digester.addSetProperties( "b" );
         assertEquals( "Add a non-matching rule", 1, digester.getRules().match( null, "a", null, null ).size() );
         digester.addSetProperties( "a/b" );
         assertEquals( "Add a non-matching nested rule", 1, digester.getRules().match( null, "a", null, null ).size() );
         digester.addSetProperties( "a/b" );
         assertEquals( "Add a second matching rule", 2, digester.getRules().match( null, "a/b", null, null ).size() );
 
         // clean up
         digester.getRules().clear();
 
     }
 
     /**
      * <p>
      * Test matching rules in {@link RulesBase}.
      * </p>
      * <p>
      * Tests:
      * </p>
      * <ul>
      * <li>exact match</li>
      * <li>tail match</li>
      * <li>longest pattern rule</li>
      * </ul>
      */
     @Test
     public void testRulesBase()
     {
 
         // clear any existing rules
         digester.getRules().clear();
 
         assertEquals( "Initial rules list is empty", 0, digester.getRules().rules().size() );
 
         // We're going to set up
         digester.addRule( "a/b/c/d", new TestRule( "a/b/c/d" ) );
         digester.addRule( "*/d", new TestRule( "*/d" ) );
         digester.addRule( "*/c/d", new TestRule( "*/c/d" ) );
 
         // Test exact match
         assertEquals( "Exact match takes precedence 1", 1, digester.getRules().match( null, "a/b/c/d", null, null ).size() );
         assertEquals( "Exact match takes precedence 2", "a/b/c/d",
                       ( (TestRule) digester.getRules().match( null, "a/b/c/d", null, null ).iterator().next() ).getIdentifier() );
 
         // Test wildcard tail matching
         assertEquals( "Wildcard tail matching rule 1", 1, digester.getRules().match( null, "a/b/d", null, null ).size() );
         assertEquals( "Wildcard tail matching rule 2", "*/d",
                       ( (TestRule) digester.getRules().match( null, "a/b/d", null, null ).iterator().next() ).getIdentifier() );
 
         // Test the longest matching pattern rule
         assertEquals( "Longest tail rule 1", 1, digester.getRules().match( null, "x/c/d", null, null ).size() );
         assertEquals( "Longest tail rule 2", "*/c/d",
                       ( (TestRule) digester.getRules().match( null, "x/c/d", null, null ).iterator().next() ).getIdentifier() );
 
         // Test wildcard tail matching at the top level,
         // i.e. the wildcard is nothing
         digester.addRule( "*/a", new TestRule( "*/a" ) );
         assertEquals( "Wildcard tail matching rule 3", 1, digester.getRules().match( null, "a", null, null ).size() );
 
         assertEquals( "Wildcard tail matching rule 3 (match too much)", 0,
                       digester.getRules().match( null, "aa", null, null ).size() );
         // clean up
         digester.getRules().clear();
 
     }
 
     /**
      * Test basic matchings involving namespaces.
      */
     @Test
     public void testBasicNamespaceMatching()
     {
 
         List<Rule> list = null;
         Iterator<Rule> it = null;
 
         // clear any existing rules
         digester.getRules().clear();
 
         assertEquals( "Initial rules list is empty", 0, digester.getRules().rules().size() );
 
         // Set up rules
         digester.addRule( "alpha/beta/gamma", new TestRule( "No-Namespace" ) );
         digester.addRule( "alpha/beta/gamma", new TestRule( "Euclidean-Namespace", "euclidean" ) );
 
         list = digester.getRules().rules();
 
         // test that matching null namespace brings back namespace and non-namespace rules
         list = digester.getRules().match( null, "alpha/beta/gamma", null, null );
 
         assertEquals( "Null namespace match (A)", 2, list.size() );
 
         it = list.iterator();
         assertEquals( "Null namespace match (B)", "No-Namespace", ( (TestRule) it.next() ).getIdentifier() );
         assertEquals( "Null namespace match (C)", "Euclidean-Namespace", ( (TestRule) it.next() ).getIdentifier() );
 
         // test that matching euclid namespace brings back namespace and non-namespace rules
         list = digester.getRules().match( "euclidean", "alpha/beta/gamma", null, null );
 
         assertEquals( "Matching namespace match (A)", 2, list.size() );
 
         it = list.iterator();
         assertEquals( "Matching namespace match (B)", "No-Namespace", ( (TestRule) it.next() ).getIdentifier() );
         assertEquals( "Matching namespace match (C)", "Euclidean-Namespace", ( (TestRule) it.next() ).getIdentifier() );
 
         // test that matching another namespace brings back only non-namespace rule
         list = digester.getRules().match( "hyperbolic", "alpha/beta/gamma", null, null );
 
         assertEquals( "Non matching namespace match (A)", 1, list.size() );
 
         it = list.iterator();
         assertEquals( "Non matching namespace match (B)", "No-Namespace", ( (TestRule) it.next() ).getIdentifier() );
 
         // clean up
         digester.getRules().clear();
 
     }
 
     /**
      * Rules must always be returned in the correct order.
      */
     @Test
     public void testOrdering()
     {
 
         // clear any existing rules
         digester.getRules().clear();
 
         assertEquals( "Initial rules list is empty", 0, digester.getRules().rules().size() );
 
         // Set up rules
         digester.addRule( "alpha/beta/gamma", new TestRule( "one" ) );
         digester.addRule( "alpha/beta/gamma", new TestRule( "two" ) );
         digester.addRule( "alpha/beta/gamma", new TestRule( "three" ) );
 
         // test that rules are returned in set order
         List<Rule> list = digester.getRules().match( null, "alpha/beta/gamma", null, null );
 
         assertEquals( "Testing ordering mismatch (A)", 3, list.size() );
 
         Iterator<Rule> it = list.iterator();
         assertEquals( "Testing ordering mismatch (B)", "one", ( (TestRule) it.next() ).getIdentifier() );
         assertEquals( "Testing ordering mismatch (C)", "two", ( (TestRule) it.next() ).getIdentifier() );
         assertEquals( "Testing ordering mismatch (D)", "three", ( (TestRule) it.next() ).getIdentifier() );
 
         // clean up
         digester.getRules().clear();
 
     }
 
     /** Tests the behaviour when a rule is added with a trailing slash */
     @Test
     public void testTrailingSlash()
     {
         // clear any existing rules
         digester.getRules().clear();
 
         assertEquals( "Initial rules list is empty", 0, digester.getRules().rules().size() );
 
         // Set up rules
         digester.addRule( "alpha/beta/gamma/", new TestRule( "one" ) );
         digester.addRule( "alpha/beta/", new TestRule( "two" ) );
         digester.addRule( "beta/gamma/alpha", new TestRule( "three" ) );
 
         // test that rules are returned in set order
         List<Rule> list = digester.getRules().match( null, "alpha/beta/gamma", null, null );
 
         assertEquals( "Testing number of matches", 1, list.size() );
 
         Iterator<Rule> it = list.iterator();
         assertEquals( "Testing ordering (A)", "one", ( (TestRule) it.next() ).getIdentifier() );
 
         // clean up
         digester.getRules().clear();
     }
 }