/*
    * 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.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 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.ArrayList;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.Map;
  
  import org.apache.commons.configuration2.ConfigurationDecoder;
  import org.apache.commons.configuration2.beanutils.BeanHelper;
  import org.apache.commons.configuration2.convert.ConversionHandler;
  import org.apache.commons.configuration2.convert.DefaultConversionHandler;
  import org.apache.commons.configuration2.convert.DefaultListDelimiterHandler;
  import org.apache.commons.configuration2.convert.ListDelimiterHandler;
  import org.apache.commons.configuration2.interpol.ConfigurationInterpolator;
  import org.apache.commons.configuration2.interpol.InterpolatorSpecification;
  import org.apache.commons.configuration2.interpol.Lookup;
  import org.apache.commons.configuration2.io.ConfigurationLogger;
  import org.apache.commons.configuration2.sync.ReadWriteSynchronizer;
  import org.apache.commons.configuration2.sync.Synchronizer;
  import org.junit.jupiter.api.BeforeEach;
  import org.junit.jupiter.api.Test;
  
  /**
   * Test class for {@code BasicBuilderParameters}.
   */
  public class TestBasicBuilderParameters {
  
      /** The instance to be tested. */
      private BasicBuilderParameters params;
  
      @BeforeEach
      public void setUp() throws Exception {
          params = new BasicBuilderParameters();
      }
  
      /**
       * Tests whether the collection with default lookups can be cloned, too.
       */
      @Test
      void testCloneDefaultLookups() {
          final Lookup look = mock(Lookup.class);
          final Collection<Lookup> looks = Collections.singleton(look);
          params.setDefaultLookups(looks);
          final BasicBuilderParameters clone = params.clone();
          Collection<?> defLooks = (Collection<?>) params.getParameters().get("defaultLookups");
          defLooks.clear();
          defLooks = (Collection<?>) clone.getParameters().get("defaultLookups");
          assertEquals(1, defLooks.size());
          assertTrue(defLooks.contains(look));
      }
  
      /**
       * Tests whether the map with prefix lookups is cloned, too.
       */
      @Test
      void testClonePrefixLookups() {
          final Lookup look = mock(Lookup.class);
          final Map<String, Lookup> lookups = Collections.singletonMap("test", look);
          params.setPrefixLookups(lookups);
          final BasicBuilderParameters clone = params.clone();
          Map<?, ?> map = (Map<?, ?>) params.getParameters().get("prefixLookups");
          map.clear();
          map = (Map<?, ?>) clone.getParameters().get("prefixLookups");
          assertEquals(1, map.size());
          assertSame(look, map.get("test"));
      }
  
      /**
       * Tests whether a cloned instance contains the same data as the original object.
       */
     @Test
     void testCloneValues() {
         final ConfigurationLogger log = mock(ConfigurationLogger.class);
         final ConfigurationInterpolator ci = mock(ConfigurationInterpolator.class);
         final ListDelimiterHandler handler1 = mock(ListDelimiterHandler.class);
         final ListDelimiterHandler handler2 = mock(ListDelimiterHandler.class);
         params.setListDelimiterHandler(handler1);
         params.setLogger(log);
         params.setInterpolator(ci);
         params.setThrowExceptionOnMissing(true);
         final BasicBuilderParameters clone = params.clone();
         params.setListDelimiterHandler(handler2);
         params.setThrowExceptionOnMissing(false);
         final Map<String, Object> map = clone.getParameters();
         assertSame(log, map.get("logger"));
         assertSame(ci, map.get("interpolator"));
         assertEquals(handler1, map.get("listDelimiterHandler"));
         assertEquals(Boolean.TRUE, map.get("throwExceptionOnMissing"));
     }
 
     /**
      * Tests the default parameter values.
      */
     @Test
     void testDefaults() {
         final Map<String, Object> paramMap = params.getParameters();
         assertTrue(paramMap.isEmpty());
     }
 
     /**
      * Tests fetchBeanHelper() if no helper was set.
      */
     @Test
     void testFetchBeanHelperNoSet() {
         assertNull(BasicBuilderParameters.fetchBeanHelper(params.getParameters()));
     }
 
     /**
      * Tries to invoke fetchBeanHelper() on a null map.
      */
     @Test
     void testFetchBeanHelperNullMap() {
         assertThrows(IllegalArgumentException.class, () -> BasicBuilderParameters.fetchBeanHelper(null));
     }
 
     /**
      * Tests whether a specification object for interpolation can be obtained.
      */
     @Test
     void testFetchInterpolatorSpecification() {
         final ConfigurationInterpolator parent = mock(ConfigurationInterpolator.class);
         final Lookup l1 = mock(Lookup.class);
         final Lookup l2 = mock(Lookup.class);
         final Lookup l3 = mock(Lookup.class);
         final Map<String, Lookup> prefixLookups = new HashMap<>();
         prefixLookups.put("p1", l1);
         prefixLookups.put("p2", l2);
         final Collection<Lookup> defLookups = Collections.singleton(l3);
         params.setParentInterpolator(parent);
         params.setPrefixLookups(prefixLookups);
         params.setDefaultLookups(defLookups);
         final Map<String, Object> map = params.getParameters();
         final InterpolatorSpecification spec = BasicBuilderParameters.fetchInterpolatorSpecification(map);
         assertSame(parent, spec.getParentInterpolator());
         assertEquals(prefixLookups, spec.getPrefixLookups());
         assertEquals(1, spec.getDefaultLookups().size());
         assertTrue(spec.getDefaultLookups().contains(l3));
     }
 
     /**
      * Tests that an empty map does not cause any problems.
      */
     @Test
     void testFetchInterpolatorSpecificationEmpty() {
         final InterpolatorSpecification spec = BasicBuilderParameters.fetchInterpolatorSpecification(params.getParameters());
         assertNull(spec.getInterpolator());
         assertTrue(spec.getDefaultLookups().isEmpty());
     }
 
     /**
      * Tests fetchInterpolatorSpecification() if the collection with default lookups contains an invalid value.
      */
     @Test
     void testFetchInterpolatorSpecificationInvalidCollectionValue() {
         final Map<String, Object> map = new HashMap<>();
         map.put("defaultLookups", Collections.singleton("not a lookup"));
         assertThrows(IllegalArgumentException.class, () -> BasicBuilderParameters.fetchInterpolatorSpecification(map));
     }
 
     /**
      * Tests fetchInterpolatorSpecification() if the map contains a property of an invalid data type.
      */
     @Test
     void testFetchInterpolatorSpecificationInvalidDataType() {
         final Map<String, Object> map = new HashMap<>();
         map.put("interpolator", this);
         assertThrows(IllegalArgumentException.class, () -> BasicBuilderParameters.fetchInterpolatorSpecification(map));
     }
 
     /**
      * Tests fetchInterpolatorSpecification() if the map with prefix lookups contains an invalid key.
      */
     @Test
     void testFetchInterpolatorSpecificationInvalidMapKey() {
         final Map<String, Object> map = new HashMap<>();
         final Map<Object, Object> prefix = new HashMap<>();
         prefix.put(42, mock(Lookup.class));
         map.put("prefixLookups", prefix);
         assertThrows(IllegalArgumentException.class, () -> BasicBuilderParameters.fetchInterpolatorSpecification(map));
     }
 
     /**
      * Tests fetchInterpolatorSpecification() if the map with prefix lookups contains an invalid value.
      */
     @Test
     void testFetchInterpolatorSpecificationInvalidMapValue() {
         final Map<String, Object> map = new HashMap<>();
         final Map<Object, Object> prefix = new HashMap<>();
         prefix.put("test", this);
         map.put("prefixLookups", prefix);
         assertThrows(IllegalArgumentException.class, () -> BasicBuilderParameters.fetchInterpolatorSpecification(map));
     }
 
     /**
      * Tries to obtain an {@code InterpolatorSpecification} from a null map.
      */
     @Test
     void testFetchInterpolatorSpecificationNull() {
         assertThrows(IllegalArgumentException.class, () -> BasicBuilderParameters.fetchInterpolatorSpecification(null));
     }
 
     /**
      * Tests whether an InterpolatorSpecification can be fetched if a ConfigurationInterpolator is present.
      */
     @Test
     void testFetchInterpolatorSpecificationWithInterpolator() {
         final ConfigurationInterpolator ci = mock(ConfigurationInterpolator.class);
         params.setInterpolator(ci);
         final InterpolatorSpecification spec = BasicBuilderParameters.fetchInterpolatorSpecification(params.getParameters());
         assertSame(ci, spec.getInterpolator());
         assertNull(spec.getParentInterpolator());
     }
 
     /**
      * Tests whether a defensive copy is created when the parameter map is returned.
      */
     @Test
     void testGetParametersDefensiveCopy() {
         final Map<String, Object> map1 = params.getParameters();
         final Map<String, Object> mapCopy = new HashMap<>(map1);
         map1.put("otherProperty", "value");
         final Map<String, Object> map2 = params.getParameters();
         assertNotSame(map1, map2);
         assertEquals(mapCopy, map2);
     }
 
     /**
      * Tests whether properties can be inherited from another parameters map.
      */
     @Test
     void testInheritFrom() {
         final BeanHelper beanHelper = new BeanHelper();
         final ConfigurationDecoder decoder = mock(ConfigurationDecoder.class);
         final ConversionHandler conversionHandler = new DefaultConversionHandler();
         final ListDelimiterHandler listDelimiterHandler = new DefaultListDelimiterHandler('#');
         final ConfigurationLogger logger = new ConfigurationLogger("test");
         final Synchronizer synchronizer = new ReadWriteSynchronizer();
         params.setBeanHelper(beanHelper).setConfigurationDecoder(decoder).setConversionHandler(conversionHandler).setListDelimiterHandler(listDelimiterHandler)
             .setLogger(logger).setSynchronizer(synchronizer).setThrowExceptionOnMissing(true);
         final BasicBuilderParameters p2 = new BasicBuilderParameters();
 
         p2.inheritFrom(params.getParameters());
         final Map<String, Object> parameters = p2.getParameters();
         assertEquals(beanHelper, parameters.get("config-BeanHelper"));
         assertEquals(decoder, parameters.get("configurationDecoder"));
         assertEquals(conversionHandler, parameters.get("conversionHandler"));
         assertEquals(listDelimiterHandler, parameters.get("listDelimiterHandler"));
         assertEquals(logger, parameters.get("logger"));
         assertEquals(synchronizer, parameters.get("synchronizer"));
         assertEquals(Boolean.TRUE, parameters.get("throwExceptionOnMissing"));
     }
 
     /**
      * Tests whether null input is handled by inheritFrom().
      */
     @Test
     void testInheritFromNull() {
         assertThrows(IllegalArgumentException.class, () -> params.inheritFrom(null));
     }
 
     /**
      * Tests that undefined properties are not copied over by inheritFrom().
      */
     @Test
     void testInheritFromUndefinedProperties() {
         final BasicBuilderParameters p2 = new BasicBuilderParameters().setThrowExceptionOnMissing(true);
 
         p2.inheritFrom(Collections.<String, Object>emptyMap());
         final Map<String, Object> parameters = p2.getParameters();
         assertEquals(Collections.singletonMap("throwExceptionOnMissing", Boolean.TRUE), parameters);
     }
 
     /**
      * Tests whether properties of other parameter objects can be merged.
      */
     @Test
     void testMerge() {
         final ListDelimiterHandler handler1 = mock(ListDelimiterHandler.class);
         final ListDelimiterHandler handler2 = mock(ListDelimiterHandler.class);
         final Map<String, Object> props = new HashMap<>();
         props.put("throwExceptionOnMissing", Boolean.TRUE);
         props.put("listDelimiterHandler", handler1);
         props.put("other", "test");
         props.put(BuilderParameters.RESERVED_PARAMETER_PREFIX + "test", "reserved");
         final BuilderParameters p = mock(BuilderParameters.class);
 
         when(p.getParameters()).thenReturn(props);
 
         params.setListDelimiterHandler(handler2);
         params.merge(p);
         final Map<String, Object> map = params.getParameters();
         assertEquals(handler2, map.get("listDelimiterHandler"));
         assertEquals(Boolean.TRUE, map.get("throwExceptionOnMissing"));
         assertEquals("test", map.get("other"));
         assertFalse(map.containsKey(BuilderParameters.RESERVED_PARAMETER_PREFIX + "test"));
 
         verify(p).getParameters();
         verifyNoMoreInteractions(p);
     }
 
     /**
      * Tries a merge with a null object.
      */
     @Test
     void testMergeNull() {
         assertThrows(IllegalArgumentException.class, () -> params.merge(null));
     }
 
     /**
      * Tests whether a BeanHelper can be set.
      */
     @Test
     void testSetBeanHelper() {
         final BeanHelper helper = new BeanHelper();
         assertSame(params, params.setBeanHelper(helper));
         assertSame(helper, BasicBuilderParameters.fetchBeanHelper(params.getParameters()));
     }
 
     /**
      * Tests whether a decoder can be set.
      */
     @Test
     void testSetConfigurationDecoder() {
         final ConfigurationDecoder decoder = mock(ConfigurationDecoder.class);
         assertSame(params, params.setConfigurationDecoder(decoder));
         assertSame(decoder, params.getParameters().get("configurationDecoder"));
     }
 
     /**
      * Tests whether a ConversionHandler can be set.
      */
     @Test
     void testSetConversionHandler() {
         final ConversionHandler handler = mock(ConversionHandler.class);
         assertSame(params, params.setConversionHandler(handler));
         assertSame(handler, params.getParameters().get("conversionHandler"));
     }
 
     /**
      * Tests whether default lookups can be set.
      */
     @Test
     void testSetDefaultLookups() {
         final Lookup look = mock(Lookup.class);
         final Collection<Lookup> looks = Collections.singleton(look);
         assertSame(params, params.setDefaultLookups(looks));
         final Collection<?> col = (Collection<?>) params.getParameters().get("defaultLookups");
         assertNotSame(col, looks);
         assertEquals(1, col.size());
         assertSame(look, col.iterator().next());
         final Collection<?> col2 = (Collection<?>) params.getParameters().get("defaultLookups");
         assertNotSame(col, col2);
     }
 
     /**
      * Tests whether null values are handled by setDefaultLookups().
      */
     @Test
     void testSetDefaultLookupsNull() {
         params.setDefaultLookups(new ArrayList<>());
         params.setDefaultLookups(null);
         assertFalse(params.getParameters().containsKey("defaultLookups"));
     }
 
     /**
      * Tests whether a {@code ConfigurationInterpolator} can be set.
      */
     @Test
     void testSetInterpolator() {
         final ConfigurationInterpolator ci = mock(ConfigurationInterpolator.class);
         assertSame(params, params.setInterpolator(ci));
         assertSame(ci, params.getParameters().get("interpolator"));
     }
 
     /**
      * Tests whether the list delimiter handler property can be set.
      */
     @Test
     void testSetListDelimiter() {
         final ListDelimiterHandler handler = mock(ListDelimiterHandler.class);
         assertSame(params, params.setListDelimiterHandler(handler));
         assertSame(handler, params.getParameters().get("listDelimiterHandler"));
     }
 
     /**
      * Tests whether the logger parameter can be set.
      */
     @Test
     void testSetLogger() {
         final ConfigurationLogger log = mock(ConfigurationLogger.class);
         assertSame(params, params.setLogger(log));
         assertSame(log, params.getParameters().get("logger"));
     }
 
     /**
      * Tests whether a custom {@code ConfigurationInterpolator} overrides settings for custom lookups.
      */
     @Test
     void testSetLookupsAndInterpolator() {
         final Lookup look1 = mock(Lookup.class);
         final Lookup look2 = mock(Lookup.class);
         final ConfigurationInterpolator parent = mock(ConfigurationInterpolator.class);
         final ConfigurationInterpolator ci = mock(ConfigurationInterpolator.class);
         params.setDefaultLookups(Collections.singleton(look1));
         params.setPrefixLookups(Collections.singletonMap("test", look2));
         params.setInterpolator(ci);
         params.setParentInterpolator(parent);
         final Map<String, Object> map = params.getParameters();
         assertFalse(map.containsKey("prefixLookups"));
         assertFalse(map.containsKey("defaultLookups"));
         assertFalse(map.containsKey("parentInterpolator"));
     }
 
     /**
      * Tests whether a parent {@code ConfigurationInterpolator} can be set.
      */
     @Test
     void testSetParentInterpolator() {
         final ConfigurationInterpolator parent = mock(ConfigurationInterpolator.class);
         assertSame(params, params.setParentInterpolator(parent));
         assertSame(parent, params.getParameters().get("parentInterpolator"));
     }
 
     /**
      * Tests whether prefix lookups can be set.
      */
     @Test
     void testSetPrefixLookups() {
         final Lookup look = mock(Lookup.class);
         final Map<String, Lookup> lookups = Collections.singletonMap("test", look);
         assertSame(params, params.setPrefixLookups(lookups));
         final Map<?, ?> map = (Map<?, ?>) params.getParameters().get("prefixLookups");
         assertNotSame(lookups, map);
         assertEquals(Collections.singletonMap("test", look), map);
         final Map<?, ?> map2 = (Map<?, ?>) params.getParameters().get("prefixLookups");
         assertNotSame(map, map2);
     }
 
     /**
      * Tests whether null values are handled by setPrefixLookups().
      */
     @Test
     void testSetPrefixLookupsNull() {
         params.setPrefixLookups(new HashMap<>());
         params.setPrefixLookups(null);
         assertFalse(params.getParameters().containsKey("prefixLookups"));
     }
 
     /**
      * Tests whether a Synchronizer can be set.
      */
     @Test
     void testSetSynchronizer() {
         final Synchronizer sync = mock(Synchronizer.class);
         assertSame(params, params.setSynchronizer(sync));
         assertSame(sync, params.getParameters().get("synchronizer"));
     }
 
     /**
      * Tests whether the throw exception on missing property can be set.
      */
     @Test
     void testSetThrowExceptionOnMissing() {
         assertSame(params, params.setThrowExceptionOnMissing(true));
         assertEquals(Boolean.TRUE, params.getParameters().get("throwExceptionOnMissing"));
     }
 }