/*
    * 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
    *
    *     https://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.assertNotSame;
  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.io.StringReader;
  import java.io.StringWriter;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Set;
  import java.util.concurrent.CountDownLatch;
  import java.util.concurrent.atomic.AtomicInteger;
  
  import org.apache.commons.configuration2.SynchronizerTestImpl.Methods;
  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.ex.ConfigurationException;
  import org.apache.commons.configuration2.ex.ConfigurationRuntimeException;
  import org.apache.commons.configuration2.io.FileHandler;
  import org.apache.commons.configuration2.sync.LockMode;
  import org.apache.commons.configuration2.sync.ReadWriteSynchronizer;
  import org.apache.commons.configuration2.sync.Synchronizer;
  import org.apache.commons.configuration2.tree.DefaultExpressionEngine;
  import org.apache.commons.configuration2.tree.DefaultExpressionEngineSymbols;
  import org.apache.commons.configuration2.tree.ImmutableNode;
  import org.apache.commons.configuration2.tree.NodeCombiner;
  import org.apache.commons.configuration2.tree.NodeModel;
  import org.apache.commons.configuration2.tree.OverrideCombiner;
  import org.apache.commons.configuration2.tree.UnionCombiner;
  import org.junit.jupiter.api.BeforeEach;
  import org.junit.jupiter.api.Test;
  
  /**
   * Test class for CombinedConfiguration.
   */
  public class TestCombinedConfiguration {
  
      /**
       * Test event listener class for checking if the expected invalidate events are fired.
       */
      private static final class CombinedListener implements EventListener<ConfigurationEvent> {
  
          private int invalidateEvents;
  
          private int otherEvents;
  
          /**
           * Checks if the expected number of events was fired.
           *
           * @param expectedInvalidate the expected number of invalidate events
           * @param expectedOthers the expected number of other events
           */
          public void checkEvent(final int expectedInvalidate, final int expectedOthers) {
              assertEquals(expectedInvalidate, invalidateEvents);
              assertEquals(expectedOthers, otherEvents);
          }
  
          @Override
          public void onEvent(final ConfigurationEvent event) {
              if (event.getEventType() == CombinedConfiguration.COMBINED_INVALIDATE) {
                  invalidateEvents++;
              } else {
                  otherEvents++;
              }
          }
      }
  
      /**
       * A test thread performing reads on a combined configuration. This thread reads a certain property from the
       * configuration. If everything works well, this property should have at least one and at most two values.
       */
     private static final class ReadThread extends Thread {
 
         /** The configuration to be accessed. */
         private final Configuration config;
 
         /** The latch for synchronizing thread start. */
         private final CountDownLatch startLatch;
 
         /** A counter for read errors. */
         private final AtomicInteger errorCount;
 
         /** The number of reads to be performed. */
         private final int numberOfReads;
 
         /**
          * Creates a new instance of {@code ReadThread}.
          *
          * @param readConfig the configuration to be read
          * @param latch the latch for synchronizing thread start
          * @param errCnt the counter for read errors
          * @param readCount the number of reads to be performed
          */
         public ReadThread(final Configuration readConfig, final CountDownLatch latch, final AtomicInteger errCnt, final int readCount) {
             config = readConfig;
             startLatch = latch;
             errorCount = errCnt;
             numberOfReads = readCount;
         }
 
         /**
          * Reads the test property from the associated configuration. Its values are checked.
          */
         private void readConfiguration() {
             final List<Object> values = config.getList(KEY_CONCURRENT);
             if (values.size() < 1 || values.size() > 2) {
                 errorCount.incrementAndGet();
             } else {
                 boolean ok = true;
                 for (final Object value : values) {
                     if (!TEST_NAME.equals(value)) {
                         ok = false;
                     }
                 }
                 if (!ok) {
                     errorCount.incrementAndGet();
                 }
             }
         }
 
         /**
          * Reads from the test configuration.
          */
         @Override
         public void run() {
             try {
                 startLatch.await();
                 for (int i = 0; i < numberOfReads; i++) {
                     readConfiguration();
                 }
             } catch (final Exception e) {
                 errorCount.incrementAndGet();
             }
         }
     }
 
     /**
      * A test thread performing updates on a test configuration. This thread modifies configurations which are children of a
      * combined configuration. Each update operation adds a value to one of the child configurations and removes it from
      * another one (which contained it before). So if concurrent reads are performed, the test property should always have
      * between 1 and 2 values.
      */
     private static final class WriteThread extends Thread {
 
         /** The list with the child configurations. */
         private final List<Configuration> testConfigs;
 
         /** The latch for synchronizing thread start. */
         private final CountDownLatch startLatch;
 
         /** A counter for errors. */
         private final AtomicInteger errorCount;
 
         /** The number of write operations to be performed. */
         private final int numberOfWrites;
 
         /** The index of the child configuration containing the test property. */
         private int currentChildConfigIdx;
 
         /**
          * Creates a new instance of {@code WriteThread}.
          *
          * @param cc the test combined configuration
          * @param latch the latch for synchronizing test start
          * @param errCnt a counter for errors
          * @param writeCount the number of writes to be performed
          */
         public WriteThread(final CombinedConfiguration cc, final CountDownLatch latch, final AtomicInteger errCnt, final int writeCount) {
             testConfigs = cc.getConfigurations();
             startLatch = latch;
             errorCount = errCnt;
             numberOfWrites = writeCount;
         }
 
         @Override
         public void run() {
             try {
                 startLatch.await();
                 for (int i = 0; i < numberOfWrites; i++) {
                     updateConfigurations();
                 }
             } catch (final InterruptedException e) {
                 errorCount.incrementAndGet();
             }
         }
 
         /**
          * Performs the update operation.
          */
         private void updateConfigurations() {
             final int newIdx = (currentChildConfigIdx + 1) % testConfigs.size();
             testConfigs.get(newIdx).addProperty(KEY_CONCURRENT, TEST_NAME);
             testConfigs.get(currentChildConfigIdx).clearProperty(KEY_CONCURRENT);
             currentChildConfigIdx = newIdx;
         }
     }
 
     /** Constant for the name of a sub configuration. */
     private static final String TEST_NAME = "SUBCONFIG";
 
     /** Constant for a test key. */
     private static final String TEST_KEY = "test.value";
 
     /** Constant for a key to be used for a concurrent test. */
     private static final String KEY_CONCURRENT = "concurrent.access.test";
 
     /** Constant for the name of the first child configuration. */
     private static final String CHILD1 = TEST_NAME + "1";
 
     /** Constant for the name of the second child configuration. */
     private static final String CHILD2 = TEST_NAME + "2";
 
     /** Constant for the key for a sub configuration. */
     private static final String SUB_KEY = "test.sub.config";
 
     /**
      * Helper method for creating a test configuration to be added to the combined configuration.
      *
      * @return the test configuration
      */
     private static AbstractConfiguration setUpTestConfiguration() {
         final BaseHierarchicalConfiguration config = new BaseHierarchicalConfiguration();
         config.addProperty(TEST_KEY, Boolean.TRUE);
         config.addProperty("test.comment", "This is a test");
         return config;
     }
 
     /** The configuration to be tested. */
     private CombinedConfiguration config;
 
     /** The test event listener. */
     private CombinedListener listener;
 
     /**
      * Checks if a configuration was correctly added to the combined config.
      *
      * @param c the config to check
      */
     private void checkAddConfig(final AbstractConfiguration c) {
         final Collection<EventListener<? super ConfigurationEvent>> listeners = c.getEventListeners(ConfigurationEvent.ANY);
         assertEquals(1, listeners.size());
         assertTrue(listeners.contains(config));
     }
 
     /**
      * Helper method for testing that the combined root node has not yet been constructed.
      */
     private void checkCombinedRootNotConstructed() {
         assertTrue(config.getModel().getNodeHandler().getRootNode().getChildren().isEmpty());
     }
 
     /**
      * Checks the configurationsAt() method.
      *
      * @param withUpdates flag whether updates are supported
      */
     private void checkConfigurationsAt(final boolean withUpdates) {
         setUpSubConfigTest();
         final List<HierarchicalConfiguration<ImmutableNode>> subs = config.configurationsAt(SUB_KEY, withUpdates);
         assertEquals(1, subs.size());
         assertTrue(subs.get(0).getBoolean(TEST_KEY));
     }
 
     /**
      * Tests whether a configuration was completely removed.
      *
      * @param c the removed configuration
      */
     private void checkRemoveConfig(final AbstractConfiguration c) {
         assertTrue(c.getEventListeners(ConfigurationEvent.ANY).isEmpty());
         assertEquals(0, config.getNumberOfConfigurations());
         assertTrue(config.getConfigurationNames().isEmpty());
         listener.checkEvent(2, 0);
     }
 
     @BeforeEach
     public void setUp() throws Exception {
         config = new CombinedConfiguration();
         listener = new CombinedListener();
         config.addEventListener(ConfigurationEvent.ANY, listener);
     }
 
     /**
      * Prepares a test of the getSource() method.
      */
     private void setUpSourceTest() {
         final BaseHierarchicalConfiguration c1 = new BaseHierarchicalConfiguration();
         final PropertiesConfiguration c2 = new PropertiesConfiguration();
         c1.addProperty(TEST_KEY, TEST_NAME);
         c2.addProperty("another.key", "test");
         config.addConfiguration(c1, CHILD1);
         config.addConfiguration(c2, CHILD2);
     }
 
     /**
      * Prepares the test configuration for a test for sub configurations. Some child configurations are added.
      *
      * @return the sub configuration at the test sub key
      */
     private AbstractConfiguration setUpSubConfigTest() {
         final AbstractConfiguration srcConfig = setUpTestConfiguration();
         config.addConfiguration(srcConfig, "source", SUB_KEY);
         config.addConfiguration(setUpTestConfiguration());
         config.addConfiguration(setUpTestConfiguration(), "otherTest", "other.prefix");
         return srcConfig;
     }
 
     /**
      * Prepares a test for synchronization. This method installs a test synchronizer and adds some test configurations.
      *
      * @return the test synchronizer
      */
     private SynchronizerTestImpl setUpSynchronizerTest() {
         setUpSourceTest();
         final SynchronizerTestImpl sync = new SynchronizerTestImpl();
         config.setSynchronizer(sync);
         return sync;
     }
 
     /**
      * Tests accessing properties if no configurations have been added.
      */
     @Test
     void testAccessPropertyEmpty() {
         assertFalse(config.containsKey(TEST_KEY));
         assertNull(config.getString("test.comment"));
         assertTrue(config.isEmpty());
     }
 
     /**
      * Tests accessing properties if multiple configurations have been added.
      */
     @Test
     void testAccessPropertyMulti() {
         config.addConfiguration(setUpTestConfiguration());
         config.addConfiguration(setUpTestConfiguration(), null, "prefix1");
         config.addConfiguration(setUpTestConfiguration(), null, "prefix2");
         assertTrue(config.getBoolean(TEST_KEY));
         assertTrue(config.getBoolean("prefix1." + TEST_KEY));
         assertTrue(config.getBoolean("prefix2." + TEST_KEY));
         assertFalse(config.isEmpty());
         listener.checkEvent(3, 0);
     }
 
     /**
      * Tests adding a configuration (without further information).
      */
     @Test
     void testAddConfiguration() {
         final AbstractConfiguration c = setUpTestConfiguration();
         config.addConfiguration(c);
         checkAddConfig(c);
         assertEquals(1, config.getNumberOfConfigurations());
         assertTrue(config.getConfigurationNames().isEmpty());
         assertSame(c, config.getConfiguration(0));
         assertTrue(config.getBoolean(TEST_KEY));
         listener.checkEvent(1, 0);
     }
 
     /**
      * Tests adding a configuration and specifying an at position.
      */
     @Test
     void testAddConfigurationAt() {
         final AbstractConfiguration c = setUpTestConfiguration();
         config.addConfiguration(c, null, "my");
         checkAddConfig(c);
         assertTrue(config.getBoolean("my." + TEST_KEY));
     }
 
     /**
      * Tests adding a configuration with a complex at position. Here the at path contains a dot, which must be escaped.
      */
     @Test
     void testAddConfigurationComplexAt() {
         final AbstractConfiguration c = setUpTestConfiguration();
         config.addConfiguration(c, null, "This..is.a.complex");
         checkAddConfig(c);
         assertTrue(config.getBoolean("This..is.a.complex." + TEST_KEY));
     }
 
     /**
      * Tests whether adding a new configuration is synchronized.
      */
     @Test
     void testAddConfigurationSynchronized() {
         final SynchronizerTestImpl sync = setUpSynchronizerTest();
         config.addConfiguration(new BaseHierarchicalConfiguration());
         sync.verify(Methods.BEGIN_WRITE, Methods.END_WRITE);
         checkCombinedRootNotConstructed();
     }
 
     /**
      * Tests adding a configuration with a name.
      */
     @Test
     void testAddConfigurationWithName() {
         final AbstractConfiguration c = setUpTestConfiguration();
         config.addConfiguration(c, TEST_NAME);
         checkAddConfig(c);
         assertEquals(1, config.getNumberOfConfigurations());
         assertSame(c, config.getConfiguration(0));
         assertSame(c, config.getConfiguration(TEST_NAME));
         final Set<String> names = config.getConfigurationNames();
         assertEquals(1, names.size());
         assertTrue(names.contains(TEST_NAME));
         assertTrue(config.getBoolean(TEST_KEY));
         listener.checkEvent(1, 0);
     }
 
     /**
      * Tests adding a configuration with a name when this name already exists. This should cause an exception.
      */
     @Test
     void testAddConfigurationWithNameTwice() {
         config.addConfiguration(setUpTestConfiguration(), TEST_NAME);
         final Configuration configuration = setUpTestConfiguration();
         assertThrows(ConfigurationRuntimeException.class, () -> config.addConfiguration(configuration, TEST_NAME, "prefix"));
     }
 
     /**
      * Tests adding a null configuration. This should cause an exception to be thrown.
      */
     @Test
     void testAddNullConfiguration() {
         assertThrows(IllegalArgumentException.class, () -> config.addConfiguration(null));
     }
 
     /**
      * Tests clearing a combined configuration. This should remove all contained configurations.
      */
     @Test
     void testClear() {
         config.addConfiguration(setUpTestConfiguration(), TEST_NAME, "test");
         config.addConfiguration(setUpTestConfiguration());
 
         config.clear();
         assertEquals(0, config.getNumberOfConfigurations());
         assertTrue(config.getConfigurationNames().isEmpty());
         assertTrue(config.isEmpty());
 
         listener.checkEvent(3, 2);
     }
 
     /**
      * Tests whether the combined configuration removes itself as change listener from the child configurations on a clear
      * operation. This test is related to CONFIGURATION-572.
      */
     @Test
     void testClearRemoveChildListener() {
         final AbstractConfiguration child = setUpTestConfiguration();
         config.addConfiguration(child);
 
         config.clear();
         for (final EventListener<?> listener : child.getEventListeners(ConfigurationEvent.ANY)) {
             assertNotEquals(config, listener);
         }
     }
 
     /**
      * Tests cloning a combined configuration.
      */
     @Test
     void testClone() {
         config.addConfiguration(setUpTestConfiguration());
         config.addConfiguration(setUpTestConfiguration(), TEST_NAME, "conf2");
         config.addConfiguration(new PropertiesConfiguration(), "props");
 
         final CombinedConfiguration cc2 = (CombinedConfiguration) config.clone();
         assertNotNull(cc2.getModel().getNodeHandler().getRootNode());
         assertEquals(config.getNumberOfConfigurations(), cc2.getNumberOfConfigurations());
         assertSame(config.getNodeCombiner(), cc2.getNodeCombiner());
         assertEquals(config.getConfigurationNames().size(), cc2.getConfigurationNames().size());
         assertTrue(Collections.disjoint(cc2.getEventListeners(ConfigurationEvent.ANY), config.getEventListeners(ConfigurationEvent.ANY)));
 
         final StrictConfigurationComparator comp = new StrictConfigurationComparator();
         for (int i = 0; i < config.getNumberOfConfigurations(); i++) {
             assertNotSame(config.getConfiguration(i), cc2.getConfiguration(i), "Configuration at " + i + " was not cloned");
             assertEquals(config.getConfiguration(i).getClass(), cc2.getConfiguration(i).getClass(), "Wrong config class at " + i);
             assertTrue(comp.compare(config.getConfiguration(i), cc2.getConfiguration(i)), "Configs not equal at " + i);
         }
 
         assertTrue(comp.compare(config, cc2));
     }
 
     /**
      * Tests if the cloned configuration is decoupled from the original.
      */
     @Test
     void testCloneModify() {
         config.addConfiguration(setUpTestConfiguration(), TEST_NAME);
         final CombinedConfiguration cc2 = (CombinedConfiguration) config.clone();
         assertTrue(cc2.getConfigurationNames().contains(TEST_NAME));
         cc2.removeConfiguration(TEST_NAME);
         assertFalse(config.getConfigurationNames().isEmpty());
     }
 
     /**
      * Tests whether cloning of a configuration is correctly synchronized.
      */
     @Test
     void testCloneSynchronized() {
         setUpSourceTest();
         config.lock(LockMode.READ); // Causes the root node to be constructed
         config.unlock(LockMode.READ);
         final SynchronizerTestImpl sync = new SynchronizerTestImpl();
         config.setSynchronizer(sync);
         config.clone();
         // clone() of base class is wrapped by another read lock
         sync.verifyStart(Methods.BEGIN_READ, Methods.BEGIN_READ);
         sync.verifyEnd(Methods.END_READ, Methods.END_READ);
     }
 
     /**
      * Tests whether a combined configuration can be copied to an XML configuration. This test is related to
      * CONFIGURATION-445.
      */
     @Test
     void testCombinedCopyToXML() throws ConfigurationException {
         final XMLConfiguration x1 = new XMLConfiguration();
         x1.addProperty("key1", "value1");
         x1.addProperty("key1[@override]", "USER1");
         x1.addProperty("key2", "value2");
         x1.addProperty("key2[@override]", "USER2");
         final XMLConfiguration x2 = new XMLConfiguration();
         x2.addProperty("key2", "value2.2");
         x2.addProperty("key2[@override]", "USER2");
         config.setNodeCombiner(new OverrideCombiner());
         config.addConfiguration(x2);
         config.addConfiguration(x1);
         XMLConfiguration x3 = new XMLConfiguration(config);
         assertEquals("value2.2", x3.getString("key2"));
         assertEquals("USER2", x3.getString("key2[@override]"));
         final StringWriter w = new StringWriter();
         new FileHandler(x3).save(w);
         final String s = w.toString();
         x3 = new XMLConfiguration();
         new FileHandler(x3).load(new StringReader(s));
         assertEquals("value2.2", x3.getString("key2"));
         assertEquals("USER2", x3.getString("key2[@override]"));
     }
 
     /**
      * Tests concurrent read and write access on a combined configuration. There are multiple reader threads and a single
      * writer thread. It is checked that no inconsistencies occur.
      */
     @Test
     void testConcurrentAccess() throws ConfigurationException, InterruptedException {
         // populate the test combined configuration
         setUpSourceTest();
         final XMLConfiguration xmlConf = new XMLConfiguration();
         new FileHandler(xmlConf).load(ConfigurationAssert.getTestFile("test.xml"));
         config.addConfiguration(xmlConf);
         final PropertiesConfiguration propConf = new PropertiesConfiguration();
         new FileHandler(propConf).load(ConfigurationAssert.getTestFile("test.properties"));
         for (int i = 0; i < 8; i++) {
             config.addConfiguration(new BaseHierarchicalConfiguration());
         }
         config.getConfiguration(0).addProperty(KEY_CONCURRENT, TEST_NAME);
 
         // Set a single synchronizer for all involved configurations
         final Synchronizer sync = new ReadWriteSynchronizer();
         config.setSynchronizer(sync);
         for (final Configuration c : config.getConfigurations()) {
             c.setSynchronizer(sync);
         }
 
         // setup test threads
         final int numberOfReaders = 3;
         final int readCount = 5000;
         final int writeCount = 3000;
         final CountDownLatch latch = new CountDownLatch(1);
         final AtomicInteger errorCount = new AtomicInteger();
         final Collection<Thread> threads = new ArrayList<>(numberOfReaders + 1);
         final Thread writeThread = new WriteThread(config, latch, errorCount, writeCount);
         writeThread.start();
         threads.add(writeThread);
         for (int i = 0; i < numberOfReaders; i++) {
             final Thread readThread = new ReadThread(config, latch, errorCount, readCount);
             readThread.start();
             threads.add(readThread);
         }
 
         // perform test
         latch.countDown();
         for (final Thread t : threads) {
             t.join();
         }
         assertEquals(0, errorCount.get());
     }
 
     /**
      * Tests whether sub configurations can be created from a key.
      */
     @Test
     void testConfigurationsAt() {
         checkConfigurationsAt(false);
     }
 
     /**
      * Tests whether sub configurations can be created which are attached.
      */
     @Test
     void testConfigurationsAtWithUpdates() {
         checkConfigurationsAt(true);
     }
 
     /**
      * Tests using a conversion expression engine for child configurations with strange keys. This test is related to
      * CONFIGURATION-336.
      */
     @Test
     void testConversionExpressionEngine() {
         final PropertiesConfiguration child = new PropertiesConfiguration();
         child.setListDelimiterHandler(new DefaultListDelimiterHandler(','));
         child.addProperty("test(a)", "1,2,3");
         config.addConfiguration(child);
         final DefaultExpressionEngine engineQuery = new DefaultExpressionEngine(
             new DefaultExpressionEngineSymbols.Builder(DefaultExpressionEngineSymbols.DEFAULT_SYMBOLS).setIndexStart("<").setIndexEnd(">").create());
         config.setExpressionEngine(engineQuery);
         final DefaultExpressionEngine engineConvert = new DefaultExpressionEngine(
             new DefaultExpressionEngineSymbols.Builder(DefaultExpressionEngineSymbols.DEFAULT_SYMBOLS).setIndexStart("[").setIndexEnd("]").create());
         config.setConversionExpressionEngine(engineConvert);
         assertEquals("1", config.getString("test(a)<0>"));
         assertEquals("2", config.getString("test(a)<1>"));
         assertEquals("3", config.getString("test(a)<2>"));
     }
 
     /**
      * Tests whether escaped list delimiters are treated correctly.
      */
     @Test
     void testEscapeListDelimiters() {
         final PropertiesConfiguration sub = new PropertiesConfiguration();
         sub.setListDelimiterHandler(new DefaultListDelimiterHandler(','));
         sub.addProperty("test.pi", "3\\,1415");
         config.addConfiguration(sub);
         assertEquals("3,1415", config.getString("test.pi"));
     }
 
     /**
      * Tests whether access to a configuration by index is correctly synchronized.
      */
     @Test
     void testGetConfigurationByIdxSynchronized() {
         final SynchronizerTestImpl sync = setUpSynchronizerTest();
         assertNotNull(config.getConfiguration(0));
         sync.verify(Methods.BEGIN_READ, Methods.END_READ);
         checkCombinedRootNotConstructed();
     }
 
     /**
      * Tests whether access to a configuration by name is correctly synchronized.
      */
     @Test
     void testGetConfigurationByNameSynchronized() {
         final SynchronizerTestImpl sync = setUpSynchronizerTest();
         assertNotNull(config.getConfiguration(CHILD1));
         sync.verify(Methods.BEGIN_READ, Methods.END_READ);
         checkCombinedRootNotConstructed();
     }
 
     @Test
     void testGetConfigurationNameList() throws Exception {
         config.addConfiguration(setUpTestConfiguration());
         config.addConfiguration(setUpTestConfiguration(), TEST_NAME, "conf2");
         final AbstractConfiguration pc = new PropertiesConfiguration();
         config.addConfiguration(pc, "props");
         final List<String> list = config.getConfigurationNameList();
         assertNotNull(list);
         assertEquals(3, list.size());
         final String name = list.get(1);
         assertNotNull(name);
         assertEquals(TEST_NAME, name);
     }
 
     /**
      * Tests whether querying the name list of child configurations is synchronized.
      */
     @Test
     void testGetConfigurationNameListSynchronized() {
         final SynchronizerTestImpl sync = setUpSynchronizerTest();
         assertFalse(config.getConfigurationNameList().isEmpty());
         sync.verify(Methods.BEGIN_READ, Methods.END_READ);
         checkCombinedRootNotConstructed();
     }
 
     /**
      * Tests whether querying the name set of child configurations is synchronized.
      */
     @Test
     void testGetConfigurationNamesSynchronized() {
         final SynchronizerTestImpl sync = setUpSynchronizerTest();
         assertFalse(config.getConfigurationNames().isEmpty());
         sync.verify(Methods.BEGIN_READ, Methods.END_READ);
         checkCombinedRootNotConstructed();
     }
 
     @Test
     void testGetConfigurations() throws Exception {
         config.addConfiguration(setUpTestConfiguration());
         config.addConfiguration(setUpTestConfiguration(), TEST_NAME, "conf2");
         final AbstractConfiguration pc = new PropertiesConfiguration();
         config.addConfiguration(pc, "props");
         final List<Configuration> list = config.getConfigurations();
         assertNotNull(list);
         assertEquals(3, list.size());
         final Configuration c = list.get(2);
         assertSame(pc, c);
     }
 
     /**
      * Tests whether querying the list of child configurations is synchronized.
      */
     @Test
     void testGetConfigurationsSynchronized() {
         final SynchronizerTestImpl sync = setUpSynchronizerTest();
         assertFalse(config.getConfigurations().isEmpty());
         sync.verify(Methods.BEGIN_READ, Methods.END_READ);
         checkCombinedRootNotConstructed();
     }
 
     /**
      * Tests whether read access to the conversion expression engine is synchronized.
      */
     @Test
     void testGetConversionExpressionEngineSynchronized() {
         final SynchronizerTestImpl sync = setUpSynchronizerTest();
         assertNull(config.getConversionExpressionEngine());
         sync.verify(Methods.BEGIN_READ, Methods.END_READ);
         checkCombinedRootNotConstructed();
     }
 
     /**
      * Tests CONFIGURATION-799.
      */
     @Test
     void testGetKeys() {
         // Set up
         final BaseConfiguration conf1 = new BaseConfiguration();
         final String key = "x1";
         conf1.addProperty(key, 1);
         assertEquals(1, conf1.getProperty(key));
 
         final CombinedConfiguration conf2 = new CombinedConfiguration();
         conf2.addConfiguration(conf1, null, "");
         assertEquals(conf1, conf2.getConfiguration(0));
 
         // Actual test
         final Iterator<String> keys = conf2.getKeys();
         assertEquals(key, keys.next());
         assertFalse(keys.hasNext());
     }
 
     /**
      * Tests whether getNodeCombiner() is correctly synchronized.
      */
     @Test
     void testGetNodeCombinerSynchronized() {
         final SynchronizerTestImpl sync = setUpSynchronizerTest();
         assertNotNull(config.getNodeCombiner());
         sync.verify(Methods.BEGIN_READ, Methods.END_READ);
         checkCombinedRootNotConstructed();
     }
 
     /**
      * Tests whether querying the number of child configurations is synchronized.
      */
     @Test
     void testGetNumberOfConfigurationsSynchronized() {
         final SynchronizerTestImpl sync = setUpSynchronizerTest();
         assertEquals(2, config.getNumberOfConfigurations());
         sync.verify(Methods.BEGIN_READ, Methods.END_READ);
         checkCombinedRootNotConstructed();
     }
 
     /**
      * Tests the getSource() method when the passed in key belongs to the combined configuration itself.
      */
     @Test
     void testGetSourceCombined() {
         setUpSourceTest();
         final String key = "yet.another.key";
         config.addProperty(key, Boolean.TRUE);
         assertEquals(config, config.getSource(key));
     }
 
     /**
      * Tests the gestSource() method when the source property is defined in a hierarchical configuration.
      */
     @Test
     void testGetSourceHierarchical() {
         setUpSourceTest();
         assertEquals(config.getConfiguration(CHILD1), config.getSource(TEST_KEY));
     }
 
     /**
      * Tests the getSource() method when the passed in key refers to multiple values, which are all defined in the same
      * source configuration.
      */
     @Test
     void testGetSourceMulti() {
         setUpSourceTest();
         final String key = "list.key";
         config.getConfiguration(CHILD1).addProperty(key, "1,2,3");
         assertEquals(config.getConfiguration(CHILD1), config.getSource(key));
     }
 
     /**
      * Tests the getSource() method when the passed in key refers to multiple values defined by different sources. This
      * should cause an exception.
      */
     @Test
     void testGetSourceMultiSources() {
         setUpSourceTest();
         final String key = "list.key";
         config.getConfiguration(CHILD1).addProperty(key, "1,2,3");
         config.getConfiguration(CHILD2).addProperty(key, "a,b,c");
         assertThrows(IllegalArgumentException.class, () -> config.getSource(key));
     }
 
     /**
      * Tests whether the source configuration can be detected for non hierarchical configurations.
      */
     @Test
     void testGetSourceNonHierarchical() {
         setUpSourceTest();
         assertEquals(config.getConfiguration(CHILD2), config.getSource("another.key"));
     }
 
     /**
      * Tests the getSource() method when a null key is passed in. This should cause an exception.
      */
     @Test
     void testGetSourceNull() {
         assertThrows(IllegalArgumentException.class, () -> config.getSource(null));
     }
 
     /**
      * Tests whether multiple sources of a key can be retrieved.
      */
     @Test
     void testGetSourcesMultiSources() {
         setUpSourceTest();
         final String key = "list.key";
         config.getConfiguration(CHILD1).addProperty(key, "1,2,3");
         config.getConfiguration(CHILD2).addProperty(key, "a,b,c");
         final Set<Configuration> sources = config.getSources(key);
         assertEquals(2, sources.size());
         assertTrue(sources.contains(config.getConfiguration(CHILD1)));
         assertTrue(sources.contains(config.getConfiguration(CHILD2)));
     }
 
     /**
      * Tests getSources() for a non existing key.
      */
     @Test
     void testGetSourcesUnknownKey() {
         setUpSourceTest();
         assertTrue(config.getSources("non.existing,key").isEmpty());
     }
 
     /**
      * Tests whether getSource() is correctly synchronized.
      */
     @Test
     void testGetSourceSynchronized() {
         final SynchronizerTestImpl sync = setUpSynchronizerTest();
         assertNotNull(config.getSource(TEST_KEY));
         sync.verifyStart(Methods.BEGIN_READ);
         sync.verifyEnd(Methods.END_READ);
     }
 
     /**
      * Tests the getSource() method when the passed in key is not contained. Result should be null in this case.
      */
     @Test
     void testGetSourceUnknown() {
         setUpSourceTest();
         assertNull(config.getSource("an.unknown.key"));
     }
 
     /**
      * Tests getSource() if a child configuration is again a combined configuration.
      */
     @Test
     void testGetSourceWithCombinedChildConfiguration() {
         setUpSourceTest();
         final CombinedConfiguration cc = new CombinedConfiguration();
         cc.addConfiguration(config);
         assertEquals(config, cc.getSource(TEST_KEY));
     }
 
     /**
      * Tests accessing a newly created combined configuration.
      */
     @Test
     void testInit() {
         assertEquals(0, config.getNumberOfConfigurations());
         assertTrue(config.getConfigurationNames().isEmpty());
         assertInstanceOf(UnionCombiner.class, config.getNodeCombiner());
         assertNull(config.getConfiguration(TEST_NAME));
     }
 
     /**
      * Tests whether only a single invalidate event is fired for a change. This test is related to CONFIGURATION-315.
      */
     @Test
     void testInvalidateEventBeforeAndAfterChange() {
         ConfigurationEvent event = new ConfigurationEvent(config, ConfigurationEvent.ANY, null, null, true);
         config.onEvent(event);
         assertEquals(1, listener.invalidateEvents);
         event = new ConfigurationEvent(config, ConfigurationEvent.ANY, null, null, false);
         config.onEvent(event);
         assertEquals(1, listener.invalidateEvents);
     }
 
     /**
      * Tests whether invalidate() performs correct synchronization.
      */
     @Test
     void testInvalidateSynchronized() {
         final SynchronizerTestImpl sync = setUpSynchronizerTest();
         config.invalidate();
         sync.verify(Methods.BEGIN_WRITE, Methods.END_WRITE);
     }
 
     /**
      * Tests whether requested locks are freed correctly if an exception occurs while constructing the root node.
      */
     @Test
     void testLockHandlingWithExceptionWhenConstructingRootNode() {
         final SynchronizerTestImpl sync = setUpSynchronizerTest();
         final RuntimeException testEx = new ConfigurationRuntimeException("Test exception");
         final BaseHierarchicalConfiguration childEx = new BaseHierarchicalConfiguration() {
             @Override
             public NodeModel<ImmutableNode> getModel() {
                 throw testEx;
             }
         };
         config.addConfiguration(childEx);
         final Exception ex = assertThrows(Exception.class, () -> config.lock(LockMode.READ));
         assertEquals(testEx, ex);
         // 1 x add configuration, then obtain read lock and create root node
         sync.verify(Methods.BEGIN_WRITE, Methods.END_WRITE, Methods.BEGIN_READ, Methods.END_READ, Methods.BEGIN_WRITE, Methods.END_WRITE);
     }
 
     /**
      * Tests removing a configuration.
      */
     @Test
     void testRemoveConfiguration() {
         final AbstractConfiguration c = setUpTestConfiguration();
         config.addConfiguration(c);
         checkAddConfig(c);
         assertTrue(config.removeConfiguration(c));
         checkRemoveConfig(c);
     }
 
     /**
      * Tests removing a configuration by index.
      */
     @Test
     void testRemoveConfigurationAt() {
         final AbstractConfiguration c = setUpTestConfiguration();
         config.addConfiguration(c);
         assertSame(c, config.removeConfigurationAt(0));
         checkRemoveConfig(c);
     }
 
     /**
      * Tests removing a configuration by name.
      */
     @Test
     void testRemoveConfigurationByName() {
         final AbstractConfiguration c = setUpTestConfiguration();
         config.addConfiguration(c, TEST_NAME);
         assertSame(c, config.removeConfiguration(TEST_NAME));
         checkRemoveConfig(c);
     }
 
     /**
      * Tests removing a configuration by name, which is not contained.
      */
     @Test
     void testRemoveConfigurationByUnknownName() {
         assertNull(config.removeConfiguration("unknownName"));
         listener.checkEvent(0, 0);
     }
 
     /**
      * Tests removing a configuration with a name.
      */
     @Test
     void testRemoveNamedConfiguration() {
         final AbstractConfiguration c = setUpTestConfiguration();
         config.addConfiguration(c, TEST_NAME);
         config.removeConfiguration(c);
         checkRemoveConfig(c);
     }
 
     /**
      * Tests removing a named configuration by index.
      */
     @Test
     void testRemoveNamedConfigurationAt() {
         final AbstractConfiguration c = setUpTestConfiguration();
         config.addConfiguration(c, TEST_NAME);
         assertSame(c, config.removeConfigurationAt(0));
         checkRemoveConfig(c);
     }
 
     /**
      * Tests removing a configuration that was not added prior.
      */
     @Test
     void testRemoveNonContainedConfiguration() {
         assertFalse(config.removeConfiguration(setUpTestConfiguration()));
         listener.checkEvent(0, 0);
     }
 
     /**
      * Tests whether write access to the conversion expression engine is synchronized.
      */
     @Test
     void testSetConversionExpressionEngineSynchronized() {
         final SynchronizerTestImpl sync = setUpSynchronizerTest();
         config.setConversionExpressionEngine(new DefaultExpressionEngine(DefaultExpressionEngineSymbols.DEFAULT_SYMBOLS));
         sync.verify(Methods.BEGIN_WRITE, Methods.END_WRITE);
         checkCombinedRootNotConstructed();
     }
 
     /**
      * Tests if setting a node combiner causes an invalidation.
      */
     @Test
     void testSetNodeCombiner() {
         final NodeCombiner combiner = new UnionCombiner();
         config.setNodeCombiner(combiner);
         assertSame(combiner, config.getNodeCombiner());
         listener.checkEvent(1, 0);
     }
 
     /**
      * Tests whether setNodeCombiner() is correctly synchronized.
      */
     @Test
     void testSetNodeCombinerSynchronized() {
         final SynchronizerTestImpl sync = setUpSynchronizerTest();
         config.setNodeCombiner(new UnionCombiner());
         sync.verify(Methods.BEGIN_WRITE, Methods.END_WRITE);
         checkCombinedRootNotConstructed();
     }
 
     /**
      * Tests setting a null node combiner. This should cause an exception.
      */
     @Test
     void testSetNullNodeCombiner() {
         assertThrows(IllegalArgumentException.class, () -> config.setNodeCombiner(null));
     }
 
     /**
      * Tests whether a sub configuration survives updates of its parent.
      */
     @Test
     void testSubConfigurationWithUpdates() {
         final AbstractConfiguration srcConfig = setUpSubConfigTest();
         final HierarchicalConfiguration<ImmutableNode> sub = config.configurationAt(SUB_KEY, true);
         assertTrue(sub.getBoolean(TEST_KEY));
         srcConfig.setProperty(TEST_KEY, Boolean.FALSE);
         assertFalse(sub.getBoolean(TEST_KEY));
         assertFalse(config.getBoolean(SUB_KEY + '.' + TEST_KEY));
     }
 
     /**
      * Tests if an update of a contained configuration leeds to an invalidation of the combined configuration.
      */
     @Test
     void testUpdateContainedConfiguration() {
         final AbstractConfiguration c = setUpTestConfiguration();
         config.addConfiguration(c);
         c.addProperty("test.otherTest", "yes");
         assertEquals("yes", config.getString("test.otherTest"));
         listener.checkEvent(2, 0);
     }
 }