/* * 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.configuration2.tree.xpath; import java.util.ArrayList; import java.util.List; import org.apache.commons.configuration2.tree.ImmutableNode; import org.apache.commons.configuration2.tree.InMemoryNodeModel; import org.apache.commons.configuration2.tree.NodeHandler; import org.apache.commons.jxpath.ri.model.NodeIterator; import org.apache.commons.jxpath.ri.model.NodePointer; import org.junit.After; import org.junit.Before; /** * A base class for testing classes of the XPath package. This base class * creates a hierarchy of nodes in its setUp() method that can be used for test * cases. * */ public abstract class AbstractXPathTest { /** Constant for the name of the counter attribute. */ protected static final String ATTR_NAME = "counter"; /** Constant for a name of an attribute of the root node. */ protected static final String ATTR_ROOT = "rootAttr"; /** Constant for the name of the first child. */ protected static final String CHILD_NAME1 = "subNode"; /** Constant for the name of the second child. */ protected static final String CHILD_NAME2 = "childNode"; /** Constant for the number of sub nodes. */ protected static final int CHILD_COUNT = 5; /** Constant for the number of levels in the hierarchy. */ protected static final int LEVEL_COUNT = 3; /** Stores the root node of the hierarchy. */ protected ImmutableNode root; /** The node handler. */ protected NodeHandler<ImmutableNode> handler; @Before public void setUp() throws Exception { root = constructHierarchy(LEVEL_COUNT); handler = new InMemoryNodeModel(root).getNodeHandler(); } /** * Clears the test environment. */ @After public void tearDown() throws Exception { root = null; } /** * Builds up a hierarchy of nodes. Each node has {@code CHILD_COUNT} * child nodes having the names {@code CHILD_NAME1} or * {@code CHILD_NAME2}. Their values are named like their parent * node with an additional index. Each node has an attribute with a counter * value. The root node has a special attribute named {@value #ATTR_ROOT} * with the value {@code true}. * * @param levels the number of levels in the hierarchy * @return the root node of the hierarchy */ protected ImmutableNode constructHierarchy(final int levels) { final ImmutableNode.Builder resultBuilder = new ImmutableNode.Builder(); createLevel(resultBuilder, null, levels); resultBuilder.addAttribute(ATTR_ROOT, String.valueOf(true)); return resultBuilder.create(); } /** * Determines the number of elements contained in the given iterator. * * @param iterator the iterator * @return the number of elements in this iteration */ protected int iteratorSize(final NodeIterator iterator) { int cnt = 0; boolean ok; do { ok = iterator.setPosition(cnt + 1); if (ok) { cnt++; } } while (ok); return cnt; } /** * Returns a list with all node pointers contained in the specified * iteration. * * @param iterator the iterator * @return a list with the node pointers obtained from the iterator */ protected List<NodePointer> iterationElements(final NodeIterator iterator) { final List<NodePointer> result = new ArrayList<>(); for (int pos = 1; iterator.setPosition(pos); pos++) { result.add(iterator.getNodePointer()); } return result; } /** * Recursive helper method for creating a level of the node hierarchy. * * @param parentBuilder the builder for the parent node * @param value the value of the parent node * @param level the level counter */ private void createLevel(final ImmutableNode.Builder parentBuilder, final String value, final int level) { if (level >= 0) { final String prefix = value == null ? "" : value + "."; for (int i = 1; i <= CHILD_COUNT; i++) { final ImmutableNode.Builder childBuilder = new ImmutableNode.Builder(); childBuilder.name(i % 2 == 0 ? CHILD_NAME1 : CHILD_NAME2); final String currentValue = prefix + i; childBuilder.value(currentValue); createLevel(childBuilder, currentValue, level - 1); childBuilder.addAttribute(ATTR_NAME, String.valueOf(i)); parentBuilder.addChild(childBuilder.create()); } } } }