/*
    * 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.builder;
  
  import static org.junit.jupiter.api.Assertions.assertEquals;
  import static org.junit.jupiter.api.Assertions.assertFalse;
  import static org.junit.jupiter.api.Assertions.assertNotSame;
  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 static org.mockito.Mockito.mock;
  import static org.mockito.Mockito.verify;
  import static org.mockito.Mockito.verifyNoMoreInteractions;
  import static org.mockito.Mockito.when;
  
  import java.util.Collection;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Map;
  import java.util.Set;
  import java.util.concurrent.CountDownLatch;
  import java.util.concurrent.TimeUnit;
  
  import org.apache.commons.configuration2.BaseConfiguration;
  import org.apache.commons.configuration2.BaseHierarchicalConfiguration;
  import org.apache.commons.configuration2.Configuration;
  import org.apache.commons.configuration2.Initializable;
  import org.apache.commons.configuration2.PropertiesConfiguration;
  import org.apache.commons.configuration2.XMLConfiguration;
  import org.apache.commons.configuration2.beanutils.BeanCreationContext;
  import org.apache.commons.configuration2.beanutils.BeanDeclaration;
  import org.apache.commons.configuration2.beanutils.BeanFactory;
  import org.apache.commons.configuration2.beanutils.BeanHelper;
  import org.apache.commons.configuration2.beanutils.DefaultBeanFactory;
  import org.apache.commons.configuration2.beanutils.XMLBeanDeclaration;
  import org.apache.commons.configuration2.convert.DefaultListDelimiterHandler;
  import org.apache.commons.configuration2.convert.ListDelimiterHandler;
  import org.apache.commons.configuration2.event.ConfigurationErrorEvent;
  import org.apache.commons.configuration2.event.ConfigurationEvent;
  import org.apache.commons.configuration2.event.ErrorListenerTestImpl;
  import org.apache.commons.configuration2.event.EventListener;
  import org.apache.commons.configuration2.event.EventListenerRegistrationData;
  import org.apache.commons.configuration2.event.EventListenerTestImpl;
  import org.apache.commons.configuration2.ex.ConfigurationException;
  import org.apache.commons.configuration2.ex.ConfigurationRuntimeException;
  import org.apache.commons.configuration2.reloading.ReloadingController;
  import org.apache.commons.configuration2.reloading.ReloadingDetector;
  import org.junit.jupiter.api.BeforeAll;
  import org.junit.jupiter.api.Test;
  
  /**
   * Test class for {@code BasicConfigurationBuilder}.
   */
  public class TestBasicConfigurationBuilder {
  
      /**
       * A test thread class for testing whether the builder's result object can be requested concurrently.
       */
      private static final class AccessBuilderThread extends Thread {
  
          /** A latch for controlling the start of the thread. */
          private final CountDownLatch startLatch;
  
          /** A latch for controlling the end of the thread. */
          private final CountDownLatch endLatch;
  
          /** The builder to be accessed. */
          private final ConfigurationBuilder<?> builder;
  
          /** The result object obtained from the builder. */
          private volatile Object result;
  
          /**
           * Creates a new instance of {@code AccessBuilderThread}.
           *
           * @param lstart the latch for controlling the thread start
           * @param lend the latch for controlling the thread end
           * @param bldr the builder to be tested
           */
          public AccessBuilderThread(final CountDownLatch lstart, final CountDownLatch lend, final ConfigurationBuilder<?> bldr) {
              startLatch = lstart;
              endLatch = lend;
              builder = bldr;
          }
  
         @Override
         public void run() {
             try {
                 startLatch.await();
                 result = builder.getConfiguration();
             } catch (final Exception ex) {
                 result = ex;
             } finally {
                 endLatch.countDown();
             }
         }
     }
 
     /**
      * A builder test implementation which allows checking exception handling when creating new configuration objects.
      */
     private static final class BasicConfigurationBuilderInitFailImpl extends BasicConfigurationBuilder<PropertiesConfiguration> {
         public BasicConfigurationBuilderInitFailImpl(final boolean allowFailOnInit) {
             super(PropertiesConfiguration.class, null, allowFailOnInit);
         }
 
         /**
          * {@inheritDoc} This implementation only throws an exception.
          */
         @Override
         protected void initResultInstance(final PropertiesConfiguration obj) throws ConfigurationException {
             throw new ConfigurationException("Initialization test exception.");
         }
     }
 
     /**
      * A test configuration implementation which also implements Initializable.
      */
     public static class InitializableConfiguration extends BaseConfiguration implements Initializable {
 
         /** A property which is initialized if the builder works as expected. */
         private String initProperty;
 
         public String getInitProperty() {
             return initProperty;
         }
 
         /**
          * Sets the value of the initProperty member based on other flag values. This tests whether the method is called after
          * other properties have been set.
          */
         @Override
         public void initialize() {
             initProperty = "Initialized with flag " + isThrowExceptionOnMissing();
         }
     }
 
     /** A test list delimiter handler. */
     private static ListDelimiterHandler listHandler;
 
     /**
      * Creates a mock for an event listener.
      *
      * @return the event listener mock
      */
     @SuppressWarnings("unchecked")
     private static EventListener<ConfigurationEvent> createEventListener() {
         return mock(EventListener.class);
     }
 
     /**
      * Creates a map with test initialization parameters.
      *
      * @return the map with parameters
      */
     private static Map<String, Object> createTestParameters() {
         final Map<String, Object> params = new HashMap<>();
         params.put("throwExceptionOnMissing", Boolean.TRUE);
         params.put("listDelimiterHandler", listHandler);
         return params;
     }
 
     @BeforeAll
     public static void setUpBeforeClass() throws Exception {
         listHandler = new DefaultListDelimiterHandler(';');
     }
 
     /**
      * Tests whether configuration listeners can be added.
      */
     @Test
     void testAddConfigurationListener() throws ConfigurationException {
         final EventListener<ConfigurationEvent> l1 = createEventListener();
         final EventListener<ConfigurationEvent> l2 = createEventListener();
         final BasicConfigurationBuilder<PropertiesConfiguration> builder = new BasicConfigurationBuilder<>(PropertiesConfiguration.class);
         builder.addEventListener(ConfigurationEvent.ANY, l1);
         final PropertiesConfiguration config = builder.getConfiguration();
         builder.addEventListener(ConfigurationEvent.ANY, l2);
         final Collection<EventListener<? super ConfigurationEvent>> listeners = config.getEventListeners(ConfigurationEvent.ANY);
         assertTrue(listeners.contains(l1));
         assertTrue(listeners.contains(l2));
     }
 
     /**
      * Tests whether additional parameters can be added.
      */
     @Test
     void testAddParameters() {
         final BasicConfigurationBuilder<PropertiesConfiguration> builder = new BasicConfigurationBuilder<>(PropertiesConfiguration.class,
             createTestParameters());
         final Map<String, Object> params = createTestParameters();
         params.put("anotherParameter", "value");
         assertSame(builder, builder.addParameters(params));
         final Map<String, Object> params2 = builder.getParameters();
         assertTrue(params2.keySet().containsAll(createTestParameters().keySet()));
         assertEquals("value", params2.get("anotherParameter"));
     }
 
     /**
      * Tests whether null parameters are handled correctly by addParameters().
      */
     @Test
     void testAddParametersNull() {
         final BasicConfigurationBuilder<PropertiesConfiguration> builder = new BasicConfigurationBuilder<>(PropertiesConfiguration.class,
             createTestParameters());
         final Map<String, Object> params = builder.getParameters();
         builder.addParameters(null);
         assertEquals(params, builder.getParameters());
     }
 
     /**
      * Tests whether a configured BeanHelper is used for result creation.
      */
     @Test
     void testBeanHelperInConfiguration() throws ConfigurationException {
         final Set<Class<?>> classesPassedToFactory = new HashSet<>();
         final BeanFactory factory = new DefaultBeanFactory() {
             @Override
             public Object createBean(final BeanCreationContext bcc) throws Exception {
                 classesPassedToFactory.add(bcc.getBeanClass());
                 return super.createBean(bcc);
             }
         };
         final BeanHelper helper = new BeanHelper(factory);
         final BasicConfigurationBuilder<PropertiesConfiguration> builder = new BasicConfigurationBuilder<>(PropertiesConfiguration.class);
         builder.configure(new BasicBuilderParameters().setBeanHelper(helper));
         final PropertiesConfiguration config = builder.getConfiguration();
         assertTrue(classesPassedToFactory.contains(config.getClass()));
     }
 
     /**
      * Tests whether parameters can be set using the configure() method.
      */
     @Test
     void testConfigure() {
         final BasicConfigurationBuilder<PropertiesConfiguration> builder = new BasicConfigurationBuilder<>(PropertiesConfiguration.class)
             .configure(new BasicBuilderParameters().setListDelimiterHandler(listHandler).setThrowExceptionOnMissing(true));
         final Map<String, Object> params2 = new HashMap<>(builder.getParameters());
         assertEquals(createTestParameters(), params2);
     }
 
     /**
      * Tests whether a builder can be connected to a reloading controller.
      */
     @Test
     void testConnectToReloadingController() throws ConfigurationException {
         final ReloadingDetector detector = mock(ReloadingDetector.class);
         final ReloadingController controller = new ReloadingController(detector);
         final BasicConfigurationBuilder<Configuration> builder = new BasicConfigurationBuilder<>(PropertiesConfiguration.class);
         final Configuration configuration = builder.getConfiguration();
 
         when(detector.isReloadingRequired()).thenReturn(Boolean.TRUE);
 
         builder.connectToReloadingController(controller);
         controller.checkForReloading(null);
         assertTrue(controller.isInReloadingState());
         assertNotSame(configuration, builder.getConfiguration());
         assertFalse(controller.isInReloadingState());
 
         verify(detector).isReloadingRequired();
         verify(detector).reloadingPerformed();
         verifyNoMoreInteractions(detector);
     }
 
     /**
      * Tries to connect to a null reloading controller.
      */
     @Test
     void testConnectToReloadingControllerNull() {
         final BasicConfigurationBuilder<Configuration> builder = new BasicConfigurationBuilder<>(PropertiesConfiguration.class);
         assertThrows(IllegalArgumentException.class, () -> builder.connectToReloadingController(null));
     }
 
     /**
      * Tests whether event listeners can be copied to another builder.
      */
     @Test
     void testCopyEventListeners() throws ConfigurationException {
         final EventListener<ConfigurationEvent> l1 = createEventListener();
         final EventListener<ConfigurationEvent> l2 = createEventListener();
         final EventListener<ConfigurationErrorEvent> l3 = new ErrorListenerTestImpl(null);
         final BasicConfigurationBuilder<PropertiesConfiguration> builder = new BasicConfigurationBuilder<>(PropertiesConfiguration.class);
         builder.addEventListener(ConfigurationEvent.ANY, l1);
         builder.addEventListener(ConfigurationEvent.ANY_HIERARCHICAL, l2);
         builder.addEventListener(ConfigurationErrorEvent.ANY, l3);
         final BasicConfigurationBuilder<XMLConfiguration> builder2 = new BasicConfigurationBuilder<>(XMLConfiguration.class);
         builder.copyEventListeners(builder2);
         final XMLConfiguration config = builder2.getConfiguration();
         Collection<EventListener<? super ConfigurationEvent>> listeners = config.getEventListeners(ConfigurationEvent.ANY);
         assertEquals(1, listeners.size());
         assertTrue(listeners.contains(l1));
         listeners = config.getEventListeners(ConfigurationEvent.ANY_HIERARCHICAL);
         assertEquals(2, listeners.size());
         assertTrue(listeners.contains(l1));
         assertTrue(listeners.contains(l2));
         final Collection<EventListener<? super ConfigurationErrorEvent>> errListeners = config.getEventListeners(ConfigurationErrorEvent.ANY);
         assertEquals(1, errListeners.size());
         assertTrue(errListeners.contains(l3));
     }
 
     /**
      * Tests whether configuration listeners can be defined via the configure() method.
      */
     @Test
     void testEventListenerConfiguration() throws ConfigurationException {
         final EventListenerTestImpl listener1 = new EventListenerTestImpl(null);
         final EventListenerRegistrationData<ConfigurationErrorEvent> regData = new EventListenerRegistrationData<>(ConfigurationErrorEvent.WRITE,
             new ErrorListenerTestImpl(null));
         final BasicConfigurationBuilder<PropertiesConfiguration> builder = new BasicConfigurationBuilder<>(PropertiesConfiguration.class)
             .configure(new EventListenerParameters().addEventListener(ConfigurationEvent.ANY, listener1).addEventListener(regData));
         final PropertiesConfiguration config = builder.getConfiguration();
         assertTrue(config.getEventListeners(ConfigurationEvent.ANY).contains(listener1));
         assertTrue(config.getEventListeners(regData.getEventType()).contains(regData.getListener()));
     }
 
     /**
      * Tests whether the builder can create a correctly initialized configuration object.
      */
     @Test
     void testGetConfiguration() throws ConfigurationException {
         final PropertiesConfiguration config = new BasicConfigurationBuilder<>(PropertiesConfiguration.class)
             .configure(new BasicBuilderParameters().setListDelimiterHandler(listHandler).setThrowExceptionOnMissing(true)).getConfiguration();
         assertTrue(config.isThrowExceptionOnMissing());
         assertEquals(listHandler, config.getListDelimiterHandler());
     }
 
     /**
      * Tests whether the builder can be accessed by multiple threads and that only a single result object is produced.
      */
     @Test
     void testGetConfigurationConcurrently() throws Exception {
         final int threadCount = 32;
         final CountDownLatch startLatch = new CountDownLatch(1);
         final CountDownLatch endLatch = new CountDownLatch(threadCount);
         final ConfigurationBuilder<?> builder = new BasicConfigurationBuilder<>(PropertiesConfiguration.class);
         final AccessBuilderThread[] threads = new AccessBuilderThread[threadCount];
         for (int i = 0; i < threadCount; i++) {
             threads[i] = new AccessBuilderThread(startLatch, endLatch, builder);
             threads[i].start();
         }
         startLatch.countDown();
         assertTrue(endLatch.await(5, TimeUnit.SECONDS));
         final Set<Object> results = new HashSet<>();
         for (final AccessBuilderThread t : threads) {
             results.add(t.result);
         }
         assertEquals(1, results.size());
     }
 
     /**
      * Tests that the map with parameters cannot be modified.
      */
     @Test
     void testGetParametersModify() {
         final BasicConfigurationBuilder<PropertiesConfiguration> builder = new BasicConfigurationBuilder<>(PropertiesConfiguration.class,
             createTestParameters());
         final Map<String, Object> parameters = builder.getParameters();
         assertThrows(UnsupportedOperationException.class, parameters::clear);
     }
 
     /**
      * Tests whether a check for the correct bean class is made.
      */
     @Test
     void testGetResultDeclarationInvalidBeanClass() {
         final BasicConfigurationBuilder<PropertiesConfiguration> builder = new BasicConfigurationBuilder<PropertiesConfiguration>(PropertiesConfiguration.class,
             createTestParameters()) {
             @Override
             protected BeanDeclaration createResultDeclaration(final Map<String, Object> params) {
                 return new XMLBeanDeclaration(new BaseHierarchicalConfiguration(), "bean", true, Object.class.getName());
             }
         };
         assertThrows(ConfigurationRuntimeException.class, builder::getConfiguration);
     }
 
     /**
      * Tests whether a configuration implementing {@code Initializable} is correctly handled.
      */
     @Test
     void testInitializableCalled() throws ConfigurationException {
         final BasicConfigurationBuilder<InitializableConfiguration> builder = new BasicConfigurationBuilder<>(InitializableConfiguration.class);
         builder.configure(new BasicBuilderParameters().setThrowExceptionOnMissing(true));
         final InitializableConfiguration config = builder.getConfiguration();
         assertEquals("Initialized with flag true", config.getInitProperty());
     }
 
     /**
      * Tests an exception during configuration initialization if the allowFailOnInit flag is true.
      */
     @Test
     void testInitializationErrorAllowed() throws ConfigurationException {
         final BasicConfigurationBuilderInitFailImpl builder = new BasicConfigurationBuilderInitFailImpl(true);
         final PropertiesConfiguration config = builder.getConfiguration();
         assertTrue(config.isEmpty());
     }
 
     /**
      * Tests an exception during configuration initialization if the allowFailOnInit flag is false.
      */
     @Test
     void testInitializationErrorNotAllowed() {
         final BasicConfigurationBuilderInitFailImpl builder = new BasicConfigurationBuilderInitFailImpl(false);
         assertThrows(ConfigurationException.class, builder::getConfiguration);
     }
 
     /**
      * Tries to create an instance without a result class.
      */
     @Test
     void testInitNoClass() {
         assertThrows(IllegalArgumentException.class, () -> new BasicConfigurationBuilder<Configuration>(null));
     }
 
     /**
      * Tests whether initialization parameters can be passed to the constructor.
      */
     @Test
     void testInitWithParameters() {
         final Map<String, Object> params = createTestParameters();
         final BasicConfigurationBuilder<Configuration> builder = new BasicConfigurationBuilder<>(PropertiesConfiguration.class, params);
         final Map<String, Object> params2 = new HashMap<>(builder.getParameters());
         assertEquals(createTestParameters(), params2);
     }
 
     /**
      * Tests whether a copy of the passed in parameters is created.
      */
     @Test
     void testInitWithParametersDefensiveCopy() {
         final Map<String, Object> params = createTestParameters();
         final BasicConfigurationBuilder<PropertiesConfiguration> builder = new BasicConfigurationBuilder<>(PropertiesConfiguration.class, params);
         params.put("anotherParameter", "value");
         final Map<String, Object> params2 = new HashMap<>(builder.getParameters());
         assertEquals(createTestParameters(), params2);
     }
 
     /**
      * Tests whether null parameters are handled correctly.
      */
     @Test
     void testInitWithParametersNull() {
         final BasicConfigurationBuilder<PropertiesConfiguration> builder = new BasicConfigurationBuilder<>(PropertiesConfiguration.class, null);
         assertTrue(builder.getParameters().isEmpty());
     }
 
     /**
      * Tests whether configuration listeners can be removed.
      */
     @Test
     void testRemoveConfigurationListener() throws ConfigurationException {
         final EventListener<ConfigurationEvent> l1 = createEventListener();
         final EventListener<ConfigurationEvent> l2 = createEventListener();
         final BasicConfigurationBuilder<PropertiesConfiguration> builder = new BasicConfigurationBuilder<>(PropertiesConfiguration.class);
         builder.addEventListener(ConfigurationEvent.ANY_HIERARCHICAL, l1);
         builder.addEventListener(ConfigurationEvent.ANY, l2);
         assertTrue(builder.removeEventListener(ConfigurationEvent.ANY, l2));
         final PropertiesConfiguration config = builder.getConfiguration();
         assertFalse(config.getEventListeners(ConfigurationEvent.ANY).contains(l2));
         assertTrue(config.getEventListeners(ConfigurationEvent.ANY_HIERARCHICAL).contains(l1));
         builder.removeEventListener(ConfigurationEvent.ANY_HIERARCHICAL, l1);
         assertFalse(config.getEventListeners(ConfigurationEvent.ANY_HIERARCHICAL).contains(l1));
     }
 
     /**
      * Tests whether configuration listeners are removed from the managed configuration when the builder's result object is
      * reset.
      */
     @Test
     void testRemoveConfigurationListenersOnReset() throws ConfigurationException {
         final EventListenerTestImpl listener = new EventListenerTestImpl(null);
         final BasicConfigurationBuilder<PropertiesConfiguration> builder = new BasicConfigurationBuilder<>(PropertiesConfiguration.class)
             .configure(new EventListenerParameters().addEventListener(ConfigurationEvent.ANY, listener));
         final PropertiesConfiguration config = builder.getConfiguration();
         builder.resetResult();
         config.addProperty("foo", "bar");
         listener.done();
     }
 
     /**
      * Tests whether parameters starting with a reserved prefix are filtered out before result objects are initialized.
      */
     @Test
     void testReservedParameter() throws ConfigurationException {
         final Map<String, Object> params = new HashMap<>();
         params.put("throwExceptionOnMissing", Boolean.TRUE);
         params.put("config-test", "a test");
         final BasicConfigurationBuilder<PropertiesConfiguration> builder = new BasicConfigurationBuilder<>(PropertiesConfiguration.class, params);
         final PropertiesConfiguration config = builder.getConfiguration();
         assertTrue(config.isThrowExceptionOnMissing());
     }
 
     /**
      * Tests a full reset of the builder.
      */
     @Test
     void testReset() throws ConfigurationException {
         final BasicConfigurationBuilder<PropertiesConfiguration> builder = new BasicConfigurationBuilder<>(PropertiesConfiguration.class,
             createTestParameters());
         final PropertiesConfiguration config = builder.getConfiguration();
         builder.reset();
         final PropertiesConfiguration config2 = builder.getConfiguration();
         assertNotSame(config, config2);
         assertFalse(config2.isThrowExceptionOnMissing());
     }
 
     /**
      * Tests whether all parameters can be reset.
      */
     @Test
     void testResetParameters() {
         final BasicConfigurationBuilder<PropertiesConfiguration> builder = new BasicConfigurationBuilder<>(PropertiesConfiguration.class,
             createTestParameters());
         builder.resetParameters();
         assertTrue(builder.getParameters().isEmpty());
     }
 
     /**
      * Tests whether a reset of the result object can be performed.
      */
     @Test
     void testResetResult() throws ConfigurationException {
         final BasicConfigurationBuilder<PropertiesConfiguration> builder = new BasicConfigurationBuilder<>(PropertiesConfiguration.class,
             createTestParameters());
         final PropertiesConfiguration config = builder.getConfiguration();
         builder.resetResult();
         final PropertiesConfiguration config2 = builder.getConfiguration();
         assertNotSame(config, config2);
         assertTrue(config2.isThrowExceptionOnMissing());
     }
 
     /**
      * Tests whether new parameters can be set to replace existing ones.
      */
     @Test
     void testSetParameters() {
         final Map<String, Object> params1 = new HashMap<>();
         params1.put("someParameter", "value");
         final BasicConfigurationBuilder<PropertiesConfiguration> builder = new BasicConfigurationBuilder<>(PropertiesConfiguration.class, params1);
         assertSame(builder, builder.setParameters(createTestParameters()));
         final Map<String, Object> params2 = new HashMap<>(builder.getParameters());
         assertEquals(createTestParameters(), params2);
     }
 }