/*
    * 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;
  
  import static org.junit.jupiter.api.Assertions.assertEquals;
  import static org.junit.jupiter.api.Assertions.assertFalse;
  import static org.junit.jupiter.api.Assertions.assertInstanceOf;
  import static org.junit.jupiter.api.Assertions.assertNotEquals;
  import static org.junit.jupiter.api.Assertions.assertNotNull;
  import static org.junit.jupiter.api.Assertions.assertNull;
  import static org.junit.jupiter.api.Assertions.assertSame;
  import static org.junit.jupiter.api.Assertions.assertThrows;
  import static org.junit.jupiter.api.Assertions.assertTrue;
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  import org.apache.commons.configuration2.convert.DefaultListDelimiterHandler;
  import org.apache.commons.configuration2.event.ConfigurationEvent;
  import org.apache.commons.configuration2.event.EventListener;
  import org.apache.commons.configuration2.event.EventListenerTestImpl;
  import org.apache.commons.configuration2.tree.DefaultConfigurationKey;
  import org.apache.commons.configuration2.tree.DefaultExpressionEngine;
  import org.apache.commons.configuration2.tree.DefaultExpressionEngineSymbols;
  import org.apache.commons.configuration2.tree.ExpressionEngine;
  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.configuration2.tree.NodeModel;
  import org.apache.commons.configuration2.tree.NodeStructureHelper;
  import org.junit.jupiter.api.BeforeEach;
  import org.junit.jupiter.api.Test;
  
  /**
   * Test class for {@code AbstractHierarchicalConfiguration}.
   */
  public class TestAbstractHierarchicalConfiguration {
      /**
       * A concrete test implementation of {@code AbstractHierarchicalConfiguration}.
       */
      private static final class AbstractHierarchicalConfigurationTestImpl extends AbstractHierarchicalConfiguration<ImmutableNode> {
          public AbstractHierarchicalConfigurationTestImpl(final InMemoryNodeModel model) {
              super(model);
          }
  
          @Override
          public List<HierarchicalConfiguration<ImmutableNode>> childConfigurationsAt(final String key) {
              throw new UnsupportedOperationException("Unexpected method call!");
          }
  
          @Override
          public List<HierarchicalConfiguration<ImmutableNode>> childConfigurationsAt(final String key, final boolean supportUpdates) {
              throw new UnsupportedOperationException("Unexpected method call!");
          }
  
          @Override
          protected NodeModel<ImmutableNode> cloneNodeModel() {
              return new InMemoryNodeModel(getModel().getNodeHandler().getRootNode());
          }
  
          @Override
          public SubnodeConfiguration configurationAt(final String key) {
              throw new UnsupportedOperationException("Unexpected method call!");
          }
  
          @Override
          public SubnodeConfiguration configurationAt(final String key, final boolean supportUpdates) {
              throw new UnsupportedOperationException("Unexpected method call!");
          }
  
          @Override
          public List<HierarchicalConfiguration<ImmutableNode>> configurationsAt(final String key) {
              throw new UnsupportedOperationException("Unexpected method call!");
          }
  
          @Override
          public List<HierarchicalConfiguration<ImmutableNode>> configurationsAt(final String key, final boolean supportUpdates) {
             throw new UnsupportedOperationException("Unexpected method call!");
         }
 
         @Override
         public List<ImmutableHierarchicalConfiguration> immutableChildConfigurationsAt(final String key) {
             throw new UnsupportedOperationException("Unexpected method call!");
         }
 
         @Override
         public ImmutableHierarchicalConfiguration immutableConfigurationAt(final String key) {
             throw new UnsupportedOperationException("Unexpected method call!");
         }
 
         @Override
         public ImmutableHierarchicalConfiguration immutableConfigurationAt(final String key, final boolean supportUpdates) {
             throw new UnsupportedOperationException("Unexpected method call!");
         }
 
         @Override
         public List<ImmutableHierarchicalConfiguration> immutableConfigurationsAt(final String key) {
             throw new UnsupportedOperationException("Unexpected method call!");
         }
     }
 
     /**
      * Checks the content of the passed in configuration object. Used by some tests that copy a configuration.
      *
      * @param c the configuration to check
      */
     private static void checkContent(final Configuration c) {
         for (int i = 0; i < NodeStructureHelper.tablesLength(); i++) {
             assertEquals(NodeStructureHelper.table(i), c.getString("tables.table(" + i + ").name"));
             for (int j = 0; j < NodeStructureHelper.fieldsLength(i); j++) {
                 assertEquals(NodeStructureHelper.field(i, j), c.getString("tables.table(" + i + ").fields.field(" + j + ").name"));
             }
         }
     }
 
     private static void checkGetProperty(final AbstractHierarchicalConfiguration<?> testConfig) {
         assertNull(testConfig.getProperty("tables.table.resultset"));
         assertNull(testConfig.getProperty("tables.table.fields.field"));
 
         Object prop = testConfig.getProperty("tables.table(0).fields.field.name");
         Collection<?> collection = assertInstanceOf(Collection.class, prop);
         assertEquals(NodeStructureHelper.fieldsLength(0), collection.size());
 
         prop = testConfig.getProperty("tables.table.fields.field.name");
         collection = assertInstanceOf(Collection.class, prop);
         assertEquals(totalFieldCount(), collection.size());
 
         prop = testConfig.getProperty("tables.table.fields.field(3).name");
         collection = assertInstanceOf(Collection.class, prop);
         assertEquals(2, collection.size());
 
         prop = testConfig.getProperty("tables.table(1).fields.field(2).name");
         assertNotNull(prop);
         assertEquals("creationDate", prop.toString());
     }
 
     /**
      * Creates a {@code DefaultConfigurationKey} object.
      *
      * @return the new key object
      */
     private static DefaultConfigurationKey createConfigurationKey() {
         return new DefaultConfigurationKey(DefaultExpressionEngine.INSTANCE);
     }
 
     /**
      * Returns the total number of fields in the test data structure.
      *
      * @return the total number of fields
      */
     private static int totalFieldCount() {
         int fieldCount = 0;
         for (int i = 0; i < NodeStructureHelper.tablesLength(); i++) {
             fieldCount += NodeStructureHelper.fieldsLength(i);
         }
         return fieldCount;
     }
 
     /** The test configuration. */
     private AbstractHierarchicalConfiguration<ImmutableNode> config;
 
     /**
      * Helper method for checking keys using an alternative syntax.
      */
     private void checkAlternativeSyntax() {
         assertNull(config.getProperty("tables/table/resultset"));
         assertNull(config.getProperty("tables/table/fields/field"));
 
         Object prop = config.getProperty("tables/table[0]/fields/field/name");
         Collection<?> collection = assertInstanceOf(Collection.class, prop);
         assertEquals(NodeStructureHelper.fieldsLength(0), collection.size());
 
         prop = config.getProperty("tables/table/fields/field/name");
         collection = assertInstanceOf(Collection.class, prop);
         assertEquals(totalFieldCount(), collection.size());
 
         prop = config.getProperty("tables/table/fields/field[3]/name");
         collection = assertInstanceOf(Collection.class, prop);
         assertEquals(2, collection.size());
 
         prop = config.getProperty("tables/table[1]/fields/field[2]/name");
         assertNotNull(prop);
         assertEquals("creationDate", prop.toString());
 
         final Set<String> keys = ConfigurationAssert.keysToSet(config);
         assertEquals(new HashSet<>(Arrays.asList("tables/table/name", "tables/table/fields/field/name")), keys);
     }
 
     /**
      * Helper method for testing the getKeys(String) method.
      *
      * @param prefix the key to pass into getKeys()
      * @param expected the expected result
      */
     private void checkKeys(final String prefix, final String[] expected) {
         final Set<String> expectedKeys = new HashSet<>();
         for (final String anExpected : expected) {
             expectedKeys.add(anExpected.startsWith(prefix) ? anExpected : prefix + "." + anExpected);
         }
 
         final Set<String> keys = new HashSet<>();
         final Iterator<String> itKeys = config.getKeys(prefix);
         while (itKeys.hasNext()) {
             final String key = itKeys.next();
             keys.add(key);
         }
 
         assertEquals(expectedKeys, keys);
     }
 
     private ExpressionEngine createAlternativeExpressionEngine() {
         return new DefaultExpressionEngine(new DefaultExpressionEngineSymbols.Builder(DefaultExpressionEngineSymbols.DEFAULT_SYMBOLS).setPropertyDelimiter("/")
             .setIndexStart("[").setIndexEnd("]").create());
     }
 
     /**
      * Convenience method for obtaining the root node of the test configuration.
      *
      * @return the root node of the test configuration
      */
     private ImmutableNode getRootNode() {
         return config.getModel().getNodeHandler().getRootNode();
     }
 
     @BeforeEach
     public void setUp() throws Exception {
         final ImmutableNode root = new ImmutableNode.Builder(1).addChild(NodeStructureHelper.ROOT_TABLES_TREE).create();
         config = new AbstractHierarchicalConfigurationTestImpl(new InMemoryNodeModel(root));
     }
 
     @Test
     public void testAddNodes() {
         final Collection<ImmutableNode> nodes = new ArrayList<>();
         nodes.add(NodeStructureHelper.createFieldNode("birthDate"));
         nodes.add(NodeStructureHelper.createFieldNode("lastLogin"));
         nodes.add(NodeStructureHelper.createFieldNode("language"));
         config.addNodes("tables.table(0).fields", nodes);
         assertEquals(7, config.getMaxIndex("tables.table(0).fields.field"));
         assertEquals("birthDate", config.getString("tables.table(0).fields.field(5).name"));
         assertEquals("lastLogin", config.getString("tables.table(0).fields.field(6).name"));
         assertEquals("language", config.getString("tables.table(0).fields.field(7).name"));
     }
 
     /**
      * Tests copying nodes from one configuration to another one.
      */
     @Test
     public void testAddNodesCopy() {
         final AbstractHierarchicalConfigurationTestImpl configDest = new AbstractHierarchicalConfigurationTestImpl(new InMemoryNodeModel());
         configDest.addProperty("test", "TEST");
         final Collection<ImmutableNode> nodes = getRootNode().getChildren();
         assertEquals(1, nodes.size());
         configDest.addNodes("newNodes", nodes);
         for (int i = 0; i < NodeStructureHelper.tablesLength(); i++) {
             final String keyTab = "newNodes.tables.table(" + i + ").";
             assertEquals(NodeStructureHelper.table(i), configDest.getString(keyTab + "name"), "Table " + i + " not found");
             for (int j = 0; j < NodeStructureHelper.fieldsLength(i); j++) {
                 assertEquals(NodeStructureHelper.field(i, j), configDest.getString(keyTab + "fields.field(" + j + ").name"),
                         "Invalid field " + j + " in table " + i);
             }
         }
     }
 
     /**
      * Tests the addNodes() method if the provided key does not exist. In this case, a new node (or even a completely new
      * branch) is created.
      */
     @Test
     public void testAddNodesForNonExistingKey() {
         final Collection<ImmutableNode> nodes = new ArrayList<>();
         final ImmutableNode newNode = new ImmutableNode.Builder().name("usr").value("scott").addAttribute("pwd", "tiger").create();
         nodes.add(newNode);
         config.addNodes("database.connection.settings", nodes);
 
         assertEquals("scott", config.getString("database.connection.settings.usr"));
         assertEquals("tiger", config.getString("database.connection.settings.usr[@pwd]"));
     }
 
     /**
      * Tests the addNodes() method when the new nodes should be added to an attribute node. This is not allowed.
      */
     @Test
     public void testAddNodesWithAttributeKey() {
         final Collection<ImmutableNode> nodes = new ArrayList<>();
         nodes.add(NodeStructureHelper.createNode("testNode", "yes"));
         assertThrows(IllegalArgumentException.class, () -> config.addNodes("database.connection[@settings]", nodes));
     }
 
     @Test
     public void testAddProperty() {
         config.addProperty("tables.table(0).fields.field(-1).name", "phone");
         Object prop = config.getProperty("tables.table(0).fields.field.name");
         Collection<?> collection = assertInstanceOf(Collection.class, prop);
         assertEquals(6, collection.size());
 
         config.addProperty("tables.table(0).fields.field.name", "fax");
         prop = config.getProperty("tables.table.fields.field(5).name");
         final List<?> list = assertInstanceOf(List.class, prop);
         assertEquals("phone", list.get(0));
         assertEquals("fax", list.get(1));
 
         config.addProperty("tables.table(-1).name", "config");
         prop = config.getProperty("tables.table.name");
         collection = assertInstanceOf(Collection.class, prop);
         assertEquals(3, collection.size());
         config.addProperty("tables.table(2).fields.field(0).name", "cid");
         config.addProperty("tables.table(2).fields.field(-1).name", "confName");
         prop = config.getProperty("tables.table(2).fields.field.name");
         collection = assertInstanceOf(Collection.class, prop);
         assertEquals(2, collection.size());
         assertEquals("confName", config.getProperty("tables.table(2).fields.field(1).name"));
 
         config.addProperty("connection.user", "scott");
         config.addProperty("connection.passwd", "tiger");
         assertEquals("tiger", config.getProperty("connection.passwd"));
 
         final DefaultConfigurationKey key = createConfigurationKey();
         key.append("tables").append("table").appendIndex(0);
         key.appendAttribute("tableType");
         config.addProperty(key.toString(), "system");
         assertEquals("system", config.getProperty(key.toString()));
     }
 
     @Test
     public void testAddPropertyInvalidKey() {
         assertThrows(IllegalArgumentException.class, () -> config.addProperty(".", "InvalidKey"));
     }
 
     /**
      * Tests whether list handling works correctly when adding properties.
      */
     @Test
     public void testAddPropertyWithListHandling() {
         config.setListDelimiterHandler(new DefaultListDelimiterHandler(','));
         final String key = "list.delimiter.value";
         config.addProperty(key + ".escaped", "3\\,1415");
         config.addProperty(key + ".elements", "3,1415");
         assertEquals("3,1415", config.getString(key + ".escaped"));
         assertEquals("3", config.getString(key + ".elements"));
     }
 
     @Test
     public void testClear() {
         config.setProperty(null, "value");
         config.addProperty("[@attr]", "defined");
         config.clear();
         assertTrue(config.isEmpty());
     }
 
     @Test
     public void testClearProperty() {
         config.clearProperty("tables.table(0).fields.field(0).name");
         assertEquals("uname", config.getProperty("tables.table(0).fields.field(0).name"));
         config.clearProperty("tables.table(0).name");
         assertFalse(config.containsKey("tables.table(0).name"));
         assertEquals("firstName", config.getProperty("tables.table(0).fields.field(1).name"));
         assertEquals("documents", config.getProperty("tables.table.name"));
         config.clearProperty("tables.table");
         assertEquals("documents", config.getProperty("tables.table.name"));
 
         config.addProperty("test", "first");
         config.addProperty("test.level", "second");
         config.clearProperty("test");
         assertEquals("second", config.getString("test.level"));
         assertFalse(config.containsKey("test"));
     }
 
     @Test
     public void testClearTree() {
         Object prop = config.getProperty("tables.table(0).fields.field.name");
         assertNotNull(prop);
         config.clearTree("tables.table(0).fields.field(3)");
         prop = config.getProperty("tables.table(0).fields.field.name");
         Collection<?> collection = assertInstanceOf(Collection.class, prop);
         assertEquals(4, collection.size());
 
         config.clearTree("tables.table(0).fields");
         assertNull(config.getProperty("tables.table(0).fields.field.name"));
         prop = config.getProperty("tables.table.fields.field.name");
         collection = assertInstanceOf(Collection.class, prop);
         assertEquals(NodeStructureHelper.fieldsLength(1), collection.size());
 
         config.clearTree("tables.table(1)");
         assertNull(config.getProperty("tables.table.fields.field.name"));
     }
 
     /**
      * Tests removing more complex node structures.
      */
     @Test
     public void testClearTreeComplex() {
         final int count = 5;
         // create the structure
         for (int idx = 0; idx < count; idx++) {
             config.addProperty("indexList.index(-1)[@default]", Boolean.FALSE);
             config.addProperty("indexList.index[@name]", "test" + idx);
             config.addProperty("indexList.index.dir", "testDir" + idx);
         }
         assertEquals(count - 1, config.getMaxIndex("indexList.index[@name]"));
 
         // Remove a sub tree
         boolean found = false;
         for (int idx = 0; true; idx++) {
             final String name = config.getString("indexList.index(" + idx + ")[@name]");
             if (name == null) {
                 break;
             }
             if ("test3".equals(name)) {
                 assertEquals("testDir3", config.getString("indexList.index(" + idx + ").dir"));
                 config.clearTree("indexList.index(" + idx + ")");
                 found = true;
             }
         }
         assertTrue(found);
         assertEquals(count - 2, config.getMaxIndex("indexList.index[@name]"));
         assertEquals(count - 2, config.getMaxIndex("indexList.index.dir"));
 
         // Verify
         for (int idx = 0; true; idx++) {
             final String name = config.getString("indexList.index(" + idx + ")[@name]");
             if (name == null) {
                 break;
             }
             assertNotEquals("test3", name);
         }
     }
 
     /**
      * Tests the clearTree() method on a hierarchical structure of nodes. This is a test case for CONFIGURATION-293.
      */
     @Test
     public void testClearTreeHierarchy() {
         config.addProperty("a.b.c", "c");
         config.addProperty("a.b.c.d", "d");
         config.addProperty("a.b.c.d.e", "e");
         config.clearTree("a.b.c");
         assertFalse(config.containsKey("a.b.c"));
         assertFalse(config.containsKey("a.b.c.d"));
     }
 
     @Test
     public void testClone() {
         final Configuration copy = (Configuration) config.clone();
         assertInstanceOf(AbstractHierarchicalConfiguration.class, copy);
         checkContent(copy);
     }
 
     /**
      * Tests whether interpolation works as expected after cloning.
      */
     @Test
     public void testCloneInterpolation() {
         final String keyAnswer = "answer";
         final String keyValue = "value";
         config.addProperty(keyAnswer, "The answer is ${" + keyValue + "}.");
         config.addProperty(keyValue, 42);
         final Configuration clone = (Configuration) config.clone();
         clone.setProperty(keyValue, 43);
         assertEquals("The answer is 42.", config.getString(keyAnswer));
         assertEquals("The answer is 43.", clone.getString(keyAnswer));
     }
 
     /**
      * Tests whether registered event handlers are handled correctly when a configuration is cloned. They should not be
      * registered at the clone.
      */
     @Test
     public void testCloneWithEventListeners() {
         final EventListener<ConfigurationEvent> l = new EventListenerTestImpl(null);
         config.addEventListener(ConfigurationEvent.ANY, l);
         final AbstractHierarchicalConfiguration<?> copy = (AbstractHierarchicalConfiguration<?>) config.clone();
         assertFalse(copy.getEventListeners(ConfigurationEvent.ANY).contains(l));
     }
 
     @Test
     public void testContainsKey() {
         assertTrue(config.containsKey("tables.table(0).name"));
         assertTrue(config.containsKey("tables.table(1).name"));
         assertFalse(config.containsKey("tables.table(2).name"));
 
         assertTrue(config.containsKey("tables.table(0).fields.field.name"));
         assertFalse(config.containsKey("tables.table(0).fields.field"));
         config.clearTree("tables.table(0).fields");
         assertFalse(config.containsKey("tables.table(0).fields.field.name"));
 
         assertTrue(config.containsKey("tables.table.fields.field.name"));
     }
 
     @Test
     public void testContainsValue() {
         assertFalse(config.containsValue(null));
         assertFalse(config.containsValue(""));
     }
 
     @Test
     public void testGetKeys() {
         final List<String> keys = new ArrayList<>();
         for (final Iterator<String> it = config.getKeys(); it.hasNext();) {
             keys.add(it.next());
         }
 
         assertEquals(Arrays.asList("tables.table.name", "tables.table.fields.field.name"), keys);
     }
 
     /**
      * Tests whether attribute keys are contained in the iteration of keys.
      */
     @Test
     public void testGetKeysAttribute() {
         config.addProperty("tables.table(0)[@type]", "system");
         final Set<String> keys = new HashSet<>();
         for (final Iterator<String> it = config.getKeys(); it.hasNext();) {
             keys.add(it.next());
         }
         assertTrue(keys.contains("tables.table[@type]"));
     }
 
     /**
      * Tests whether a prefix that points to an attribute is correctly handled.
      */
     @Test
     public void testGetKeysAttributePrefix() {
         config.addProperty("tables.table(0)[@type]", "system");
         final Iterator<String> itKeys = config.getKeys("tables.table[@type]");
         assertEquals("tables.table[@type]", itKeys.next());
         assertFalse(itKeys.hasNext());
     }
 
     /**
      * Tests whether keys are returned in a defined order.
      */
     @Test
     public void testGetKeysOrder() {
         config.addProperty("order.key1", "value1");
         config.addProperty("order.key2", "value2");
         config.addProperty("order.key3", "value3");
 
         final Iterator<String> it = config.getKeys("order");
         assertEquals("order.key1", it.next());
         assertEquals("order.key2", it.next());
         assertEquals("order.key3", it.next());
     }
 
     @Test
     public void testGetKeysString() {
         // add some more properties to make it more interesting
         config.addProperty("tables.table(0).fields.field(1).type", "VARCHAR");
         config.addProperty("tables.table(0)[@type]", "system");
         config.addProperty("tables.table(0).size", "42");
         config.addProperty("tables.table(0).fields.field(0).size", "128");
         config.addProperty("connections.connection.param.url", "url1");
         config.addProperty("connections.connection.param.user", "me");
         config.addProperty("connections.connection.param.pwd", "secret");
         config.addProperty("connections.connection(-1).param.url", "url2");
         config.addProperty("connections.connection(1).param.user", "guest");
 
         checkKeys("tables.table(1)", new String[] {"name", "fields.field.name"});
         checkKeys("tables.table(0)", new String[] {"name", "fields.field.name", "tables.table(0)[@type]", "size", "fields.field.type", "fields.field.size"});
         checkKeys("connections.connection(0).param", new String[] {"url", "user", "pwd"});
         checkKeys("connections.connection(1).param", new String[] {"url", "user"});
     }
 
     /**
      * Tests getKeys() with a prefix when the prefix matches exactly a key.
      */
     @Test
     public void testGetKeysWithKeyAsPrefix() {
         config.addProperty("order.key1", "value1");
         config.addProperty("order.key2", "value2");
         final Iterator<String> it = config.getKeys("order.key1");
         assertTrue(it.hasNext());
         assertEquals("order.key1", it.next());
         assertFalse(it.hasNext());
     }
 
     /**
      * Tests getKeys() with a prefix when the prefix matches exactly a key, and there are multiple keys starting with this
      * prefix.
      */
     @Test
     public void testGetKeysWithKeyAsPrefixMultiple() {
         config.addProperty("order.key1", "value1");
         config.addProperty("order.key1.test", "value2");
         config.addProperty("order.key1.test.complex", "value2");
         final Iterator<String> it = config.getKeys("order.key1");
         assertEquals("order.key1", it.next());
         assertEquals("order.key1.test", it.next());
         assertEquals("order.key1.test.complex", it.next());
         assertFalse(it.hasNext());
     }
 
     @Test
     public void testGetMaxIndex() {
         assertEquals(NodeStructureHelper.fieldsLength(0) - 1, config.getMaxIndex("tables.table(0).fields.field"));
         assertEquals(NodeStructureHelper.fieldsLength(1) - 1, config.getMaxIndex("tables.table(1).fields.field"));
         assertEquals(1, config.getMaxIndex("tables.table"));
         assertEquals(1, config.getMaxIndex("tables.table.name"));
         assertEquals(0, config.getMaxIndex("tables.table(0).name"));
         assertEquals(0, config.getMaxIndex("tables.table(1).fields.field(1)"));
         assertEquals(-1, config.getMaxIndex("tables.table(2).fields"));
 
         final int maxIdx = config.getMaxIndex("tables.table(0).fields.field.name");
         for (int i = 0; i <= maxIdx; i++) {
             final DefaultConfigurationKey key = new DefaultConfigurationKey(DefaultExpressionEngine.INSTANCE, "tables.table(0).fields");
             key.append("field").appendIndex(i).append("name");
             assertNotNull(config.getProperty(key.toString()));
         }
     }
 
     /**
      * Tests whether the configuration's node model can be correctly accessed.
      */
     @Test
     public void testGetNodeModel() {
         final SynchronizerTestImpl sync = new SynchronizerTestImpl();
         config.setSynchronizer(sync);
         final NodeModel<ImmutableNode> model = config.getNodeModel();
 
         assertInstanceOf(InMemoryNodeModel.class, model);
         final ImmutableNode rootNode = model.getNodeHandler().getRootNode();
         assertEquals(1, rootNode.getChildren().size());
         assertTrue(rootNode.getChildren().contains(NodeStructureHelper.ROOT_TABLES_TREE));
         sync.verify(SynchronizerTestImpl.Methods.BEGIN_READ, SynchronizerTestImpl.Methods.END_READ);
     }
 
     @Test
     public void testGetProperty() {
         checkGetProperty(config);
     }
 
     /**
      * Tests whether keys that contains brackets can be used.
      */
     @Test
     public void testGetPropertyKeyWithBrackets() {
         final String key = "test.directory.platform(x86)";
         config.addProperty(key, "C:\\Temp");
         assertEquals("C:\\Temp", config.getString(key));
     }
 
     /**
      * Tests the copy constructor when a null reference is passed.
      */
     @Test
     public void testInitCopyNull() {
         final BaseHierarchicalConfiguration copy = new BaseHierarchicalConfiguration((BaseHierarchicalConfiguration) null);
         assertTrue(copy.isEmpty());
     }
 
     /**
      * Tests obtaining a configuration with all variables substituted.
      */
     @Test
     public void testInterpolatedConfiguration() {
         config.setListDelimiterHandler(new DefaultListDelimiterHandler(','));
         final AbstractHierarchicalConfiguration<?> c = (AbstractHierarchicalConfiguration<?>) InterpolationTestHelper.testInterpolatedConfiguration(config);
 
         // tests whether the hierarchical structure has been maintained
         checkGetProperty(c);
     }
 
     /**
      * Tests interpolation facilities.
      */
     @Test
     public void testInterpolation() {
         config.addProperty("base.dir", "/home/foo");
         config.addProperty("test.absolute.dir.dir1", "${base.dir}/path1");
         config.addProperty("test.absolute.dir.dir2", "${base.dir}/path2");
         config.addProperty("test.absolute.dir.dir3", "${base.dir}/path3");
         final Configuration sub = config.subset("test.absolute.dir");
         for (int i = 1; i < 4; i++) {
             assertEquals("/home/foo/path" + i, config.getString("test.absolute.dir.dir" + i));
             assertEquals("/home/foo/path" + i, sub.getString("dir" + i));
         }
     }
 
     /**
      * Basic interpolation tests.
      */
     @Test
     public void testInterpolationBasic() {
         InterpolationTestHelper.testInterpolation(config);
     }
 
     /**
      * Tests interpolation with constant values.
      */
     @Test
     public void testInterpolationConstants() {
         InterpolationTestHelper.testInterpolationConstants(config);
     }
 
     /**
      * Tests escaping variables.
      */
     @Test
     public void testInterpolationEscaped() {
         InterpolationTestHelper.testInterpolationEscaped(config);
     }
 
     /**
      * Tests interpolation with localhost values.
      */
     @Test
     public void testInterpolationLocalhost() {
         InterpolationTestHelper.testInterpolationLocalhost(config);
     }
 
     /**
      * Tests an invalid interpolation that causes an endless loop.
      */
     @Test
     public void testInterpolationLoop() {
         InterpolationTestHelper.testInterpolationLoop(config);
     }
 
     /**
      * Tests multiple levels of interpolation.
      */
     @Test
     public void testInterpolationMultipleLevels() {
         InterpolationTestHelper.testMultipleInterpolation(config);
     }
 
     /**
      * Tests interpolation with a subset.
      */
     @Test
     public void testInterpolationSubset() {
         InterpolationTestHelper.testInterpolationSubset(config);
     }
 
     /**
      * Tests whether interpolation with a subset configuration works over multiple layers.
      */
     @Test
     public void testInterpolationSubsetMultipleLayers() {
         config.clear();
         config.addProperty("var", "value");
         config.addProperty("prop2.prop[@attr]", "${var}");
         final Configuration sub1 = config.subset("prop2");
         final Configuration sub2 = sub1.subset("prop");
         assertEquals("value", sub2.getString("[@attr]"));
     }
 
     /**
      * Tests interpolation with system properties.
      */
     @Test
     public void testInterpolationSystemProperties() {
         InterpolationTestHelper.testInterpolationSystemProperties(config);
     }
 
     /**
      * Tests interpolation of a variable, which cannot be resolved.
      */
     @Test
     public void testInterpolationUnknownProperty() {
         InterpolationTestHelper.testInterpolationUnknownProperty(config);
     }
 
     /**
      * Tests manipulating the interpolator.
      */
     @Test
     public void testInterpolator() {
         InterpolationTestHelper.testGetInterpolator(config);
     }
 
     @Test
     public void testIsEmptyFalse() {
         assertFalse(config.isEmpty());
     }
 
     /**
      * Tests isEmpty() if the structure contains some nodes without values.
      */
     @Test
     public void testIsEmptyNodesWithNoValues() {
         final ImmutableNode.Builder rootBuilder = new ImmutableNode.Builder(1);
         final ImmutableNode.Builder nodeBuilder = new ImmutableNode.Builder(1);
         nodeBuilder.addChild(NodeStructureHelper.createNode("child", null));
         rootBuilder.addChild(nodeBuilder.create());
         config = new AbstractHierarchicalConfigurationTestImpl(new InMemoryNodeModel(rootBuilder.create()));
         assertTrue(config.isEmpty());
     }
 
     /**
      * Tests isEmpty() if only the root node exists.
      */
     @Test
     public void testIsEmptyRootOnly() {
         config = new AbstractHierarchicalConfigurationTestImpl(new InMemoryNodeModel());
         assertTrue(config.isEmpty());
     }
 
     /**
      * Tests nodeKey() if the key is directly found in the cache.
      */
     @Test
     public void testNodeKeyCacheHit() {
         final Map<ImmutableNode, String> cache = new HashMap<>();
         final String key = "someResultKey";
         cache.put(getRootNode(), key);
         assertEquals(key, config.nodeKey(getRootNode(), cache, config.getModel().getNodeHandler()));
     }
 
     /**
      * Tests whether the cache map is filled while generating node keys.
      */
     @Test
     public void testNodeKeyCachePopulated() {
         final Map<ImmutableNode, String> cache = new HashMap<>();
         final ImmutableNode nodeTabName = NodeStructureHelper.nodeForKey(getRootNode(), "tables/table(0)/name");
         final NodeHandler<ImmutableNode> handler = config.getModel().getNodeHandler();
         config.nodeKey(nodeTabName, cache, handler);
         assertEquals(4, cache.size());
         assertEquals("tables(0).table(0).name(0)", cache.get(nodeTabName));
         assertEquals("tables(0).table(0)", cache.get(handler.getParent(nodeTabName)));
         assertEquals("tables(0)", cache.get(handler.getParent(handler.getParent(nodeTabName))));
         assertEquals("", cache.get(getRootNode()));
     }
 
     /**
      * Tests whether the cache is used by nodeKey().
      */
     @Test
     public void testNodeKeyCacheUsage() {
         final Map<ImmutableNode, String> cache = new HashMap<>();
         final ImmutableNode nodeTabName = NodeStructureHelper.nodeForKey(getRootNode(), "tables/table(0)/name");
         final NodeHandler<ImmutableNode> handler = config.getModel().getNodeHandler();
         cache.put(handler.getParent(nodeTabName), "somePrefix");
         assertEquals("somePrefix.name(0)", config.nodeKey(nodeTabName, cache, handler));
     }
 
     /**
      * Tests whether a correct node key is generated if no data is contained in the cache.
      */
     @Test
     public void testNodeKeyEmptyCache() {
         final Map<ImmutableNode, String> cache = new HashMap<>();
         final ImmutableNode nodeTabName = NodeStructureHelper.nodeForKey(getRootNode(), "tables/table(0)/name");
         final ImmutableNode nodeFldName = NodeStructureHelper.nodeForKey(getRootNode(), "tables/table(0)/fields/field(1)/name");
         assertEquals("tables(0).table(0).name(0)", config.nodeKey(nodeTabName, cache, config.getModel().getNodeHandler()));
         assertEquals("tables(0).table(0).fields(0).field(1).name(0)", config.nodeKey(nodeFldName, cache, config.getModel().getNodeHandler()));
     }
 
     /**
      * Tests whether a node key for the root node can be generated.
      */
     @Test
     public void testNodeKeyRootNode() {
         final Map<ImmutableNode, String> cache = new HashMap<>();
         assertEquals("", config.nodeKey(getRootNode(), cache, config.getModel().getNodeHandler()));
     }
 
     /**
      * Tests whether node keys can be resolved.
      */
     @Test
     public void testResolveNodeKey() {
         final List<ImmutableNode> nodes = config.resolveNodeKey(getRootNode(), "tables.table.name", config.getModel().getNodeHandler());
         assertEquals(NodeStructureHelper.tablesLength(), nodes.size());
         for (int i = 0; i < NodeStructureHelper.tablesLength(); i++) {
             assertEquals(NodeStructureHelper.table(i), nodes.get(i).getValue(), "Wrong node value at " + i);
         }
     }
 
     /**
      * Tests whether attribute keys are filtered out when resolving node keys.
      */
     @Test
     public void testResolveNodeKeyAttribute() {
         final String attrKey = "tables.table(0)[@type]";
         config.addProperty(attrKey, "system");
         assertTrue(config.resolveNodeKey(getRootNode(), attrKey, config.getModel().getNodeHandler()).isEmpty());
     }
 
     /**
      * Tests setting a custom expression engine, which uses a slightly different syntax.
      */
     @Test
     public void testSetExpressionEngine() {
         config.setExpressionEngine(null);
         assertNotNull(config.getExpressionEngine());
         assertSame(DefaultExpressionEngine.INSTANCE, config.getExpressionEngine());
 
         config.setExpressionEngine(createAlternativeExpressionEngine());
         checkAlternativeSyntax();
     }
 
     @Test
     public void testSetProperty() {
         config.setListDelimiterHandler(new DefaultListDelimiterHandler(','));
         config.setProperty("tables.table(0).name", "resources");
         assertEquals("resources", config.getString("tables.table(0).name"));
         config.setProperty("tables.table.name", "tab1,tab2");
         assertEquals("tab1", config.getString("tables.table(0).name"));
         assertEquals("tab2", config.getString("tables.table(1).name"));
 
         config.setProperty("test.items.item", new int[] {2, 4, 8, 16});
         assertEquals(3, config.getMaxIndex("test.items.item"));
         assertEquals(8, config.getInt("test.items.item(2)"));
         config.setProperty("test.items.item(2)", Integer.valueOf(6));
         assertEquals(6, config.getInt("test.items.item(2)"));
         config.setProperty("test.items.item(2)", new int[] {7, 9, 11});
         assertEquals(5, config.getMaxIndex("test.items.item"));
 
         config.setProperty("test", Boolean.TRUE);
         config.setProperty("test.items", "01/01/05");
         assertEquals(5, config.getMaxIndex("test.items.item"));
         assertTrue(config.getBoolean("test"));
         assertEquals("01/01/05", config.getProperty("test.items"));
 
         config.setProperty("test.items.item", Integer.valueOf(42));
         assertEquals(0, config.getMaxIndex("test.items.item"));
         assertEquals(42, config.getInt("test.items.item"));
     }
 
     /**
      * Tests whether the correct size is calculated.
      */
     @Test
     public void testSize() {
         assertEquals(2, config.size());
     }
 }