1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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 439648 2006-09-02 20:42:10Z oheger $
32 */
33 public class TestConfigurationNodePointer extends XPathTest
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 }