src/test/java/org/apache/commons/configuration2/tree/NodeStructureHelper.java - commons-configuration - Git at Google

 /*
  * 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;

 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;

 import java.util.NoSuchElementException;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

 import org.apache.commons.lang3.StringUtils;

 /**
  * A helper class for tests related to hierarchies of {@code ImmutableNode} objects. This class provides functionality
  * for creating test trees and accessing single nodes. It can be used by various test classes.
  */
 public class NodeStructureHelper {
     /** A pattern for parsing node keys with optional indices. */
     private static final Pattern PAT_KEY_WITH_INDEX = Pattern.compile("(\\w+)\\((\\d+)\\)");

     /** The character for splitting node path elements. */
     private static final String PATH_SEPARATOR = "/";

     /** An array with authors. */
     private static final String[] AUTHORS = {"Shakespeare", "Homer", "Simmons"};

     /** An array with the works of the test authors. */
     private static final String[][] WORKS = {{"Troilus and Cressida", "The Tempest", "A Midsummer Night's Dream"}, {"Ilias"}, {"Ilium", "Hyperion"}};

     /** An array with the personae in the works. */
     private static final String[][][] PERSONAE = {{
         // Works of Shakespeare
         {"Troilus", "Cressidia", "Ajax", "Achilles"}, {"Prospero", "Ariel"}, {"Oberon", "Titania", "Puck"}},
         {
             // Works of Homer
             {"Achilles", "Agamemnon", "Hektor"}},
         {
             // Works of Dan Simmons
             {"Hockenberry", "Achilles"}, {"Shrike", "Moneta", "Consul", "Weintraub"}}};

     /** An array with table names used for the TABLES tree. */
     private static final String[] TABLES = {"users", "documents"};

     /**
      * An array with the names of columns to be used for the TABLES tree.
      */
     private static final String[][] FIELDS = {{"uid", "uname", "firstName", "lastName", "email"},
         {"docid", "name", "creationDate", "authorID", "version", "length"}};

     /** Constant for the author attribute. */
     public static final String ATTR_AUTHOR = "author";

     /** Constant for the original value element in the personae tree. */
     public static final String ELEM_ORG_VALUE = "originalValue";

     /** Constant for the tested attribute. */
     public static final String ATTR_TESTED = "tested";

     /** The root node of the authors tree. */
     public static final ImmutableNode ROOT_AUTHORS_TREE = createAuthorsTree();

     /** The root node of the personae tree. */
     public static final ImmutableNode ROOT_PERSONAE_TREE = createPersonaeTree();

     /** The root node of the TABLES tree. */
     public static final ImmutableNode ROOT_TABLES_TREE = createTablesTree();

     /**
      * Appends a component to a node path. The component is added separated by a path separator.
      *
      * @param path the path
      * @param component the component to be added
      * @return the resulting path
      */
     public static String appendPath(final String path, final String component) {
         final StringBuilder buf = new StringBuilder(StringUtils.length(path) + StringUtils.length(component) + 1);
         buf.append(path).append(PATH_SEPARATOR).append(component);
         return buf.toString();
     }

     /**
      * Returns the name of the author at the given index.
      *
      * @param idx the index
      * @return the name of this author
      */
     public static String author(final int idx) {
         return AUTHORS[idx];
     }

     /**
      * Returns the number of authors.
      *
      * @return the number of authors
      */
     public static int authorsLength() {
         return AUTHORS.length;
     }

     /**
      * Creates a tree with a root node whose children are the test authors. Each other has his works as child nodes. Each
      * work has its personae as children.
      *
      * @return the root node of the authors tree
      */
     private static ImmutableNode createAuthorsTree() {
         final ImmutableNode.Builder rootBuilder = new ImmutableNode.Builder(AUTHORS.length);
         for (int author = 0; author < AUTHORS.length; author++) {
             final ImmutableNode.Builder authorBuilder = new ImmutableNode.Builder();
             authorBuilder.name(AUTHORS[author]);
             for (int work = 0; work < WORKS[author].length; work++) {
                 final ImmutableNode.Builder workBuilder = new ImmutableNode.Builder();
                 workBuilder.name(WORKS[author][work]);
                 for (final String person : PERSONAE[author][work]) {
                     workBuilder.addChild(new ImmutableNode.Builder().name(person).create());
                 }
                 authorBuilder.addChild(workBuilder.create());
             }
             rootBuilder.addChild(authorBuilder.create());
         }
         return rootBuilder.name("authorTree").create();
     }

     /**
      * Helper method for creating a field node with its children. Nodes of this type are used within the tables tree. They
      * define a single column of a table.
      *
      * @param name the name of the field
      * @return the field node
      */
     public static ImmutableNode createFieldNode(final String name) {
         final ImmutableNode.Builder fldBuilder = new ImmutableNode.Builder(1);
         fldBuilder.addChild(createNode("name", name));
         return fldBuilder.name("field").create();
     }

     /**
      * Helper method for creating an immutable node with a name and a value.
      *
      * @param name the node's name
      * @param value the node's value
      * @return the new node
      */
     public static ImmutableNode createNode(final String name, final Object value) {
         return new ImmutableNode.Builder().name(name).value(value).create();
     }

     /**
      * Creates a tree with a root node whose children are the test personae. Each node represents a person and has an
      * attribute pointing to the author who invented this person. There is a single child node for the associated work which
      * has again a child and an attribute.
      *
      * @return the root node of the personae tree
      */
     private static ImmutableNode createPersonaeTree() {
         final ImmutableNode.Builder rootBuilder = new ImmutableNode.Builder();
         for (int author = 0; author < AUTHORS.length; author++) {
             for (int work = 0; work < WORKS[author].length; work++) {
                 for (final String person : PERSONAE[author][work]) {
                     final ImmutableNode orgValue = new ImmutableNode.Builder().name(ELEM_ORG_VALUE).value("yes").addAttribute(ATTR_TESTED, Boolean.FALSE)
                         .create();
                     final ImmutableNode workNode = new ImmutableNode.Builder(1).name(WORKS[author][work]).addChild(orgValue).create();
                     final ImmutableNode personNode = new ImmutableNode.Builder(1).name(person).addAttribute(ATTR_AUTHOR, AUTHORS[author]).addChild(workNode)
                         .create();
                     rootBuilder.addChild(personNode);
                 }
             }
         }
         return rootBuilder.create();
     }

     /**
      * Creates a mock for a resolver.
      *
      * @return the resolver mock
      */
     @SuppressWarnings("unchecked")
     public static NodeKeyResolver<ImmutableNode> createResolverMock() {
         return mock(NodeKeyResolver.class);
     }

     /**
      * Creates a tree with database table data with the following structure:
      *
      * tables table name fields field name field name
      *
      * @return the resulting nodes structure
      */
     private static ImmutableNode createTablesTree() {
         return createTablesTree(TABLES, FIELDS);
     }

     /**
      * Creates as tree with database table data based on the passed in arrays of table names and fields for tables. Works
      * like the method without parameters, but allows defining the data of the structure.
      *
      * @param tables an array with the names of the tables
      * @param fields an array with the fields of the single tables
      * @return the resulting nodes structure
      */
     public static ImmutableNode createTablesTree(final String[] tables, final String[][] fields) {
         final ImmutableNode.Builder bldTables = new ImmutableNode.Builder(tables.length);
         bldTables.name("tables");
         for (int i = 0; i < tables.length; i++) {
             final ImmutableNode.Builder bldTable = new ImmutableNode.Builder(2);
             bldTable.addChild(createNode("name", tables[i]));
             final ImmutableNode.Builder bldFields = new ImmutableNode.Builder(fields[i].length);
             bldFields.name("fields");

             for (int j = 0; j < fields[i].length; j++) {
                 bldFields.addChild(createFieldNode(fields[i][j]));
             }
             bldTable.addChild(bldFields.create());
             bldTables.addChild(bldTable.name("table").create());
         }
         return bldTables.create();
     }

     /**
      * Returns the name of the specified field in the tables tree.
      *
      * @param tabIdx the index of the table
      * @param fldIdx the index of the field
      * @return the name of this field
      */
     public static String field(final int tabIdx, final int fldIdx) {
         return FIELDS[tabIdx][fldIdx];
     }

     /**
      * Returns the number of fields in the test table with the given index.
      *
      * @param tabIdx the index of the table
      * @return the number of fields in this table
      */
     public static int fieldsLength(final int tabIdx) {
         return FIELDS[tabIdx].length;
     }

     /**
      * Helper method for evaluating a single component of a node key.
      *
      * @param parent the current parent node
      * @param components the array with the components of the node key
      * @param currentIdx the index of the current path component
      * @return the found target node
      * @throws NoSuchElementException if the desired node cannot be found
      */
     private static ImmutableNode findNode(final ImmutableNode parent, final String[] components, final int currentIdx) {
         if (currentIdx >= components.length) {
             return parent;
         }

         final Matcher m = PAT_KEY_WITH_INDEX.matcher(components[currentIdx]);
         final String childName;
         final int childIndex;
         if (m.matches()) {
             childName = m.group(1);
             childIndex = Integer.parseInt(m.group(2));
         } else {
             childName = components[currentIdx];
             childIndex = 0;
         }

         int foundIdx = 0;
         for (final ImmutableNode node : parent) {
             if (childName.equals(node.getNodeName()) && foundIdx++ == childIndex) {
                 return findNode(node, components, currentIdx + 1);
             }
         }
         throw new NoSuchElementException("Cannot resolve child " + components[currentIdx]);
     }

     /**
      * Returns a clone of the array with the table fields. This is useful if a slightly different tree structure should be
      * created.
      *
      * @return the cloned field names
      */
     public static String[][] getClonedFields() {
         final String[][] fieldNamesNew = new String[FIELDS.length][];
         for (int i = 0; i < FIELDS.length; i++) {
             fieldNamesNew[i] = FIELDS[i].clone();
         }
         return fieldNamesNew;
     }

     /**
      * Returns a clone of the array with the table names. This is useful if a slightly different tree structure should be
      * created.
      *
      * @return the cloned table names
      */
     public static String[] getClonedTables() {
         return TABLES.clone();
     }

     /**
      * Evaluates the given key and finds the corresponding child node of the specified root. Keys have the form
      * {@code path/to/node}. If there are multiple sibling nodes with the same name, a numerical index can be specified in
      * parenthesis.
      *
      * @param root the root node
      * @param key the key to the desired node
      * @return the node with this key
      * @throws NoSuchElementException if the key cannot be resolved
      */
     public static ImmutableNode nodeForKey(final ImmutableNode root, final String key) {
         final String[] components = key.split(PATH_SEPARATOR);
         return findNode(root, components, 0);
     }

     /**
      * Evaluates the given key and finds the corresponding child node of the root node of the specified model. This is a
      * convenience method that works like the method with the same name, but obtains the root node from the given model.
      *
      * @param model the node model
      * @param key the key to the desired node
      * @return the found target node
      * @throws NoSuchElementException if the desired node cannot be found
      */
     public static ImmutableNode nodeForKey(final InMemoryNodeModel model, final String key) {
         return nodeForKey(model.getRootNode(), key);
     }

     /**
      * Evaluates the given key and finds the corresponding child node of the root node of the specified {@code NodeHandler}
      * object. This is a convenience method that works like the method with the same name, but obtains the root node from
      * the given handler object.
      *
      * @param handler the {@code NodeHandler} object
      * @param key the key to the desired node
      * @return the found target node
      * @throws NoSuchElementException if the desired node cannot be found
      */
     public static ImmutableNode nodeForKey(final NodeHandler<ImmutableNode> handler, final String key) {
         return nodeForKey(handler.getRootNode(), key);
     }

     /**
      * Convenience method for creating a path for accessing a node based on the node names.
      *
      * @param path an array with the expected node names on the path
      * @return the resulting path as string
      */
     public static String nodePath(final String... path) {
         return StringUtils.join(path, PATH_SEPARATOR);
     }

     /**
      * Convenience method for creating a node path with a special end node.
      *
      * @param endNode the name of the last path component
      * @param path an array with the expected node names on the path
      * @return the resulting path as string
      */
     public static String nodePathWithEndNode(final String endNode, final String... path) {
         return nodePath(path) + PATH_SEPARATOR + endNode;
     }

     /**
      * Returns the name of a persona.
      *
      * @param authorIdx the author index
      * @param workIdx the index of the work
      * @param personaIdx the index of the persona
      * @return the name of this persona
      */
     public static String persona(final int authorIdx, final int workIdx, final int personaIdx) {
         return PERSONAE[authorIdx][workIdx][personaIdx];
     }

     /**
      * Returns the number of personae in the given work of the specified author.
      *
      * @param authorIdx the author index
      * @param workIdx the index of the work
      * @return the number of personae in this work
      */
     public static int personaeLength(final int authorIdx, final int workIdx) {
         return PERSONAE[authorIdx][workIdx].length;
     }

     /**
      * Prepares the passed in resolver mock to resolve add keys. They are interpreted on a default expression engine.
      *
      * @param resolver the {@code NodeKeyResolver} mock
      */
     public static void prepareResolveAddKeys(final NodeKeyResolver<ImmutableNode> resolver) {
         when(resolver.resolveAddKey(any(), any(), any())).then(invocation -> {
             final ImmutableNode root = invocation.getArgument(0, ImmutableNode.class);
             final String key = invocation.getArgument(1, String.class);
             final TreeData handler = invocation.getArgument(2, TreeData.class);
             return DefaultExpressionEngine.INSTANCE.prepareAdd(root, key, handler);
         });
     }

     /**
      * Prepares a mock for a resolver to expect arbitrary resolve operations. These operations are implemented on top of a
      * default expression engine.
      *
      * @param resolver the mock resolver
      */
     @SuppressWarnings("unchecked")
     public static void prepareResolveKeyForQueries(final NodeKeyResolver<ImmutableNode> resolver) {
         when(resolver.resolveKey(any(), any(), any())).thenAnswer(invocation -> {
             final ImmutableNode root = invocation.getArgument(0, ImmutableNode.class);
             final String key = invocation.getArgument(1, String.class);
             final NodeHandler<ImmutableNode> handler = invocation.getArgument(2, NodeHandler.class);
             return DefaultExpressionEngine.INSTANCE.query(root, key, handler);
         });
     }

     /**
      * Returns the name of the test table with the given index.
      *
      * @param idx the index of the table
      * @return the name of the test table with this index
      */
     public static String table(final int idx) {
         return TABLES[idx];
     }

     /**
      * Returns the number of tables in the tables tree.
      *
      * @return the number of tables
      */
     public static int tablesLength() {
         return TABLES.length;
     }

     /**
      * Returns the work of an author with a given index.
      *
      * @param authorIdx the author index
      * @param idx the index of the work
      * @return the desired work
      */
     public static String work(final int authorIdx, final int idx) {
         return WORKS[authorIdx][idx];
     }

     /**
      * Returns the number of works for the author with the given index.
      *
      * @param authorIdx the author index
      * @return the number of works of this author
      */
     public static int worksLength(final int authorIdx) {
         return WORKS[authorIdx].length;
     }
 }
	/*
	* 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;

	import static org.mockito.ArgumentMatchers.any;
	import static org.mockito.Mockito.mock;
	import static org.mockito.Mockito.when;

	import java.util.NoSuchElementException;
	import java.util.regex.Matcher;
	import java.util.regex.Pattern;

	import org.apache.commons.lang3.StringUtils;

	/**
	* A helper class for tests related to hierarchies of {@code ImmutableNode} objects. This class provides functionality
	* for creating test trees and accessing single nodes. It can be used by various test classes.
	*/
	public class NodeStructureHelper {
	/** A pattern for parsing node keys with optional indices. */
	private static final Pattern PAT_KEY_WITH_INDEX = Pattern.compile("(\\w+)\\((\\d+)\\)");

	/** The character for splitting node path elements. */
	private static final String PATH_SEPARATOR = "/";

	/** An array with authors. */
	private static final String[] AUTHORS = {"Shakespeare", "Homer", "Simmons"};

	/** An array with the works of the test authors. */
	private static final String[][] WORKS = {{"Troilus and Cressida", "The Tempest", "A Midsummer Night's Dream"}, {"Ilias"}, {"Ilium", "Hyperion"}};

	/** An array with the personae in the works. */
	private static final String[][][] PERSONAE = {{
	// Works of Shakespeare
	{"Troilus", "Cressidia", "Ajax", "Achilles"}, {"Prospero", "Ariel"}, {"Oberon", "Titania", "Puck"}},
	{
	// Works of Homer
	{"Achilles", "Agamemnon", "Hektor"}},
	{
	// Works of Dan Simmons
	{"Hockenberry", "Achilles"}, {"Shrike", "Moneta", "Consul", "Weintraub"}}};

	/** An array with table names used for the TABLES tree. */
	private static final String[] TABLES = {"users", "documents"};

	/**
	* An array with the names of columns to be used for the TABLES tree.
	*/
	private static final String[][] FIELDS = {{"uid", "uname", "firstName", "lastName", "email"},
	{"docid", "name", "creationDate", "authorID", "version", "length"}};

	/** Constant for the author attribute. */
	public static final String ATTR_AUTHOR = "author";

	/** Constant for the original value element in the personae tree. */
	public static final String ELEM_ORG_VALUE = "originalValue";

	/** Constant for the tested attribute. */
	public static final String ATTR_TESTED = "tested";

	/** The root node of the authors tree. */
	public static final ImmutableNode ROOT_AUTHORS_TREE = createAuthorsTree();

	/** The root node of the personae tree. */
	public static final ImmutableNode ROOT_PERSONAE_TREE = createPersonaeTree();

	/** The root node of the TABLES tree. */
	public static final ImmutableNode ROOT_TABLES_TREE = createTablesTree();

	/**
	* Appends a component to a node path. The component is added separated by a path separator.
	*
	* @param path the path
	* @param component the component to be added
	* @return the resulting path
	*/
	public static String appendPath(final String path, final String component) {
	final StringBuilder buf = new StringBuilder(StringUtils.length(path) + StringUtils.length(component) + 1);
	buf.append(path).append(PATH_SEPARATOR).append(component);
	return buf.toString();
	}

	/**
	* Returns the name of the author at the given index.
	*
	* @param idx the index
	* @return the name of this author
	*/
	public static String author(final int idx) {
	return AUTHORS[idx];
	}

	/**
	* Returns the number of authors.
	*
	* @return the number of authors
	*/
	public static int authorsLength() {
	return AUTHORS.length;
	}

	/**
	* Creates a tree with a root node whose children are the test authors. Each other has his works as child nodes. Each
	* work has its personae as children.
	*
	* @return the root node of the authors tree
	*/
	private static ImmutableNode createAuthorsTree() {
	final ImmutableNode.Builder rootBuilder = new ImmutableNode.Builder(AUTHORS.length);
	for (int author = 0; author < AUTHORS.length; author++) {
	final ImmutableNode.Builder authorBuilder = new ImmutableNode.Builder();
	authorBuilder.name(AUTHORS[author]);
	for (int work = 0; work < WORKS[author].length; work++) {
	final ImmutableNode.Builder workBuilder = new ImmutableNode.Builder();
	workBuilder.name(WORKS[author][work]);
	for (final String person : PERSONAE[author][work]) {
	workBuilder.addChild(new ImmutableNode.Builder().name(person).create());
	}
	authorBuilder.addChild(workBuilder.create());
	}
	rootBuilder.addChild(authorBuilder.create());
	}
	return rootBuilder.name("authorTree").create();
	}

	/**
	* Helper method for creating a field node with its children. Nodes of this type are used within the tables tree. They
	* define a single column of a table.
	*
	* @param name the name of the field
	* @return the field node
	*/
	public static ImmutableNode createFieldNode(final String name) {
	final ImmutableNode.Builder fldBuilder = new ImmutableNode.Builder(1);
	fldBuilder.addChild(createNode("name", name));
	return fldBuilder.name("field").create();
	}

	/**
	* Helper method for creating an immutable node with a name and a value.
	*
	* @param name the node's name
	* @param value the node's value
	* @return the new node
	*/
	public static ImmutableNode createNode(final String name, final Object value) {
	return new ImmutableNode.Builder().name(name).value(value).create();
	}

	/**
	* Creates a tree with a root node whose children are the test personae. Each node represents a person and has an
	* attribute pointing to the author who invented this person. There is a single child node for the associated work which
	* has again a child and an attribute.
	*
	* @return the root node of the personae tree
	*/
	private static ImmutableNode createPersonaeTree() {
	final ImmutableNode.Builder rootBuilder = new ImmutableNode.Builder();
	for (int author = 0; author < AUTHORS.length; author++) {
	for (int work = 0; work < WORKS[author].length; work++) {
	for (final String person : PERSONAE[author][work]) {
	final ImmutableNode orgValue = new ImmutableNode.Builder().name(ELEM_ORG_VALUE).value("yes").addAttribute(ATTR_TESTED, Boolean.FALSE)
	.create();
	final ImmutableNode workNode = new ImmutableNode.Builder(1).name(WORKS[author][work]).addChild(orgValue).create();
	final ImmutableNode personNode = new ImmutableNode.Builder(1).name(person).addAttribute(ATTR_AUTHOR, AUTHORS[author]).addChild(workNode)
	.create();
	rootBuilder.addChild(personNode);
	}
	}
	}
	return rootBuilder.create();
	}

	/**
	* Creates a mock for a resolver.
	*
	* @return the resolver mock
	*/
	@SuppressWarnings("unchecked")
	public static NodeKeyResolver<ImmutableNode> createResolverMock() {
	return mock(NodeKeyResolver.class);
	}

	/**
	* Creates a tree with database table data with the following structure:
	*
	* tables table name fields field name field name
	*
	* @return the resulting nodes structure
	*/
	private static ImmutableNode createTablesTree() {
	return createTablesTree(TABLES, FIELDS);
	}

	/**
	* Creates as tree with database table data based on the passed in arrays of table names and fields for tables. Works
	* like the method without parameters, but allows defining the data of the structure.
	*
	* @param tables an array with the names of the tables
	* @param fields an array with the fields of the single tables
	* @return the resulting nodes structure
	*/
	public static ImmutableNode createTablesTree(final String[] tables, final String[][] fields) {
	final ImmutableNode.Builder bldTables = new ImmutableNode.Builder(tables.length);
	bldTables.name("tables");
	for (int i = 0; i < tables.length; i++) {
	final ImmutableNode.Builder bldTable = new ImmutableNode.Builder(2);
	bldTable.addChild(createNode("name", tables[i]));
	final ImmutableNode.Builder bldFields = new ImmutableNode.Builder(fields[i].length);
	bldFields.name("fields");

	for (int j = 0; j < fields[i].length; j++) {
	bldFields.addChild(createFieldNode(fields[i][j]));
	}
	bldTable.addChild(bldFields.create());
	bldTables.addChild(bldTable.name("table").create());
	}
	return bldTables.create();
	}

	/**
	* Returns the name of the specified field in the tables tree.
	*
	* @param tabIdx the index of the table
	* @param fldIdx the index of the field
	* @return the name of this field
	*/
	public static String field(final int tabIdx, final int fldIdx) {
	return FIELDS[tabIdx][fldIdx];
	}

	/**
	* Returns the number of fields in the test table with the given index.
	*
	* @param tabIdx the index of the table
	* @return the number of fields in this table
	*/
	public static int fieldsLength(final int tabIdx) {
	return FIELDS[tabIdx].length;
	}

	/**
	* Helper method for evaluating a single component of a node key.
	*
	* @param parent the current parent node
	* @param components the array with the components of the node key
	* @param currentIdx the index of the current path component
	* @return the found target node
	* @throws NoSuchElementException if the desired node cannot be found
	*/
	private static ImmutableNode findNode(final ImmutableNode parent, final String[] components, final int currentIdx) {
	if (currentIdx >= components.length) {
	return parent;
	}

	final Matcher m = PAT_KEY_WITH_INDEX.matcher(components[currentIdx]);
	final String childName;
	final int childIndex;
	if (m.matches()) {
	childName = m.group(1);
	childIndex = Integer.parseInt(m.group(2));
	} else {
	childName = components[currentIdx];
	childIndex = 0;
	}

	int foundIdx = 0;
	for (final ImmutableNode node : parent) {
	if (childName.equals(node.getNodeName()) && foundIdx++ == childIndex) {
	return findNode(node, components, currentIdx + 1);
	}
	}
	throw new NoSuchElementException("Cannot resolve child " + components[currentIdx]);
	}

	/**
	* Returns a clone of the array with the table fields. This is useful if a slightly different tree structure should be
	* created.
	*
	* @return the cloned field names
	*/
	public static String[][] getClonedFields() {
	final String[][] fieldNamesNew = new String[FIELDS.length][];
	for (int i = 0; i < FIELDS.length; i++) {
	fieldNamesNew[i] = FIELDS[i].clone();
	}
	return fieldNamesNew;
	}

	/**
	* Returns a clone of the array with the table names. This is useful if a slightly different tree structure should be
	* created.
	*
	* @return the cloned table names
	*/
	public static String[] getClonedTables() {
	return TABLES.clone();
	}

	/**
	* Evaluates the given key and finds the corresponding child node of the specified root. Keys have the form
	* {@code path/to/node}. If there are multiple sibling nodes with the same name, a numerical index can be specified in
	* parenthesis.
	*
	* @param root the root node
	* @param key the key to the desired node
	* @return the node with this key
	* @throws NoSuchElementException if the key cannot be resolved
	*/
	public static ImmutableNode nodeForKey(final ImmutableNode root, final String key) {
	final String[] components = key.split(PATH_SEPARATOR);
	return findNode(root, components, 0);
	}

	/**
	* Evaluates the given key and finds the corresponding child node of the root node of the specified model. This is a
	* convenience method that works like the method with the same name, but obtains the root node from the given model.
	*
	* @param model the node model
	* @param key the key to the desired node
	* @return the found target node
	* @throws NoSuchElementException if the desired node cannot be found
	*/
	public static ImmutableNode nodeForKey(final InMemoryNodeModel model, final String key) {
	return nodeForKey(model.getRootNode(), key);
	}

	/**
	* Evaluates the given key and finds the corresponding child node of the root node of the specified {@code NodeHandler}
	* object. This is a convenience method that works like the method with the same name, but obtains the root node from
	* the given handler object.
	*
	* @param handler the {@code NodeHandler} object
	* @param key the key to the desired node
	* @return the found target node
	* @throws NoSuchElementException if the desired node cannot be found
	*/
	public static ImmutableNode nodeForKey(final NodeHandler<ImmutableNode> handler, final String key) {
	return nodeForKey(handler.getRootNode(), key);
	}

	/**
	* Convenience method for creating a path for accessing a node based on the node names.
	*
	* @param path an array with the expected node names on the path
	* @return the resulting path as string
	*/
	public static String nodePath(final String... path) {
	return StringUtils.join(path, PATH_SEPARATOR);
	}

	/**
	* Convenience method for creating a node path with a special end node.
	*
	* @param endNode the name of the last path component
	* @param path an array with the expected node names on the path
	* @return the resulting path as string
	*/
	public static String nodePathWithEndNode(final String endNode, final String... path) {
	return nodePath(path) + PATH_SEPARATOR + endNode;
	}

	/**
	* Returns the name of a persona.
	*
	* @param authorIdx the author index
	* @param workIdx the index of the work
	* @param personaIdx the index of the persona
	* @return the name of this persona
	*/
	public static String persona(final int authorIdx, final int workIdx, final int personaIdx) {
	return PERSONAE[authorIdx][workIdx][personaIdx];
	}

	/**
	* Returns the number of personae in the given work of the specified author.
	*
	* @param authorIdx the author index
	* @param workIdx the index of the work
	* @return the number of personae in this work
	*/
	public static int personaeLength(final int authorIdx, final int workIdx) {
	return PERSONAE[authorIdx][workIdx].length;
	}

	/**
	* Prepares the passed in resolver mock to resolve add keys. They are interpreted on a default expression engine.
	*
	* @param resolver the {@code NodeKeyResolver} mock
	*/
	public static void prepareResolveAddKeys(final NodeKeyResolver<ImmutableNode> resolver) {
	when(resolver.resolveAddKey(any(), any(), any())).then(invocation -> {
	final ImmutableNode root = invocation.getArgument(0, ImmutableNode.class);
	final String key = invocation.getArgument(1, String.class);
	final TreeData handler = invocation.getArgument(2, TreeData.class);
	return DefaultExpressionEngine.INSTANCE.prepareAdd(root, key, handler);
	});
	}

	/**
	* Prepares a mock for a resolver to expect arbitrary resolve operations. These operations are implemented on top of a
	* default expression engine.
	*
	* @param resolver the mock resolver
	*/
	@SuppressWarnings("unchecked")
	public static void prepareResolveKeyForQueries(final NodeKeyResolver<ImmutableNode> resolver) {
	when(resolver.resolveKey(any(), any(), any())).thenAnswer(invocation -> {
	final ImmutableNode root = invocation.getArgument(0, ImmutableNode.class);
	final String key = invocation.getArgument(1, String.class);
	final NodeHandler<ImmutableNode> handler = invocation.getArgument(2, NodeHandler.class);
	return DefaultExpressionEngine.INSTANCE.query(root, key, handler);
	});
	}

	/**
	* Returns the name of the test table with the given index.
	*
	* @param idx the index of the table
	* @return the name of the test table with this index
	*/
	public static String table(final int idx) {
	return TABLES[idx];
	}

	/**
	* Returns the number of tables in the tables tree.
	*
	* @return the number of tables
	*/
	public static int tablesLength() {
	return TABLES.length;
	}

	/**
	* Returns the work of an author with a given index.
	*
	* @param authorIdx the author index
	* @param idx the index of the work
	* @return the desired work
	*/
	public static String work(final int authorIdx, final int idx) {
	return WORKS[authorIdx][idx];
	}

	/**
	* Returns the number of works for the author with the given index.
	*
	* @param authorIdx the author index
	* @return the number of works of this author
	*/
	public static int worksLength(final int authorIdx) {
	return WORKS[authorIdx].length;
	}
	}