| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package org.apache.commons.configuration2; |
| |
| import static org.junit.jupiter.api.Assertions.assertArrayEquals; |
| import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; |
| import static org.junit.jupiter.api.Assertions.assertEquals; |
| import static org.junit.jupiter.api.Assertions.assertFalse; |
| 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 static org.mockito.Mockito.mock; |
| |
| import java.io.File; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.NoSuchElementException; |
| |
| import org.apache.commons.configuration2.SynchronizerTestImpl.Methods; |
| import org.apache.commons.configuration2.convert.DefaultListDelimiterHandler; |
| import org.apache.commons.configuration2.convert.LegacyListDelimiterHandler; |
| import org.apache.commons.configuration2.convert.ListDelimiterHandler; |
| import org.apache.commons.configuration2.event.ConfigurationEvent; |
| import org.apache.commons.configuration2.event.EventListenerTestImpl; |
| import org.apache.commons.configuration2.ex.ConfigurationRuntimeException; |
| import org.apache.commons.configuration2.io.FileHandler; |
| import org.apache.commons.io.FileUtils; |
| import org.junit.jupiter.api.BeforeEach; |
| import org.junit.jupiter.api.Test; |
| |
| /** |
| * Test class for {@code CompositeConfiguration}. |
| */ |
| public class TestCompositeConfiguration { |
| /** Constant for a test property to be checked. */ |
| private static final String TEST_PROPERTY = "test.source.property"; |
| |
| protected PropertiesConfiguration conf1; |
| protected PropertiesConfiguration conf2; |
| protected XMLConfiguration xmlConf; |
| protected CompositeConfiguration cc; |
| |
| /** |
| * The File that we test with |
| */ |
| private final String testProperties = ConfigurationAssert.getTestFile("test.properties").getAbsolutePath(); |
| private final String testProperties2 = ConfigurationAssert.getTestFile("test2.properties").getAbsolutePath(); |
| private final String testPropertiesXML = ConfigurationAssert.getTestFile("test.xml").getAbsolutePath(); |
| |
| /** |
| * Helper method for testing whether the list delimiter is correctly handled. |
| */ |
| private void checkSetListDelimiterHandler() { |
| cc.addProperty("test.list", "a/b/c"); |
| cc.addProperty("test.property", "a,b,c"); |
| assertEquals(3, cc.getList("test.list").size()); |
| assertEquals("a,b,c", cc.getString("test.property")); |
| |
| final AbstractConfiguration config = (AbstractConfiguration) cc.getInMemoryConfiguration(); |
| final DefaultListDelimiterHandler listHandler = (DefaultListDelimiterHandler) config.getListDelimiterHandler(); |
| assertEquals('/', listHandler.getDelimiter()); |
| } |
| |
| /** |
| * Creates a test synchronizer and installs it at the test configuration. |
| * |
| * @return the test synchronizer |
| */ |
| private SynchronizerTestImpl installSynchronizer() { |
| cc.addConfiguration(conf1); |
| cc.addConfiguration(conf2); |
| final SynchronizerTestImpl sync = new SynchronizerTestImpl(); |
| cc.setSynchronizer(sync); |
| return sync; |
| } |
| |
| /** |
| * Prepares a test for interpolation with multiple configurations and similar properties. |
| */ |
| private void prepareInterpolationTest() { |
| final PropertiesConfiguration p = new PropertiesConfiguration(); |
| p.addProperty("foo", "initial"); |
| p.addProperty("bar", "${foo}"); |
| p.addProperty("prefix.foo", "override"); |
| |
| cc.addConfiguration(p.subset("prefix")); |
| cc.addConfiguration(p); |
| assertEquals("override", cc.getString("bar")); |
| } |
| |
| @BeforeEach |
| public void setUp() throws Exception { |
| cc = new CompositeConfiguration(); |
| final ListDelimiterHandler listHandler = new LegacyListDelimiterHandler(','); |
| conf1 = new PropertiesConfiguration(); |
| conf1.setListDelimiterHandler(listHandler); |
| final FileHandler handler1 = new FileHandler(conf1); |
| handler1.setFileName(testProperties); |
| handler1.load(); |
| conf2 = new PropertiesConfiguration(); |
| conf2.setListDelimiterHandler(listHandler); |
| final FileHandler handler2 = new FileHandler(conf2); |
| handler2.setFileName(testProperties2); |
| handler2.load(); |
| xmlConf = new XMLConfiguration(); |
| final FileHandler handler3 = new FileHandler(xmlConf); |
| handler3.load(new File(testPropertiesXML)); |
| |
| cc.setThrowExceptionOnMissing(true); |
| } |
| |
| /** |
| * Prepares a test of the getSource() method. |
| */ |
| private void setUpSourceTest() { |
| cc.addConfiguration(conf1); |
| cc.addConfiguration(conf2); |
| } |
| |
| /** |
| * Tests whether adding a child configuration is synchronized. |
| */ |
| @Test |
| public void testAddConfigurationSynchronized() { |
| final SynchronizerTestImpl sync = installSynchronizer(); |
| cc.addConfiguration(xmlConf); |
| sync.verify(Methods.BEGIN_WRITE, Methods.END_WRITE); |
| } |
| |
| @Test |
| public void testAddFirstRemoveConfigurations() throws Exception { |
| cc.addConfigurationFirst(conf1); |
| assertEquals(2, cc.getNumberOfConfigurations()); |
| cc.addConfigurationFirst(conf1); |
| assertEquals(2, cc.getNumberOfConfigurations()); |
| cc.addConfigurationFirst(conf2); |
| assertEquals(3, cc.getNumberOfConfigurations()); |
| cc.removeConfiguration(conf1); |
| assertEquals(2, cc.getNumberOfConfigurations()); |
| cc.clear(); |
| assertEquals(1, cc.getNumberOfConfigurations()); |
| } |
| |
| /** |
| * Tests adding values. Make sure they _DON'T_ override any other properties but add to the existing properties and keep |
| * sequence |
| */ |
| @Test |
| public void testAddingProperty() throws Exception { |
| cc.addConfiguration(conf1); |
| cc.addConfiguration(xmlConf); |
| |
| String[] values = cc.getStringArray("test.short"); |
| |
| assertArrayEquals(new String[] {"1"}, values); |
| |
| cc.addProperty("test.short", "88"); |
| |
| values = cc.getStringArray("test.short"); |
| |
| assertArrayEquals(new String[] {"1", "88"}, values); |
| } |
| |
| @Test |
| public void testAddRemoveConfigurations() throws Exception { |
| cc.addConfiguration(conf1); |
| assertEquals(2, cc.getNumberOfConfigurations()); |
| cc.addConfiguration(conf1); |
| assertEquals(2, cc.getNumberOfConfigurations()); |
| cc.addConfiguration(conf2); |
| assertEquals(3, cc.getNumberOfConfigurations()); |
| cc.removeConfiguration(conf1); |
| assertEquals(2, cc.getNumberOfConfigurations()); |
| cc.clear(); |
| assertEquals(1, cc.getNumberOfConfigurations()); |
| } |
| |
| @Test |
| public void testCantRemoveMemoryConfig() throws Exception { |
| cc.clear(); |
| assertEquals(1, cc.getNumberOfConfigurations()); |
| |
| final Configuration internal = cc.getConfiguration(0); |
| cc.removeConfiguration(internal); |
| |
| assertEquals(1, cc.getNumberOfConfigurations()); |
| } |
| |
| @Test |
| public void testCheckingInMemoryConfiguration() throws Exception { |
| final String TEST_KEY = "testKey"; |
| final Configuration defaults = new PropertiesConfiguration(); |
| defaults.setProperty(TEST_KEY, "testValue"); |
| final Configuration testConfiguration = new CompositeConfiguration(defaults); |
| assertTrue(testConfiguration.containsKey(TEST_KEY)); |
| assertFalse(testConfiguration.isEmpty()); |
| boolean foundTestKey = false; |
| final Iterator<String> i = testConfiguration.getKeys(); |
| // assertInstanceOf(IteratorChain.class, i); |
| // IteratorChain ic = (IteratorChain)i; |
| // assertEquals(2,i.size()); |
| while (i.hasNext()) { |
| final String key = i.next(); |
| if (key.equals(TEST_KEY)) { |
| foundTestKey = true; |
| } |
| } |
| assertTrue(foundTestKey); |
| testConfiguration.clearProperty(TEST_KEY); |
| assertFalse(testConfiguration.containsKey(TEST_KEY)); |
| } |
| |
| /** |
| * Tests setting values. These are set in memory mode only! |
| */ |
| @Test |
| public void testClearingProperty() throws Exception { |
| cc.addConfiguration(conf1); |
| cc.addConfiguration(xmlConf); |
| cc.clearProperty("test.short"); |
| assertFalse(cc.containsKey("test.short")); |
| } |
| |
| @Test |
| public void testClone() { |
| final CompositeConfiguration cc2 = (CompositeConfiguration) cc.clone(); |
| assertEquals(cc.getNumberOfConfigurations(), cc2.getNumberOfConfigurations()); |
| |
| final StrictConfigurationComparator comp = new StrictConfigurationComparator(); |
| for (int i = 0; i < cc.getNumberOfConfigurations(); i++) { |
| assertEquals(cc.getConfiguration(i).getClass(), cc2.getConfiguration(i).getClass(), "Wrong configuration class at " + i); |
| assertNotSame(cc.getConfiguration(i), cc2.getConfiguration(i)); |
| assertTrue(comp.compare(cc.getConfiguration(i), cc2.getConfiguration(i)), "Configurations at " + i + " not equal"); |
| } |
| |
| assertTrue(comp.compare(cc, cc2)); |
| } |
| |
| /** |
| * Ensures that event listeners are not cloned. |
| */ |
| @Test |
| public void testCloneEventListener() { |
| cc.addEventListener(ConfigurationEvent.ANY, new EventListenerTestImpl(null)); |
| final CompositeConfiguration cc2 = (CompositeConfiguration) cc.clone(); |
| assertTrue(cc2.getEventListeners(ConfigurationEvent.ANY).isEmpty()); |
| } |
| |
| /** |
| * Tests whether interpolation works as expected after cloning. |
| */ |
| @Test |
| public void testCloneInterpolation() { |
| final CompositeConfiguration cc2 = (CompositeConfiguration) cc.clone(); |
| assertNotSame(cc.getInterpolator(), cc2.getInterpolator()); |
| } |
| |
| /** |
| * Tests cloning if one of the contained configurations does not support this operation. This should cause an exception. |
| */ |
| @Test |
| public void testCloneNotSupported() { |
| cc.addConfiguration(new NonCloneableConfiguration()); |
| assertThrows(ConfigurationRuntimeException.class, cc::clone); |
| } |
| |
| /** |
| * Tests getting a default when the key doesn't exist |
| */ |
| @Test |
| public void testDefaultValueWhenKeyMissing() throws Exception { |
| cc.addConfiguration(conf1); |
| cc.addConfiguration(xmlConf); |
| assertEquals("default", cc.getString("bogus", "default")); |
| assertEquals(1.4, cc.getDouble("bogus", 1.4), 0.0); |
| assertEquals(1.4, cc.getDouble("bogus", 1.4), 0.0); |
| } |
| |
| /** |
| * Tests whether add property events are triggered. |
| */ |
| @Test |
| public void testEventAddProperty() { |
| final EventListenerTestImpl listener = new EventListenerTestImpl(cc); |
| cc.addEventListener(ConfigurationEvent.ANY, listener); |
| cc.addProperty("test", "value"); |
| listener.checkEvent(ConfigurationEvent.ADD_PROPERTY, "test", "value", true); |
| listener.checkEvent(ConfigurationEvent.ADD_PROPERTY, "test", "value", false); |
| listener.done(); |
| } |
| |
| /** |
| * Tests whether clear property events are triggered. |
| */ |
| @Test |
| public void testEventClearProperty() { |
| cc.addConfiguration(conf1); |
| final String key = "configuration.loaded"; |
| assertTrue(cc.getBoolean(key)); |
| final EventListenerTestImpl listener = new EventListenerTestImpl(cc); |
| cc.addEventListener(ConfigurationEvent.ANY, listener); |
| cc.clearProperty(key); |
| assertFalse(cc.containsKey(key)); |
| listener.checkEvent(ConfigurationEvent.CLEAR_PROPERTY, key, null, true); |
| listener.checkEvent(ConfigurationEvent.CLEAR_PROPERTY, key, null, false); |
| listener.done(); |
| } |
| |
| /** |
| * Tests whether set property events are triggered. |
| */ |
| @Test |
| public void testEventSetProperty() { |
| final EventListenerTestImpl listener = new EventListenerTestImpl(cc); |
| cc.addEventListener(ConfigurationEvent.ANY, listener); |
| cc.setProperty("test", "value"); |
| listener.checkEvent(ConfigurationEvent.SET_PROPERTY, "test", "value", true); |
| listener.checkEvent(ConfigurationEvent.SET_PROPERTY, "test", "value", false); |
| listener.done(); |
| } |
| |
| /** |
| * Tests whether access to a configuration by index is synchronized. |
| */ |
| @Test |
| public void testGetConfigurationSynchronized() { |
| final SynchronizerTestImpl sync = installSynchronizer(); |
| assertEquals(conf1, cc.getConfiguration(0)); |
| sync.verify(Methods.BEGIN_READ, Methods.END_READ); |
| } |
| |
| /** |
| * Tests whether access to the in-memory configuration is synchronized. |
| */ |
| @Test |
| public void testGetInMemoryConfigurationSynchronized() { |
| final SynchronizerTestImpl sync = installSynchronizer(); |
| cc.getInMemoryConfiguration(); |
| sync.verify(Methods.BEGIN_READ, Methods.END_READ); |
| } |
| |
| /** |
| * Tests {@code getKeys(String key)} preserves the order |
| */ |
| @Test |
| public void testGetKeys2PreservesOrder() throws Exception { |
| cc.addConfiguration(conf1); |
| final List<String> orderedList = new ArrayList<>(); |
| for (final Iterator<String> keys = conf1.getKeys("test"); keys.hasNext();) { |
| orderedList.add(keys.next()); |
| } |
| final List<String> iteratedList = new ArrayList<>(); |
| for (final Iterator<String> keys = cc.getKeys("test"); keys.hasNext();) { |
| iteratedList.add(keys.next()); |
| } |
| assertEquals(orderedList, iteratedList); |
| } |
| |
| /** |
| * Tests {@code getKeys} preserves the order |
| */ |
| @Test |
| public void testGetKeysPreservesOrder() throws Exception { |
| cc.addConfiguration(conf1); |
| final List<String> orderedList = new ArrayList<>(); |
| for (final Iterator<String> keys = conf1.getKeys(); keys.hasNext();) { |
| orderedList.add(keys.next()); |
| } |
| final List<String> iteratedList = new ArrayList<>(); |
| for (final Iterator<String> keys = cc.getKeys(); keys.hasNext();) { |
| iteratedList.add(keys.next()); |
| } |
| assertEquals(orderedList, iteratedList); |
| } |
| |
| @Test |
| public void testGetList() { |
| final Configuration conf1 = new BaseConfiguration(); |
| conf1.addProperty("array", "value1"); |
| conf1.addProperty("array", "value2"); |
| |
| final Configuration conf2 = new BaseConfiguration(); |
| conf2.addProperty("array", "value3"); |
| conf2.addProperty("array", "value4"); |
| |
| cc.addConfiguration(conf1); |
| cc.addConfiguration(conf2); |
| |
| // check the composite 'array' property |
| List<Object> list = cc.getList("array"); |
| assertEquals(Arrays.asList("value1", "value2"), list); |
| |
| // add an element to the list in the composite configuration |
| cc.addProperty("array", "value5"); |
| |
| // test the new list |
| list = cc.getList("array"); |
| assertEquals(Arrays.asList("value1", "value2", "value5"), list); |
| } |
| |
| /** |
| * Tests querying a list when a tricky interpolation is involved. This is related to CONFIGURATION-339. |
| */ |
| @Test |
| public void testGetListWithInterpolation() { |
| prepareInterpolationTest(); |
| final List<Object> lst = cc.getList("bar"); |
| assertEquals(Arrays.asList("override"), lst); |
| } |
| |
| /** |
| * Tests whether querying the number of child configurations is synchronized. |
| */ |
| @Test |
| public void testGetNumberOfConfigurationsSynchronized() { |
| final SynchronizerTestImpl sync = installSynchronizer(); |
| assertEquals(3, cc.getNumberOfConfigurations()); |
| sync.verify(Methods.BEGIN_READ, Methods.END_READ); |
| } |
| |
| @Test |
| public void testGetProperty() throws Exception { |
| cc.addConfiguration(conf1); |
| cc.addConfiguration(conf2); |
| assertEquals("test.properties", cc.getString("propertyInOrder")); |
| cc.clear(); |
| |
| cc.addConfiguration(conf2); |
| cc.addConfiguration(conf1); |
| assertEquals("test2.properties", cc.getString("propertyInOrder")); |
| cc.clear(); |
| |
| cc.addConfiguration(conf1); |
| cc.addConfigurationFirst(conf2); |
| assertEquals("test2.properties", cc.getString("propertyInOrder")); |
| cc.clear(); |
| } |
| |
| @Test |
| public void testGetPropertyMissing() throws Exception { |
| cc.addConfiguration(conf1); |
| cc.addConfiguration(conf2); |
| final NoSuchElementException nsee = assertThrows(NoSuchElementException.class, () -> cc.getString("bogus.property")); |
| assertTrue(nsee.getMessage().contains("bogus.property")); |
| |
| assertFalse(cc.getBoolean("test.missing.boolean", false)); |
| assertTrue(cc.getBoolean("test.missing.boolean.true", true)); |
| } |
| |
| @Test |
| public void testGetPropertyWIncludes() throws Exception { |
| cc.addConfiguration(conf1); |
| cc.addConfiguration(conf2); |
| final List<Object> l = cc.getList("packages"); |
| assertTrue(l.contains("packagea")); |
| } |
| |
| /** |
| * Tests the getSource() method for a property contained in the in memory configuration. |
| */ |
| @Test |
| public void testGetSourceInMemory() { |
| setUpSourceTest(); |
| cc.addProperty(TEST_PROPERTY, Boolean.TRUE); |
| assertSame(cc.getInMemoryConfiguration(), cc.getSource(TEST_PROPERTY)); |
| } |
| |
| /** |
| * Tests the getSource() method if the property is defined by multiple child configurations. In this case an exception |
| * should be thrown. |
| */ |
| @Test |
| public void testGetSourceMultiple() { |
| setUpSourceTest(); |
| conf1.addProperty(TEST_PROPERTY, Boolean.TRUE); |
| cc.addProperty(TEST_PROPERTY, "a value"); |
| assertThrows(IllegalArgumentException.class, () -> cc.getSource(TEST_PROPERTY)); |
| } |
| |
| /** |
| * Tests the getSource() method for a null key. This should cause an exception. |
| */ |
| @Test |
| public void testGetSourceNull() { |
| assertThrows(IllegalArgumentException.class, () -> cc.getSource(null)); |
| } |
| |
| /** |
| * Tests the getSource() method if the property is defined in a single child configuration. |
| */ |
| @Test |
| public void testGetSourceSingle() { |
| setUpSourceTest(); |
| conf1.addProperty(TEST_PROPERTY, Boolean.TRUE); |
| assertSame(conf1, cc.getSource(TEST_PROPERTY)); |
| } |
| |
| /** |
| * Tests the getSource() method for an unknown property key. |
| */ |
| @Test |
| public void testGetSourceUnknown() { |
| setUpSourceTest(); |
| assertNull(cc.getSource(TEST_PROPERTY)); |
| } |
| |
| /** |
| * Tests querying a string array when a tricky interpolation is involved. |
| */ |
| @Test |
| public void testGetStringArrayWithInterpolation() { |
| prepareInterpolationTest(); |
| final String[] values = cc.getStringArray("bar"); |
| assertArrayEquals(new String[] {"override"}, values); |
| } |
| |
| @Test |
| public void testGetStringWithDefaults() { |
| final BaseConfiguration defaults = new BaseConfiguration(); |
| defaults.addProperty("default", "default string"); |
| |
| final CompositeConfiguration c = new CompositeConfiguration(defaults); |
| c.setThrowExceptionOnMissing(cc.isThrowExceptionOnMissing()); |
| c.addProperty("string", "test string"); |
| |
| assertEquals("test string", c.getString("string")); |
| assertThrows(NoSuchElementException.class, () -> c.getString("XXX")); |
| |
| // test defaults |
| assertEquals("test string", c.getString("string", "some default value")); |
| assertEquals("default string", c.getString("default")); |
| assertEquals("default string", c.getString("default", "some default value")); |
| assertEquals("some default value", c.getString("XXX", "some default value")); |
| } |
| |
| @Test |
| public void testGettingConfiguration() throws Exception { |
| cc.addConfiguration(conf1); |
| cc.addConfiguration(xmlConf); |
| assertEquals(PropertiesConfiguration.class, cc.getConfiguration(0).getClass()); |
| assertEquals(XMLConfiguration.class, cc.getConfiguration(1).getClass()); |
| } |
| |
| /** |
| * Tests retrieving subsets of configurations |
| */ |
| @Test |
| public void testGettingSubset() throws Exception { |
| cc.addConfiguration(conf1); |
| cc.addConfiguration(xmlConf); |
| |
| Configuration subset = cc.subset("test"); |
| assertNotNull(subset); |
| assertFalse(subset.isEmpty()); |
| assertEquals("1", subset.getString("short")); |
| |
| cc.setProperty("test.short", "43"); |
| subset = cc.subset("test"); |
| assertEquals("43", subset.getString("short")); |
| } |
| |
| @Test |
| public void testInstanciateWithCollection() { |
| final Collection<Configuration> configs = new ArrayList<>(); |
| configs.add(xmlConf); |
| configs.add(conf1); |
| configs.add(conf2); |
| |
| final CompositeConfiguration config = new CompositeConfiguration(configs); |
| assertEquals(4, config.getNumberOfConfigurations()); |
| assertTrue(config.getInMemoryConfiguration().isEmpty()); |
| } |
| |
| /** |
| * Tests whether interpolation works if a variable references a property with multiple values. This test is related to |
| * CONFIGURATION-632. |
| */ |
| @Test |
| public void testInterpolationArrayReference() { |
| final Configuration props = new PropertiesConfiguration(); |
| final String[] values = {"a", "property", "with", "multiple", "values"}; |
| props.addProperty("keyMultiValues", values); |
| props.addProperty("keyReference", "${keyMultiValues}"); |
| cc.addConfiguration(props); |
| assertArrayEquals(values, cc.getStringArray("keyReference")); |
| } |
| |
| /** |
| * Tests whether interpolation works if multiple configurations are involved. This test is related to CONFIGURATION-441. |
| */ |
| @Test |
| public void testInterpolationInMultipleConfigs() { |
| final Configuration c1 = new PropertiesConfiguration(); |
| c1.addProperty("property.one", "one"); |
| c1.addProperty("property.two", "two"); |
| final Configuration c2 = new PropertiesConfiguration(); |
| c2.addProperty("property.one.ref", "${property.one}"); |
| cc.addConfiguration(c1); |
| cc.addConfiguration(c2); |
| assertEquals("one", cc.getString("property.one.ref")); |
| } |
| |
| /** |
| * Tests {@code List} parsing. |
| */ |
| @Test |
| public void testList() throws Exception { |
| cc.addConfiguration(conf1); |
| cc.addConfiguration(xmlConf); |
| |
| List<Object> packages = cc.getList("packages"); |
| // we should get 3 packages here |
| assertEquals(3, packages.size()); |
| |
| final List<Object> defaultList = new ArrayList<>(); |
| defaultList.add("1"); |
| defaultList.add("2"); |
| |
| packages = cc.getList("packages.which.dont.exist", defaultList); |
| // we should get 2 packages here |
| assertEquals(2, packages.size()); |
| |
| } |
| |
| /** |
| * Tests whether global interpolation works with lists. |
| */ |
| @Test |
| public void testListInterpolation() { |
| final PropertiesConfiguration c1 = new PropertiesConfiguration(); |
| c1.addProperty("c1.value", "test1"); |
| c1.addProperty("c1.value", "${c2.value}"); |
| cc.addConfiguration(c1); |
| final PropertiesConfiguration c2 = new PropertiesConfiguration(); |
| c2.addProperty("c2.value", "test2"); |
| cc.addConfiguration(c2); |
| final List<Object> lst = cc.getList("c1.value"); |
| assertEquals(Arrays.asList("test1", "test2"), lst); |
| } |
| |
| /** |
| * Tests {@code List} parsing. |
| */ |
| @Test |
| public void testMultipleTypesOfConfigs() throws Exception { |
| cc.addConfiguration(conf1); |
| cc.addConfiguration(xmlConf); |
| assertEquals(1, cc.getInt("test.short")); |
| cc.clear(); |
| |
| cc.addConfiguration(xmlConf); |
| cc.addConfiguration(conf1); |
| assertEquals(8, cc.getInt("test.short")); |
| } |
| |
| @Test |
| public void testPropertyExistsInOnlyOneConfig() throws Exception { |
| cc.addConfiguration(conf1); |
| cc.addConfiguration(xmlConf); |
| assertEquals("value", cc.getString("element")); |
| } |
| |
| /** |
| * Tests whether removing a child configuration is synchronized. |
| */ |
| @Test |
| public void testRemoveConfigurationSynchronized() { |
| final SynchronizerTestImpl sync = installSynchronizer(); |
| cc.removeConfiguration(conf1); |
| sync.verify(Methods.BEGIN_WRITE, Methods.END_WRITE); |
| } |
| |
| /** |
| * Tests whether the in-memory configuration can be replaced by a new child configuration. |
| */ |
| @Test |
| public void testReplaceInMemoryConfig() { |
| conf1.setProperty(TEST_PROPERTY, "conf1"); |
| conf2.setProperty(TEST_PROPERTY, "conf2"); |
| cc.addConfiguration(conf1, true); |
| cc.addProperty("newProperty1", "newValue1"); |
| cc.addConfiguration(conf2, true); |
| cc.addProperty("newProperty2", "newValue2"); |
| assertEquals("conf1", cc.getString(TEST_PROPERTY)); |
| assertEquals("newValue1", conf1.getString("newProperty1")); |
| assertEquals("newValue2", conf2.getString("newProperty2")); |
| } |
| |
| /** |
| * Tests changing the list delimiter handler. |
| */ |
| @Test |
| public void testSetListDelimiter() { |
| cc.setListDelimiterHandler(new DefaultListDelimiterHandler('/')); |
| checkSetListDelimiterHandler(); |
| } |
| |
| /** |
| * Tests whether the correct list delimiter handler is set after a clear operation. |
| */ |
| @Test |
| public void testSetListDelimiterAfterClear() { |
| cc.setListDelimiterHandler(new DefaultListDelimiterHandler('/')); |
| cc.clear(); |
| checkSetListDelimiterHandler(); |
| } |
| |
| /** |
| * Tests the behavior of setListDelimiterHandler() if the in-memory configuration is not derived from BaseConfiguration. |
| * This test is related to CONFIGURATION-476. |
| */ |
| @Test |
| public void testSetListDelimiterInMemoryConfigNonBaseConfig() { |
| final Configuration inMemoryConfig = mock(Configuration.class); |
| cc = new CompositeConfiguration(inMemoryConfig); |
| assertDoesNotThrow(() -> cc.setListDelimiterHandler(new DefaultListDelimiterHandler(';'))); |
| } |
| |
| /** |
| * Tests setting values. These are set in memory mode only! |
| */ |
| @Test |
| public void testSettingMissingProperty() throws Exception { |
| cc.addConfiguration(conf1); |
| cc.addConfiguration(xmlConf); |
| cc.setProperty("my.new.property", "supernew"); |
| assertEquals("supernew", cc.getString("my.new.property")); |
| } |
| |
| /** |
| * Tests {@code String} array parsing. |
| */ |
| @Test |
| public void testStringArray() throws Exception { |
| cc.addConfiguration(conf1); |
| cc.addConfiguration(xmlConf); |
| |
| String[] packages = cc.getStringArray("packages"); |
| // we should get 3 packages here |
| assertEquals(3, packages.length); |
| |
| packages = cc.getStringArray("packages.which.dont.exist"); |
| // we should get 0 packages here |
| assertEquals(0, packages.length); |
| } |
| |
| @Test |
| public void testStringArrayInterpolation() { |
| final CompositeConfiguration config = new CompositeConfiguration(); |
| config.addProperty("base", "foo"); |
| config.addProperty("list", "${base}.bar1"); |
| config.addProperty("list", "${base}.bar2"); |
| config.addProperty("list", "${base}.bar3"); |
| |
| final String[] array = config.getStringArray("list"); |
| assertArrayEquals(new String[] {"foo.bar1", "foo.bar2", "foo.bar3"}, array); |
| } |
| |
| /** |
| * Tests subsets and still can resolve elements |
| */ |
| @Test |
| public void testSubsetCanResolve() throws Exception { |
| cc = new CompositeConfiguration(); |
| final BaseConfiguration config = new BaseConfiguration(); |
| config.addProperty("subset.tempfile", "${java.io.tmpdir}/file.tmp"); |
| cc.addConfiguration(config); |
| cc.addConfiguration(ConfigurationConverter.getConfiguration(System.getProperties())); |
| |
| final Configuration subset = cc.subset("subset"); |
| assertEquals(FileUtils.getTempDirectoryPath() + "/file.tmp", subset.getString("tempfile")); |
| } |
| |
| @Test |
| public void testThrowExceptionOnMissing() { |
| assertTrue(cc.isThrowExceptionOnMissing()); |
| } |
| |
| /** |
| * Tests whether a configuration can act as both regular child configuration and in-memory configuration. This test is |
| * related to CONFIGURATION-471. |
| */ |
| @Test |
| public void testUseChildConfigAsInMemoryConfig() { |
| conf1.setProperty(TEST_PROPERTY, "conf1"); |
| conf2.setProperty(TEST_PROPERTY, "conf2"); |
| cc.addConfiguration(conf1, true); |
| cc.addConfiguration(conf2); |
| assertEquals(2, cc.getNumberOfConfigurations()); |
| assertEquals("conf1", cc.getString(TEST_PROPERTY)); |
| cc.addProperty("newProperty", "newValue"); |
| assertEquals("newValue", conf1.getString("newProperty")); |
| } |
| } |
