src/test/java/org/apache/commons/configuration2/builder/TestBasicBuilderParameters.java - commons-configuration - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *     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"));
     }
 }
	/*
	* 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"));
	}
	}