    1   /*
    2    * Licensed to the Apache Software Foundation (ASF) under one or more
    3    * contributor license agreements.  See the NOTICE file distributed with
    4    * this work for additional information regarding copyright ownership.
    5    * The ASF licenses this file to You under the Apache License, Version 2.0
    6    * (the "License"); you may not use this file except in compliance with
    7    * the License.  You may obtain a copy of the License at
    8    *
    9    *     http://www.apache.org/licenses/LICENSE-2.0
    10   *
    11   * Unless required by applicable law or agreed to in writing, software
    12   * distributed under the License is distributed on an "AS IS" BASIS,
    13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    14   * See the License for the specific language governing permissions and
    15   * limitations under the License.
    16   */
    17  package org.apache.commons.configuration.tree.xpath;
    18
    19  import java.util.Locale;
    20
    21  import org.apache.commons.configuration.tree.ConfigurationNode;
    22  import org.apache.commons.configuration.tree.DefaultConfigurationNode;
    23  import org.apache.commons.jxpath.ri.QName;
    24  import org.apache.commons.jxpath.ri.model.NodeIterator;
    25  import org.apache.commons.jxpath.ri.model.NodePointer;
    26
    27  /***
    28   * Test class for ConfigurationNodePointer.
    29   *
    30   * @author Oliver Heger
    31   * @version $Id: TestConfigurationNodePointer.java 502705 2007-02-02 19:55:37Z oheger $
    32   */
    33  public class TestConfigurationNodePointer extends AbstractXPathTest
    34  {
    35      /*** Stores the node pointer to be tested. */
    36      NodePointer pointer;
    37
    38      protected void setUp() throws Exception
    39      {
    40          super.setUp();
    41          pointer = new ConfigurationNodePointer(root, Locale.getDefault());
    42      }
    43
    44      /***
    45       * Tests comparing child node pointers for child nodes.
    46       */
    47      public void testCompareChildNodePointersChildren()
    48      {
    49          NodePointer p1 = new ConfigurationNodePointer(pointer, root.getChild(1));
    50          NodePointer p2 = new ConfigurationNodePointer(pointer, root.getChild(3));
    51          assertEquals("Incorrect order", -1, pointer.compareChildNodePointers(
    52                  p1, p2));
    53          assertEquals("Incorrect symmetric order", 1, pointer
    54                  .compareChildNodePointers(p2, p1));
    55      }
    56
    57      /***
    58       * Tests comparing child node pointers for attribute nodes.
    59       */
    60      public void testCompareChildNodePointersAttributes()
    61      {
    62          root.addAttribute(new DefaultConfigurationNode("attr1", "test1"));
    63          root.addAttribute(new DefaultConfigurationNode("attr2", "test2"));
    64          NodePointer p1 = new ConfigurationNodePointer(pointer, root
    65                  .getAttribute(0));
    66          NodePointer p2 = new ConfigurationNodePointer(pointer, root
    67                  .getAttribute(1));
    68          assertEquals("Incorrect order", -1, pointer.compareChildNodePointers(
    69                  p1, p2));
    70          assertEquals("Incorrect symmetric order", 1, pointer
    71                  .compareChildNodePointers(p2, p1));
    72      }
    73
    74      /***
    75       * tests comparing child node pointers for both child and attribute nodes.
    76       */
    77      public void testCompareChildNodePointersChildAndAttribute()
    78      {
    79          root.addAttribute(new DefaultConfigurationNode("attr1", "test1"));
    80          NodePointer p1 = new ConfigurationNodePointer(pointer, root.getChild(2));
    81          NodePointer p2 = new ConfigurationNodePointer(pointer, root
    82                  .getAttribute(0));
    83          assertEquals("Incorrect order for attributes", 1, pointer
    84                  .compareChildNodePointers(p1, p2));
    85          assertEquals("Incorrect symmetric order for attributes", -1, pointer
    86                  .compareChildNodePointers(p2, p1));
    87      }
    88
    89      /***
    90       * Tests comparing child node pointers for child nodes that do not belong to
    91       * the parent node.
    92       */
    93      public void testCompareChildNodePointersInvalidChildren()
    94      {
    95          ConfigurationNode node = root.getChild(1);
    96          NodePointer p1 = new ConfigurationNodePointer(pointer, node.getChild(1));
    97          NodePointer p2 = new ConfigurationNodePointer(pointer, node.getChild(3));
    98          assertEquals("Non child nodes could be sorted", 0, pointer
    99                  .compareChildNodePointers(p1, p2));
    100         assertEquals("Non child nodes could be sorted symmetrically", 0,
    101                 pointer.compareChildNodePointers(p2, p1));
    102     }
    103
    104     /***
    105      * Tests the attribute flag.
    106      */
    107     public void testIsAttribute()
    108     {
    109         ConfigurationNode node = new DefaultConfigurationNode("test", "testval");
    110         NodePointer p = new ConfigurationNodePointer(pointer, node);
    111         assertFalse("Node is an attribute", p.isAttribute());
    112         node.setAttribute(true);
    113         assertTrue("Node is no attribute", p.isAttribute());
    114     }
    115
    116     /***
    117      * Tests if leaves in the tree are correctly detected.
    118      */
    119     public void testIsLeave()
    120     {
    121         assertFalse("Root node is leaf", pointer.isLeaf());
    122
    123         NodePointer p = pointer;
    124         while (!p.isLeaf())
    125         {
    126             ConfigurationNode node = (ConfigurationNode) p.getNode();
    127             assertTrue("Node has no children", node.getChildrenCount() > 0);
    128             p = new ConfigurationNodePointer(p, node.getChild(0));
    129         }
    130         assertTrue("Node has children", ((ConfigurationNode) p.getNode())
    131                 .getChildrenCount() == 0);
    132     }
    133
    134     /***
    135      * Tests the iterators returned by the node pointer.
    136      */
    137     public void testIterators()
    138     {
    139         checkIterators(pointer);
    140     }
    141
    142     /***
    143      * Recursive helper method for testing the returned iterators.
    144      *
    145      * @param p the node pointer to test
    146      */
    147     private void checkIterators(NodePointer p)
    148     {
    149         ConfigurationNode node = (ConfigurationNode) p.getNode();
    150         NodeIterator it = p.childIterator(null, false, null);
    151         assertEquals("Iterator count differs from children count", node
    152                 .getChildrenCount(), iteratorSize(it));
    153
    154         for (int index = 1; it.setPosition(index); index++)
    155         {
    156             NodePointer pchild = it.getNodePointer();
    157             assertEquals("Wrong child", node.getChild(index - 1), pchild
    158                     .getNode());
    159             checkIterators(pchild);
    160         }
    161
    162         it = p.attributeIterator(new QName(null, "*"));
    163         assertEquals("Iterator count differs from attribute count", node
    164                 .getAttributeCount(), iteratorSize(it));
    165         for (int index = 1; it.setPosition(index); index++)
    166         {
    167             NodePointer pattr = it.getNodePointer();
    168             assertTrue("Node pointer is no attribute", pattr.isAttribute());
    169             assertEquals("Wrong attribute", node.getAttribute(index - 1), pattr
    170                     .getNode());
    171             checkIterators(pattr);
    172         }
    173     }
    174 }