| /* |
| * 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.apache.commons.configuration2.TempDirUtils.newFile; |
| import static org.hamcrest.CoreMatchers.containsString; |
| import static org.hamcrest.MatcherAssert.assertThat; |
| import static org.hamcrest.Matchers.containsInAnyOrder; |
| import static org.hamcrest.Matchers.not; |
| import static org.junit.jupiter.api.Assertions.assertArrayEquals; |
| import static org.junit.jupiter.api.Assertions.assertEquals; |
| import static org.junit.jupiter.api.Assertions.assertFalse; |
| import static org.junit.jupiter.api.Assertions.assertInstanceOf; |
| import static org.junit.jupiter.api.Assertions.assertNotNull; |
| import static org.junit.jupiter.api.Assertions.assertNotSame; |
| import static org.junit.jupiter.api.Assertions.assertNull; |
| import static org.junit.jupiter.api.Assertions.assertSame; |
| import static org.junit.jupiter.api.Assertions.assertThrows; |
| import static org.junit.jupiter.api.Assertions.assertTrue; |
| |
| import java.beans.beancontext.BeanContextServicesSupport; |
| import java.beans.beancontext.BeanContextSupport; |
| import java.io.BufferedReader; |
| import java.io.ByteArrayInputStream; |
| import java.io.File; |
| import java.io.FileOutputStream; |
| import java.io.FileReader; |
| import java.io.FileWriter; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.io.Reader; |
| import java.io.StringReader; |
| import java.io.StringWriter; |
| import java.io.Writer; |
| import java.net.HttpURLConnection; |
| import java.net.URL; |
| import java.net.URLConnection; |
| import java.net.URLStreamHandler; |
| import java.nio.charset.StandardCharsets; |
| import java.nio.file.FileSystems; |
| import java.nio.file.Files; |
| import java.nio.file.Paths; |
| import java.util.ArrayDeque; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.PriorityQueue; |
| import java.util.Properties; |
| import java.util.Set; |
| |
| import org.apache.commons.collections.IteratorUtils; |
| import org.apache.commons.configuration2.SynchronizerTestImpl.Methods; |
| import org.apache.commons.configuration2.builder.FileBasedBuilderParametersImpl; |
| import org.apache.commons.configuration2.builder.FileBasedConfigurationBuilder; |
| import org.apache.commons.configuration2.builder.combined.CombinedConfigurationBuilder; |
| import org.apache.commons.configuration2.builder.fluent.Parameters; |
| import org.apache.commons.configuration2.convert.DefaultListDelimiterHandler; |
| import org.apache.commons.configuration2.convert.DisabledListDelimiterHandler; |
| 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.ex.ConfigurationException; |
| import org.apache.commons.configuration2.io.DefaultFileSystem; |
| import org.apache.commons.configuration2.io.FileHandler; |
| import org.apache.commons.configuration2.io.FileSystem; |
| import org.apache.commons.lang3.mutable.MutableObject; |
| import org.junit.jupiter.api.BeforeEach; |
| import org.junit.jupiter.api.Test; |
| import org.junit.jupiter.api.io.TempDir; |
| import org.junit.jupiter.params.ParameterizedTest; |
| import org.junit.jupiter.params.provider.ValueSource; |
| |
| /** |
| * Test for loading and saving properties files. |
| */ |
| public class TestPropertiesConfiguration { |
| /** |
| * A dummy layout implementation for checking whether certain methods are correctly called by the configuration. |
| */ |
| static class DummyLayout extends PropertiesConfigurationLayout { |
| /** Stores the number how often load() was called. */ |
| public int loadCalls; |
| |
| @Override |
| public void load(final PropertiesConfiguration config, final Reader in) throws ConfigurationException { |
| loadCalls++; |
| } |
| } |
| |
| /** |
| * A mock implementation of a HttpURLConnection used for testing saving to a HTTP server. |
| */ |
| static class MockHttpURLConnection extends HttpURLConnection { |
| /** The response code to return. */ |
| private final int returnCode; |
| |
| /** The output file. The output stream will point to this file. */ |
| private final File outputFile; |
| |
| protected MockHttpURLConnection(final URL u, final int respCode, final File outFile) { |
| super(u); |
| returnCode = respCode; |
| outputFile = outFile; |
| } |
| |
| @Override |
| public void connect() throws IOException { |
| } |
| |
| @Override |
| public void disconnect() { |
| } |
| |
| @Override |
| public OutputStream getOutputStream() throws IOException { |
| return new FileOutputStream(outputFile); |
| } |
| |
| @Override |
| public int getResponseCode() throws IOException { |
| return returnCode; |
| } |
| |
| @Override |
| public boolean usingProxy() { |
| return false; |
| } |
| } |
| |
| /** |
| * A mock stream handler for working with the mock HttpURLConnection. |
| */ |
| static class MockHttpURLStreamHandler extends URLStreamHandler { |
| /** Stores the response code. */ |
| private final int responseCode; |
| |
| /** Stores the output file. */ |
| private final File outputFile; |
| |
| /** Stores the connection. */ |
| private MockHttpURLConnection connection; |
| |
| public MockHttpURLStreamHandler(final int respCode, final File outFile) { |
| responseCode = respCode; |
| outputFile = outFile; |
| } |
| |
| public MockHttpURLConnection getMockConnection() { |
| return connection; |
| } |
| |
| @Override |
| protected URLConnection openConnection(final URL u) throws IOException { |
| connection = new MockHttpURLConnection(u, responseCode, outputFile); |
| return connection; |
| } |
| } |
| |
| /** |
| * A test PropertiesReader for testing whether a custom reader can be injected. This implementation creates a |
| * configurable number of synthetic test properties. |
| */ |
| private static final class PropertiesReaderTestImpl extends PropertiesConfiguration.PropertiesReader { |
| /** The number of test properties to be created. */ |
| private final int maxProperties; |
| |
| /** The current number of properties. */ |
| private int propertyCount; |
| |
| public PropertiesReaderTestImpl(final Reader reader, final int maxProps) { |
| super(reader); |
| maxProperties = maxProps; |
| } |
| |
| @Override |
| public String getPropertyName() { |
| return PROP_NAME + propertyCount; |
| } |
| |
| @Override |
| public String getPropertyValue() { |
| return PROP_VALUE + propertyCount; |
| } |
| |
| @Override |
| public boolean nextProperty() throws IOException { |
| propertyCount++; |
| return propertyCount <= maxProperties; |
| } |
| } |
| |
| /** |
| * A test PropertiesWriter for testing whether a custom writer can be injected. This implementation simply redirects all |
| * output into a test file. |
| */ |
| private static final class PropertiesWriterTestImpl extends PropertiesConfiguration.PropertiesWriter { |
| public PropertiesWriterTestImpl(final ListDelimiterHandler handler) throws IOException { |
| super(new FileWriter(testSavePropertiesFile), handler); |
| } |
| } |
| |
| /** Constant for a test property name. */ |
| private static final String PROP_NAME = "testProperty"; |
| /** Constant for a test property value. */ |
| private static final String PROP_VALUE = "value"; |
| /** Constant for the line break character. */ |
| private static final String CR = System.lineSeparator(); |
| |
| /** The File that we test with */ |
| private static final String testProperties = ConfigurationAssert.getTestFile("test.properties").getAbsolutePath(); |
| |
| private static final String testBasePath = ConfigurationAssert.TEST_DIR.getAbsolutePath(); |
| |
| private static final String testBasePath2 = ConfigurationAssert.TEST_DIR.getParentFile().getAbsolutePath(); |
| |
| private static final File testSavePropertiesFile = ConfigurationAssert.getOutFile("testsave.properties"); |
| |
| /** |
| * Helper method for loading a configuration from a given file. |
| * |
| * @param pc the configuration to be loaded |
| * @param fileName the file name |
| * @return the file handler associated with the configuration |
| * @throws ConfigurationException if an error occurs |
| */ |
| private static FileHandler load(final PropertiesConfiguration pc, final String fileName) throws ConfigurationException { |
| final FileHandler handler = new FileHandler(pc); |
| handler.setFileName(fileName); |
| handler.load(); |
| return handler; |
| } |
| |
| /** The configuration to be tested. */ |
| private PropertiesConfiguration conf; |
| |
| /** A folder for temporary files. */ |
| @TempDir |
| public File tempFolder; |
| |
| /** |
| * Helper method for testing the content of a list with elements that contain backslashes. |
| * |
| * @param key the key |
| */ |
| private void checkBackslashList(final String key) { |
| final Object prop = conf.getProperty("test." + key); |
| final List<?> list = assertInstanceOf(List.class, prop); |
| final String prefix = "\\\\" + key; |
| assertEquals(Arrays.asList(prefix + "a", prefix + "b"), list); |
| } |
| |
| /** |
| * Tests whether the data of a configuration that was copied into the test configuration is correctly saved. |
| * |
| * @param copyConf the copied configuration |
| * @throws ConfigurationException if an error occurs |
| */ |
| private void checkCopiedConfig(final Configuration copyConf) throws ConfigurationException { |
| saveTestConfig(); |
| final PropertiesConfiguration checkConf = new PropertiesConfiguration(); |
| load(checkConf, testSavePropertiesFile.getAbsolutePath()); |
| for (final Iterator<String> it = copyConf.getKeys(); it.hasNext();) { |
| final String key = it.next(); |
| assertEquals(checkConf.getProperty(key), copyConf.getProperty(key), "Wrong value for property " + key); |
| } |
| } |
| |
| /** |
| * Checks for a property without a value. |
| * |
| * @param key the key to be checked |
| */ |
| private void checkEmpty(final String key) { |
| final String empty = conf.getString(key); |
| assertNotNull(empty, "Property not found: " + key); |
| assertEquals("", empty, "Wrong value for property " + key); |
| } |
| |
| /** |
| * Helper method for testing a saved configuration. Reads in the file using a new instance and compares this instance |
| * with the original one. |
| * |
| * @return the newly created configuration instance |
| * @throws ConfigurationException if an error occurs |
| */ |
| private PropertiesConfiguration checkSavedConfig() throws ConfigurationException { |
| final PropertiesConfiguration checkConfig = new PropertiesConfiguration(); |
| checkConfig.setListDelimiterHandler(new LegacyListDelimiterHandler(',')); |
| load(checkConfig, testSavePropertiesFile.getAbsolutePath()); |
| ConfigurationAssert.assertConfigurationEquals(conf, checkConfig); |
| return checkConfig; |
| } |
| |
| /** |
| * Saves the test configuration to a default output file. |
| * |
| * @throws ConfigurationException if an error occurs |
| */ |
| private void saveTestConfig() throws ConfigurationException { |
| final FileHandler handler = new FileHandler(conf); |
| handler.save(testSavePropertiesFile); |
| } |
| |
| @BeforeEach |
| public void setUp() throws Exception { |
| conf = new PropertiesConfiguration(); |
| conf.setListDelimiterHandler(new LegacyListDelimiterHandler(',')); |
| load(conf, testProperties); |
| |
| // remove the test save file if it exists |
| if (testSavePropertiesFile.exists()) { |
| assertTrue(testSavePropertiesFile.delete()); |
| } |
| } |
| |
| /** |
| * Creates a configuration that can be used for testing copy operations. |
| * |
| * @return the configuration to be copied |
| */ |
| private Configuration setUpCopyConfig() { |
| final int count = 25; |
| final Configuration result = new BaseConfiguration(); |
| for (int i = 1; i <= count; i++) { |
| result.addProperty("copyKey" + i, "copyValue" + i); |
| } |
| return result; |
| } |
| |
| /** |
| * Tests if properties can be appended by simply calling load() another time. |
| */ |
| @Test |
| public void testAppend() throws Exception { |
| final File file2 = ConfigurationAssert.getTestFile("threesome.properties"); |
| final FileHandler handler = new FileHandler(conf); |
| handler.load(file2); |
| assertEquals("aaa", conf.getString("test.threesome.one")); |
| assertEquals("true", conf.getString("configuration.loaded")); |
| } |
| |
| /** |
| * Tests appending a configuration to the test configuration. Again it has to be ensured that the layout object is |
| * correctly updated. |
| */ |
| @Test |
| public void testAppendAndSave() throws ConfigurationException { |
| final Configuration copyConf = setUpCopyConfig(); |
| conf.append(copyConf); |
| checkCopiedConfig(copyConf); |
| } |
| |
| /** |
| * Tests whether backslashes are correctly handled if lists are parsed. This test is related to CONFIGURATION-418. |
| */ |
| @Test |
| public void testBackslashEscapingInLists() throws Exception { |
| checkBackslashList("share2"); |
| checkBackslashList("share1"); |
| } |
| |
| /** |
| * Tests whether another list delimiter character can be set (by using an alternative list delimiter handler). |
| */ |
| @Test |
| public void testChangingListDelimiter() throws Exception { |
| assertEquals("a^b^c", conf.getString("test.other.delimiter")); |
| final PropertiesConfiguration pc2 = new PropertiesConfiguration(); |
| pc2.setListDelimiterHandler(new DefaultListDelimiterHandler('^')); |
| load(pc2, testProperties); |
| assertEquals("a", pc2.getString("test.other.delimiter")); |
| assertEquals(3, pc2.getList("test.other.delimiter").size()); |
| } |
| |
| /** |
| * Tests whether a clear() operation clears the footer comment. |
| */ |
| @Test |
| public void testClearFooterComment() { |
| conf.clear(); |
| assertNull(conf.getFooter()); |
| assertNull(conf.getHeader()); |
| } |
| |
| /** |
| * Tests whether a properties configuration can be successfully cloned. It is especially checked whether the layout |
| * object is taken into account. |
| */ |
| @Test |
| public void testClone() throws ConfigurationException { |
| final PropertiesConfiguration copy = (PropertiesConfiguration) conf.clone(); |
| assertNotSame(conf.getLayout(), copy.getLayout()); |
| assertEquals(1, conf.getEventListeners(ConfigurationEvent.ANY).size()); |
| assertEquals(1, copy.getEventListeners(ConfigurationEvent.ANY).size()); |
| assertSame(conf.getLayout(), conf.getEventListeners(ConfigurationEvent.ANY).iterator().next()); |
| assertSame(copy.getLayout(), copy.getEventListeners(ConfigurationEvent.ANY).iterator().next()); |
| final StringWriter outConf = new StringWriter(); |
| new FileHandler(conf).save(outConf); |
| final StringWriter outCopy = new StringWriter(); |
| new FileHandler(copy).save(outCopy); |
| assertEquals(outConf.toString(), outCopy.toString()); |
| } |
| |
| /** |
| * Tests the clone() method when no layout object exists yet. |
| */ |
| @Test |
| public void testCloneNullLayout() { |
| conf = new PropertiesConfiguration(); |
| final PropertiesConfiguration copy = (PropertiesConfiguration) conf.clone(); |
| assertNotSame(conf.getLayout(), copy.getLayout()); |
| } |
| |
| /** |
| * Test if the lines starting with # or ! are properly ignored. |
| */ |
| @Test |
| public void testComment() { |
| assertFalse(conf.containsKey("#comment")); |
| assertFalse(conf.containsKey("!comment")); |
| } |
| |
| private Collection<?> testCompress840(final Iterable<?> object) { |
| final PropertiesConfiguration configuration = new PropertiesConfiguration(); |
| final ListDelimiterHandler listDelimiterHandler = configuration.getListDelimiterHandler(); |
| listDelimiterHandler.flatten(object, 0); |
| // Stack overflow: |
| listDelimiterHandler.flatten(object, 1); |
| listDelimiterHandler.flatten(object, Integer.MAX_VALUE); |
| listDelimiterHandler.parse(object); |
| configuration.addProperty("foo", object); |
| configuration.toString(); |
| return listDelimiterHandler.flatten(object, Integer.MAX_VALUE); |
| } |
| |
| @ParameterizedTest |
| @ValueSource(ints = { 0, 2, 4, 8, 16 }) |
| public void testCompress840ArrayList(final int size) { |
| final ArrayList<Object> object = new ArrayList<>(); |
| for (int i = 0; i < size; i++) { |
| object.add(i); |
| } |
| final Collection<?> result = testCompress840(object); |
| assertNotNull(result); |
| assertEquals(size, result.size()); |
| assertEquals(object, result); |
| } |
| |
| @ParameterizedTest |
| @ValueSource(ints = { 0, 2, 4, 8, 16 }) |
| public void testCompress840ArrayListCycle(final int size) { |
| final ArrayList<Object> object = new ArrayList<>(); |
| for (int i = 0; i < size; i++) { |
| object.add(i); |
| object.add(object); |
| object.add(new ArrayList<>(object)); |
| } |
| final Collection<?> result = testCompress840(object); |
| assertNotNull(result); |
| assertEquals(size, result.size()); |
| object.add(object); |
| testCompress840(object); |
| } |
| |
| @Test |
| public void testCompress840BeanContextServicesSupport() { |
| testCompress840(new BeanContextServicesSupport()); |
| testCompress840(new BeanContextServicesSupport(new BeanContextServicesSupport())); |
| final BeanContextSupport bcs = new BeanContextSupport(); |
| final BeanContextServicesSupport bcss = new BeanContextServicesSupport(); |
| bcs.add(FileSystems.getDefault().getPath("bar")); |
| bcss.add(bcs); |
| testCompress840(bcss); |
| bcss.add(FileSystems.getDefault().getPath("bar")); |
| testCompress840(bcss); |
| bcss.add(bcss); |
| testCompress840(bcss); |
| } |
| |
| @Test |
| public void testCompress840BeanContextSupport() { |
| testCompress840(new BeanContextSupport()); |
| testCompress840(new BeanContextSupport(new BeanContextSupport())); |
| final BeanContextSupport bcs = new BeanContextSupport(); |
| bcs.add(FileSystems.getDefault().getPath("bar")); |
| testCompress840(bcs); |
| bcs.add(bcs); |
| testCompress840(bcs); |
| } |
| |
| @ParameterizedTest |
| @ValueSource(ints = { 0, 2, 4, 8, 16 }) |
| public void testCompress840Exception(final int size) { |
| final ArrayList<Object> object = new ArrayList<>(); |
| final Exception bottom = new Exception(); |
| object.add(bottom); |
| Exception top = bottom; |
| for (int i = 0; i < size; i++) { |
| object.add(i); |
| top = new Exception(top); |
| object.add(top); |
| } |
| if (bottom != top) { |
| // direct self-causation is not allowed. |
| bottom.initCause(top); |
| } |
| final Collection<?> result = testCompress840(object); |
| assertNotNull(result); |
| assertEquals(size * 2 + 1, result.size()); |
| assertEquals(object, result); |
| } |
| |
| @ParameterizedTest |
| @ValueSource(ints = { 0, 2, 4, 8, 16 }) |
| public void testCompress840Path(final int size) { |
| final PriorityQueue<Object> object = new PriorityQueue<>(); |
| for (int i = 0; i < size; i++) { |
| object.add(FileSystems.getDefault().getPath("foo")); |
| object.add(FileSystems.getDefault().getPath("foo", "bar")); |
| } |
| testCompress840(object); |
| } |
| |
| @ParameterizedTest |
| @ValueSource(ints = { 0, 2, 4, 8, 16 }) |
| public void testCompress840PriorityQueue(final int size) { |
| final PriorityQueue<Object> object = new PriorityQueue<>(); |
| for (int i = 0; i < size; i++) { |
| object.add(FileSystems.getDefault().getPath("foo")); |
| } |
| testCompress840(object); |
| } |
| |
| /** |
| * Tests copying another configuration into the test configuration. This test ensures that the layout object is informed |
| * about the newly added properties. |
| */ |
| @Test |
| public void testCopyAndSave() throws ConfigurationException { |
| final Configuration copyConf = setUpCopyConfig(); |
| conf.copy(copyConf); |
| checkCopiedConfig(copyConf); |
| } |
| |
| /** |
| * Tests whether include files can be disabled. |
| */ |
| @Test |
| public void testDisableIncludes() throws ConfigurationException, IOException { |
| final String content = PropertiesConfiguration.getInclude() + " = nonExistingIncludeFile" + CR + PROP_NAME + " = " + PROP_VALUE + CR; |
| final StringReader in = new StringReader(content); |
| conf = new PropertiesConfiguration(); |
| conf.setIncludesAllowed(false); |
| conf.read(in); |
| assertEquals(PROP_VALUE, conf.getString(PROP_NAME)); |
| } |
| |
| @Test |
| public void testDisableListDelimiter() throws Exception { |
| assertEquals(4, conf.getList("test.mixed.array").size()); |
| |
| final PropertiesConfiguration pc2 = new PropertiesConfiguration(); |
| load(pc2, testProperties); |
| assertEquals(2, pc2.getList("test.mixed.array").size()); |
| } |
| |
| /** |
| * Tests that empty properties are treated as the empty string (rather than as null). |
| */ |
| @Test |
| public void testEmpty() { |
| checkEmpty("test.empty"); |
| } |
| |
| /** |
| * Tests that properties are detected that do not have a separator and a value. |
| */ |
| @Test |
| public void testEmptyNoSeparator() { |
| checkEmpty("test.empty2"); |
| } |
| |
| @Test |
| public void testEscapedKey() throws Exception { |
| conf.clear(); |
| final FileHandler handler = new FileHandler(conf); |
| handler.load(new StringReader("\\u0066\\u006f\\u006f=bar")); |
| |
| assertEquals("bar", conf.getString("foo")); |
| } |
| |
| /** |
| * Check that key/value separators can be part of a key. |
| */ |
| @Test |
| public void testEscapedKeyValueSeparator() { |
| assertEquals("foo", conf.getProperty("test.separator=in.key")); |
| assertEquals("bar", conf.getProperty("test.separator:in.key")); |
| assertEquals("foo", conf.getProperty("test.separator\tin.key")); |
| assertEquals("bar", conf.getProperty("test.separator\fin.key")); |
| assertEquals("foo", conf.getProperty("test.separator in.key")); |
| } |
| |
| /** |
| * Tests the escaping of quotation marks in a properties value. This test is related to CONFIGURATION-516. |
| */ |
| @Test |
| public void testEscapeQuote() throws ConfigurationException { |
| conf.clear(); |
| final String text = "\"Hello World!\""; |
| conf.setProperty(PROP_NAME, text); |
| final StringWriter out = new StringWriter(); |
| new FileHandler(conf).save(out); |
| assertTrue(out.toString().contains(text)); |
| saveTestConfig(); |
| final PropertiesConfiguration c2 = new PropertiesConfiguration(); |
| load(c2, testSavePropertiesFile.getAbsolutePath()); |
| assertEquals(text, c2.getString(PROP_NAME)); |
| } |
| |
| /** |
| * Test the creation of a file containing a '#' in its name. |
| */ |
| @Test |
| public void testFileWithSharpSymbol() throws Exception { |
| final File file = newFile("sharp#1.properties", tempFolder); |
| |
| final PropertiesConfiguration conf = new PropertiesConfiguration(); |
| final FileHandler handler = new FileHandler(conf); |
| handler.setFile(file); |
| handler.load(); |
| handler.save(); |
| |
| assertTrue(file.exists()); |
| } |
| |
| /** |
| * Tests whether read access to the footer comment is synchronized. |
| */ |
| @Test |
| public void testGetFooterSynchronized() { |
| final SynchronizerTestImpl sync = new SynchronizerTestImpl(); |
| conf.setSynchronizer(sync); |
| assertNotNull(conf.getFooter()); |
| sync.verify(Methods.BEGIN_READ, Methods.END_READ); |
| } |
| |
| /** |
| * Tests whether read access to the header comment is synchronized. |
| */ |
| @Test |
| public void testGetHeaderSynchronized() { |
| final SynchronizerTestImpl sync = new SynchronizerTestImpl(); |
| conf.setSynchronizer(sync); |
| assertNull(conf.getHeader()); |
| sync.verify(Methods.BEGIN_READ, Methods.END_READ); |
| } |
| |
| /** |
| * Tests whether a default IOFactory is set. |
| */ |
| @Test |
| public void testGetIOFactoryDefault() { |
| assertNotNull(conf.getIOFactory()); |
| } |
| |
| /** |
| * Tests accessing the layout object. |
| */ |
| @Test |
| public void testGetLayout() { |
| final PropertiesConfigurationLayout layout = conf.getLayout(); |
| assertNotNull(layout); |
| assertSame(layout, conf.getLayout()); |
| conf.setLayout(null); |
| final PropertiesConfigurationLayout layout2 = conf.getLayout(); |
| assertNotNull(layout2); |
| assertNotSame(layout, layout2); |
| } |
| |
| @Test |
| public void testGetStringWithEscapedChars() { |
| final String property = conf.getString("test.unescape"); |
| assertEquals("This \n string \t contains \" escaped \\ characters", property); |
| } |
| |
| @Test |
| public void testGetStringWithEscapedComma() { |
| final String property = conf.getString("test.unescape.list-separator"); |
| assertEquals("This string contains , an escaped list separator", property); |
| } |
| |
| @Test |
| public void testIncludeIncludeLoadAllOnNotFound() throws Exception { |
| final PropertiesConfiguration pc = new PropertiesConfiguration(); |
| pc.setIncludeListener(PropertiesConfiguration.NOOP_INCLUDE_LISTENER); |
| final FileHandler handler = new FileHandler(pc); |
| handler.setBasePath(testBasePath); |
| handler.setFileName("include-include-not-found.properties"); |
| handler.load(); |
| assertEquals("valueA", pc.getString("keyA")); |
| assertEquals("valueB", pc.getString("keyB")); |
| } |
| |
| @Test |
| public void testIncludeIncludeLoadCyclicalReferenceFail() throws Exception { |
| final PropertiesConfiguration pc = new PropertiesConfiguration(); |
| final FileHandler handler = new FileHandler(pc); |
| handler.setBasePath(testBasePath); |
| handler.setFileName("include-include-cyclical-reference.properties"); |
| assertThrows(ConfigurationException.class, handler::load); |
| assertNull(pc.getString("keyA")); |
| } |
| |
| @Test |
| public void testIncludeIncludeLoadCyclicalReferenceIgnore() throws Exception { |
| final PropertiesConfiguration pc = new PropertiesConfiguration(); |
| pc.setIncludeListener(PropertiesConfiguration.NOOP_INCLUDE_LISTENER); |
| final FileHandler handler = new FileHandler(pc); |
| handler.setBasePath(testBasePath); |
| handler.setFileName("include-include-cyclical-reference.properties"); |
| handler.load(); |
| assertEquals("valueA", pc.getString("keyA")); |
| } |
| |
| /** |
| * Tests including properties when they are loaded from a nested directory structure. |
| */ |
| @Test |
| public void testIncludeInSubDir() throws ConfigurationException { |
| final CombinedConfigurationBuilder builder = new CombinedConfigurationBuilder(); |
| builder.configure(new FileBasedBuilderParametersImpl().setFileName("testFactoryPropertiesInclude.xml")); |
| final Configuration config = builder.getConfiguration(); |
| assertTrue(config.getBoolean("deeptest")); |
| assertTrue(config.getBoolean("deepinclude")); |
| assertFalse(config.containsKey("deeptestinvalid")); |
| } |
| |
| @Test |
| public void testIncludeLoadAllOnLoadException() throws Exception { |
| final PropertiesConfiguration pc = new PropertiesConfiguration(); |
| pc.setIncludeListener(PropertiesConfiguration.NOOP_INCLUDE_LISTENER); |
| final FileHandler handler = new FileHandler(pc); |
| handler.setBasePath(testBasePath); |
| handler.setFileName("include-load-exception.properties"); |
| handler.load(); |
| assertEquals("valueA", pc.getString("keyA")); |
| } |
| |
| @Test |
| public void testIncludeLoadAllOnNotFound() throws Exception { |
| final PropertiesConfiguration pc = new PropertiesConfiguration(); |
| pc.setIncludeListener(PropertiesConfiguration.NOOP_INCLUDE_LISTENER); |
| final FileHandler handler = new FileHandler(pc); |
| handler.setBasePath(testBasePath); |
| handler.setFileName("include-not-found.properties"); |
| handler.load(); |
| assertEquals("valueA", pc.getString("keyA")); |
| } |
| |
| @Test |
| public void testIncludeLoadCyclicalMultiStepReferenceFail() throws Exception { |
| final PropertiesConfiguration pc = new PropertiesConfiguration(); |
| final FileHandler handler = new FileHandler(pc); |
| handler.setBasePath(testBasePath); |
| handler.setFileName("include-cyclical-root.properties"); |
| assertThrows(ConfigurationException.class, handler::load); |
| assertNull(pc.getString("keyA")); |
| } |
| |
| @Test |
| public void testIncludeLoadCyclicalMultiStepReferenceIgnore() throws Exception { |
| final PropertiesConfiguration pc = new PropertiesConfiguration(); |
| pc.setIncludeListener(PropertiesConfiguration.NOOP_INCLUDE_LISTENER); |
| final FileHandler handler = new FileHandler(pc); |
| handler.setBasePath(testBasePath); |
| handler.setFileName("include-cyclical-root.properties"); |
| handler.load(); |
| assertEquals("valueA", pc.getString("keyA")); |
| } |
| |
| @Test |
| public void testIncludeLoadCyclicalReferenceFail() throws Exception { |
| final PropertiesConfiguration pc = new PropertiesConfiguration(); |
| final FileHandler handler = new FileHandler(pc); |
| handler.setBasePath(testBasePath); |
| handler.setFileName("include-cyclical-reference.properties"); |
| assertThrows(ConfigurationException.class, handler::load); |
| assertNull(pc.getString("keyA")); |
| } |
| |
| @Test |
| public void testIncludeLoadCyclicalReferenceIgnore() throws Exception { |
| final PropertiesConfiguration pc = new PropertiesConfiguration(); |
| pc.setIncludeListener(PropertiesConfiguration.NOOP_INCLUDE_LISTENER); |
| final FileHandler handler = new FileHandler(pc); |
| handler.setBasePath(testBasePath); |
| handler.setFileName("include-cyclical-reference.properties"); |
| handler.load(); |
| assertEquals("valueA", pc.getString("keyA")); |
| } |
| |
| /** |
| * Tests initializing a properties configuration from a non existing file. There was a bug, which caused properties |
| * getting lost when later save() is called. |
| */ |
| @Test |
| public void testInitFromNonExistingFile() throws ConfigurationException { |
| final String testProperty = "test.successfull"; |
| conf = new PropertiesConfiguration(); |
| final FileHandler handler = new FileHandler(conf); |
| handler.setFile(testSavePropertiesFile); |
| conf.addProperty(testProperty, "true"); |
| handler.save(); |
| checkSavedConfig(); |
| } |
| |
| @Test |
| public void testInMemoryCreatedSave() throws Exception { |
| conf = new PropertiesConfiguration(); |
| // add an array of strings to the configuration |
| conf.addProperty("string", "value1"); |
| final List<Object> list = new ArrayList<>(); |
| for (int i = 1; i < 5; i++) { |
| list.add("value" + i); |
| } |
| conf.addProperty("array", list); |
| |
| // save the configuration |
| saveTestConfig(); |
| assertTrue(testSavePropertiesFile.exists()); |
| |
| // read the configuration and compare the properties |
| checkSavedConfig(); |
| } |
| |
| /** |
| * Tests whether comment lines are correctly detected. |
| */ |
| @Test |
| public void testIsCommentLine() { |
| assertTrue(PropertiesConfiguration.isCommentLine("# a comment")); |
| assertTrue(PropertiesConfiguration.isCommentLine("! a comment")); |
| assertTrue(PropertiesConfiguration.isCommentLine("#a comment")); |
| assertTrue(PropertiesConfiguration.isCommentLine(" ! a comment")); |
| assertFalse(PropertiesConfiguration.isCommentLine(" a#comment")); |
| } |
| |
| /** |
| * Tests that {@link PropertiesConfiguration.JupIOFactory} reads the same keys and values as {@link Properties} based on |
| * a test file. |
| */ |
| @Test |
| public void testJupRead() throws IOException, ConfigurationException { |
| conf.clear(); |
| conf.setIOFactory(new PropertiesConfiguration.JupIOFactory()); |
| |
| final String testFilePath = ConfigurationAssert.getTestFile("jup-test.properties").getAbsolutePath(); |
| |
| load(conf, testFilePath); |
| |
| final Properties jup = new Properties(); |
| try (InputStream in = Files.newInputStream(Paths.get(testFilePath))) { |
| jup.load(in); |
| } |
| |
| @SuppressWarnings("unchecked") |
| final Set<Object> pcKeys = new HashSet<>(IteratorUtils.toList(conf.getKeys())); |
| assertEquals(jup.keySet(), pcKeys); |
| |
| for (final Object key : jup.keySet()) { |
| final String keyString = key.toString(); |
| assertEquals(jup.getProperty(keyString), conf.getProperty(keyString), "Wrong property value for '" + keyString + "'"); |
| } |
| } |
| |
| /** |
| * Tests that {@link PropertiesConfiguration.JupIOFactory} writes properties in a way that allows {@link Properties} to |
| * read them exactly like they were set. |
| */ |
| @Test |
| public void testJupWrite() throws IOException, ConfigurationException { |
| conf.clear(); |
| conf.setIOFactory(new PropertiesConfiguration.JupIOFactory()); |
| |
| final String testFilePath = ConfigurationAssert.getTestFile("jup-test.properties").getAbsolutePath(); |
| |
| // read the test properties and set them on the PropertiesConfiguration |
| final Properties origProps = new Properties(); |
| try (InputStream in = Files.newInputStream(Paths.get(testFilePath))) { |
| origProps.load(in); |
| } |
| for (final Object key : origProps.keySet()) { |
| final String keyString = key.toString(); |
| conf.setProperty(keyString, origProps.getProperty(keyString)); |
| } |
| |
| // save the configuration |
| saveTestConfig(); |
| assertTrue(testSavePropertiesFile.exists()); |
| |
| // load the saved file... |
| final Properties testProps = new Properties(); |
| try (InputStream in = Files.newInputStream(testSavePropertiesFile.toPath())) { |
| testProps.load(in); |
| } |
| |
| // ... and compare the properties to the originals |
| @SuppressWarnings("unchecked") |
| final Set<Object> pcKeys = new HashSet<>(IteratorUtils.toList(conf.getKeys())); |
| assertEquals(testProps.keySet(), pcKeys); |
| |
| for (final Object key : testProps.keySet()) { |
| final String keyString = key.toString(); |
| assertEquals(testProps.getProperty(keyString), conf.getProperty(keyString), "Wrong property value for '" + keyString + "'"); |
| } |
| } |
| |
| /** |
| * Tests that {@link PropertiesConfiguration.JupIOFactory} writes properties in a way that allows {@link Properties} to |
| * read them exactly like they were set. This test writes in UTF-8 encoding, with Unicode escapes turned off. |
| */ |
| @Test |
| public void testJupWriteUtf8WithoutUnicodeEscapes() throws IOException, ConfigurationException { |
| conf.clear(); |
| conf.setIOFactory(new PropertiesConfiguration.JupIOFactory(false)); |
| |
| final String testFilePath = ConfigurationAssert.getTestFile("jup-test.properties").getAbsolutePath(); |
| |
| // read the test properties and set them on the PropertiesConfiguration |
| final Properties origProps = new Properties(); |
| try (InputStream in = Files.newInputStream(Paths.get(testFilePath))) { |
| origProps.load(in); |
| } |
| for (final Object key : origProps.keySet()) { |
| final String keyString = key.toString(); |
| conf.setProperty(keyString, origProps.getProperty(keyString)); |
| } |
| |
| // save the configuration as UTF-8 |
| final FileHandler handler = new FileHandler(conf); |
| handler.setEncoding(StandardCharsets.UTF_8.name()); |
| handler.save(testSavePropertiesFile); |
| assertTrue(testSavePropertiesFile.exists()); |
| |
| // load the saved file... |
| final Properties testProps = new Properties(); |
| try (BufferedReader in = Files.newBufferedReader(testSavePropertiesFile.toPath(), StandardCharsets.UTF_8)) { |
| testProps.load(in); |
| } |
| |
| // ... and compare the properties to the originals |
| @SuppressWarnings("unchecked") |
| final Set<Object> pcKeys = new HashSet<>(IteratorUtils.toList(conf.getKeys())); |
| assertEquals(testProps.keySet(), pcKeys); |
| |
| for (final Object key : testProps.keySet()) { |
| final String keyString = key.toString(); |
| assertEquals(testProps.getProperty(keyString), conf.getProperty(keyString), "Wrong property value for '" + keyString + "'"); |
| } |
| |
| // ensure that the written properties file contains no Unicode escapes |
| for (final String line : Files.readAllLines(testSavePropertiesFile.toPath())) { |
| assertThat(line, not(containsString("\\u"))); |
| } |
| } |
| |
| /** |
| * Tests that the property separators are retained when saving the configuration. |
| */ |
| @Test |
| public void testKeepSeparators() throws ConfigurationException, IOException { |
| saveTestConfig(); |
| final String[] separatorTests = {"test.separator.equal = foo", "test.separator.colon : foo", "test.separator.tab\tfoo", "test.separator.whitespace foo", |
| "test.separator.no.space=foo"}; |
| final Set<String> foundLines = new HashSet<>(); |
| try (BufferedReader in = new BufferedReader(new FileReader(testSavePropertiesFile))) { |
| String s; |
| while ((s = in.readLine()) != null) { |
| for (final String separatorTest : separatorTests) { |
| if (separatorTest.equals(s)) { |
| foundLines.add(s); |
| } |
| } |
| } |
| } |
| assertThat(foundLines, containsInAnyOrder(separatorTests)); |
| } |
| |
| /** |
| * Test all acceptable key/value separators ('=', ':' or white spaces). |
| */ |
| @Test |
| public void testKeyValueSeparators() { |
| assertEquals("foo", conf.getProperty("test.separator.equal")); |
| assertEquals("foo", conf.getProperty("test.separator.colon")); |
| assertEquals("foo", conf.getProperty("test.separator.tab")); |
| assertEquals("foo", conf.getProperty("test.separator.formfeed")); |
| assertEquals("foo", conf.getProperty("test.separator.whitespace")); |
| } |
| |
| @Test |
| public void testLargeKey() throws Exception { |
| conf.clear(); |
| final String key = String.join("", Collections.nCopies(10000, "x")); |
| final FileHandler handler = new FileHandler(conf); |
| handler.load(new StringReader(key)); |
| |
| assertEquals("", conf.getString(key)); |
| } |
| |
| /** |
| * Tests whether the correct line separator is used. |
| */ |
| @Test |
| public void testLineSeparator() throws ConfigurationException { |
| final String EOL = System.lineSeparator(); |
| conf = new PropertiesConfiguration(); |
| conf.setHeader("My header"); |
| conf.setProperty("prop", "value"); |
| |
| final StringWriter out = new StringWriter(); |
| new FileHandler(conf).save(out); |
| final String content = out.toString(); |
| assertEquals(0, content.indexOf("# My header" + EOL + EOL)); |
| assertThat(content, containsString("prop = value" + EOL)); |
| } |
| |
| /** |
| * Tests {@code List} parsing. |
| */ |
| @Test |
| public void testList() throws Exception { |
| final List<Object> packages = conf.getList("packages"); |
| // we should get 3 packages here |
| assertEquals(3, packages.size()); |
| } |
| |
| @Test |
| public void testLoad() throws Exception { |
| final String loaded = conf.getString("configuration.loaded"); |
| assertEquals("true", loaded); |
| } |
| |
| @Test |
| public void testLoadFromFile() throws Exception { |
| final File file = ConfigurationAssert.getTestFile("test.properties"); |
| conf.clear(); |
| final FileHandler handler = new FileHandler(conf); |
| handler.setFile(file); |
| handler.load(); |
| |
| assertEquals("true", conf.getString("configuration.loaded")); |
| } |
| |
| /** |
| * test if includes properties get loaded too |
| */ |
| @Test |
| public void testLoadInclude() throws Exception { |
| final String loaded = conf.getString("include.loaded"); |
| assertEquals("true", loaded); |
| } |
| |
| /** |
| * Tests whether the correct file system is used when loading an include file. This test is related to |
| * CONFIGURATION-609. |
| */ |
| @Test |
| public void testLoadIncludeFileViaFileSystem() throws ConfigurationException { |
| conf.clear(); |
| conf.addProperty("include", "include.properties"); |
| saveTestConfig(); |
| |
| final FileSystem fs = new DefaultFileSystem() { |
| @Override |
| public InputStream getInputStream(final URL url) throws ConfigurationException { |
| if (url.toString().endsWith("include.properties")) { |
| return new ByteArrayInputStream("test.outcome = success".getBytes(StandardCharsets.UTF_8)); |
| } |
| return super.getInputStream(url); |
| } |
| }; |
| final Parameters params = new Parameters(); |
| final FileBasedConfigurationBuilder<PropertiesConfiguration> builder = new FileBasedConfigurationBuilder<>(PropertiesConfiguration.class); |
| builder.configure(params.fileBased().setFile(testSavePropertiesFile).setBasePath(ConfigurationAssert.OUT_DIR.toURI().toString()).setFileSystem(fs)); |
| final PropertiesConfiguration configuration = builder.getConfiguration(); |
| assertEquals("success", configuration.getString("test.outcome")); |
| } |
| |
| /** |
| * Tests if included files are loaded when the source lies in the class path. |
| */ |
| @Test |
| public void testLoadIncludeFromClassPath() { |
| assertEquals("true", conf.getString("include.loaded")); |
| } |
| |
| /** |
| * Tests whether include files can be resolved if a configuration file is read from a reader. |
| */ |
| @Test |
| public void testLoadIncludeFromReader() throws ConfigurationException { |
| final StringReader in = new StringReader(PropertiesConfiguration.getInclude() + " = " + ConfigurationAssert.getTestURL("include.properties")); |
| conf = new PropertiesConfiguration(); |
| final FileHandler handler = new FileHandler(conf); |
| handler.load(in); |
| assertEquals("true", conf.getString("include.loaded")); |
| } |
| |
| /** |
| * test if includes properties from interpolated file name get loaded |
| */ |
| @Test |
| public void testLoadIncludeInterpol() throws Exception { |
| final String loaded = conf.getString("include.interpol.loaded"); |
| assertEquals("true", loaded); |
| } |
| |
| @Test |
| public void testLoadIncludeOptional() throws Exception { |
| final PropertiesConfiguration pc = new PropertiesConfiguration(); |
| final FileHandler handler = new FileHandler(pc); |
| handler.setBasePath(testBasePath); |
| handler.setFileName("includeoptional.properties"); |
| handler.load(); |
| |
| assertTrue(pc.getBoolean("includeoptional.loaded")); |
| } |
| |
| @Test |
| public void testLoadUnexistingFile() { |
| assertThrows(ConfigurationException.class, () -> load(conf, "unexisting file")); |
| } |
| |
| @Test |
| public void testLoadViaPropertyWithBasePath() throws Exception { |
| final PropertiesConfiguration pc = new PropertiesConfiguration(); |
| final FileHandler handler = new FileHandler(pc); |
| handler.setBasePath(testBasePath); |
| handler.setFileName("test.properties"); |
| handler.load(); |
| |
| assertTrue(pc.getBoolean("test.boolean")); |
| } |
| |
| @Test |
| public void testLoadViaPropertyWithBasePath2() throws Exception { |
| final PropertiesConfiguration pc = new PropertiesConfiguration(); |
| final FileHandler handler = new FileHandler(pc); |
| handler.setBasePath(testBasePath2); |
| handler.setFileName("test.properties"); |
| handler.load(); |
| |
| assertTrue(pc.getBoolean("test.boolean")); |
| } |
| |
| @Test |
| public void testMixedArray() { |
| final String[] array = conf.getStringArray("test.mixed.array"); |
| |
| assertArrayEquals(new String[] {"a", "b", "c", "d"}, array); |
| } |
| |
| @Test |
| public void testMultilines() { |
| final String property = "This is a value spread out across several adjacent " + "natural lines by escaping the line terminator with " |
| + "a backslash character."; |
| |
| assertEquals(property, conf.getString("test.multilines")); |
| } |
| |
| /** |
| * Tests whether multiple include files can be resolved. |
| */ |
| @Test |
| public void testMultipleIncludeFiles() throws ConfigurationException { |
| conf = new PropertiesConfiguration(); |
| final FileHandler handler = new FileHandler(conf); |
| handler.load(ConfigurationAssert.getTestFile("config/testMultiInclude.properties")); |
| assertEquals("topValue", conf.getString("top")); |
| assertEquals(100, conf.getInt("property.c")); |
| assertTrue(conf.getBoolean("include.loaded")); |
| } |
| |
| /** |
| * Tests escaping of an end of line with a backslash. |
| */ |
| @Test |
| public void testNewLineEscaping() { |
| final List<Object> list = conf.getList("test.path"); |
| assertEquals(Arrays.asList("C:\\path1\\", "C:\\path2\\", "C:\\path3\\complex\\test\\"), list); |
| } |
| |
| /** |
| * Tests the propertyLoaded() method for a simple property. |
| */ |
| @Test |
| public void testPropertyLoaded() throws ConfigurationException { |
| final DummyLayout layout = new DummyLayout(); |
| conf.setLayout(layout); |
| conf.propertyLoaded("layoutLoadedProperty", "yes", null); |
| assertEquals(0, layout.loadCalls); |
| assertEquals("yes", conf.getString("layoutLoadedProperty")); |
| } |
| |
| /** |
| * Tests the propertyLoaded() method for an include property. |
| */ |
| @Test |
| public void testPropertyLoadedInclude() throws ConfigurationException { |
| final DummyLayout layout = new DummyLayout(); |
| conf.setLayout(layout); |
| conf.propertyLoaded(PropertiesConfiguration.getInclude(), "testClasspath.properties,testEqual.properties", new ArrayDeque<>()); |
| assertEquals(2, layout.loadCalls); |
| assertFalse(conf.containsKey(PropertiesConfiguration.getInclude())); |
| } |
| |
| /** |
| * Tests propertyLoaded() for an include property, when includes are disabled. |
| */ |
| @Test |
| public void testPropertyLoadedIncludeNotAllowed() throws ConfigurationException { |
| final DummyLayout layout = new DummyLayout(); |
| conf.setLayout(layout); |
| conf.setIncludesAllowed(false); |
| conf.propertyLoaded(PropertiesConfiguration.getInclude(), "testClassPath.properties,testEqual.properties", null); |
| assertEquals(0, layout.loadCalls); |
| assertFalse(conf.containsKey(PropertiesConfiguration.getInclude())); |
| } |
| |
| /** |
| * Tests a direct invocation of the read() method. This is not allowed because certain initializations have not been |
| * done. This test is related to CONFIGURATION-641. |
| */ |
| @Test |
| public void testReadCalledDirectly() throws IOException { |
| conf = new PropertiesConfiguration(); |
| try (Reader in = new FileReader(ConfigurationAssert.getTestFile("test.properties"))) { |
| final ConfigurationException e = assertThrows(ConfigurationException.class, () -> conf.read(in)); |
| assertThat(e.getMessage(), containsString("FileHandler")); |
| } |
| } |
| |
| /** |
| * Tests whether a footer comment is correctly read. |
| */ |
| @Test |
| public void testReadFooterComment() { |
| assertEquals("\n# This is a foot comment\n", conf.getFooter()); |
| assertEquals("\nThis is a foot comment\n", conf.getLayout().getCanonicalFooterCooment(false)); |
| } |
| |
| /** |
| * Tests that references to other properties work |
| */ |
| @Test |
| public void testReference() throws Exception { |
| assertEquals("baseextra", conf.getString("base.reference")); |
| } |
| |
| @Test |
| public void testSave() throws Exception { |
| // add an array of strings to the configuration |
| conf.addProperty("string", "value1"); |
| final List<Object> list = new ArrayList<>(); |
| for (int i = 1; i < 5; i++) { |
| list.add("value" + i); |
| } |
| conf.addProperty("array", list); |
| |
| // save the configuration |
| saveTestConfig(); |
| assertTrue(testSavePropertiesFile.exists()); |
| |
| // read the configuration and compare the properties |
| checkSavedConfig(); |
| } |
| |
| /** |
| * Tests whether the escape character for list delimiters can be itself escaped and survives a save operation. |
| */ |
| @Test |
| public void testSaveEscapedEscapingCharacter() throws ConfigurationException { |
| conf.addProperty("test.dirs", "C:\\Temp\\\\,D:\\Data\\\\,E:\\Test\\"); |
| final List<Object> dirs = conf.getList("test.dirs"); |
| assertEquals(3, dirs.size()); |
| saveTestConfig(); |
| checkSavedConfig(); |
| } |
| |
| @Test |
| public void testSaveMissingFileName() { |
| final FileHandler handler = new FileHandler(conf); |
| assertThrows(ConfigurationException.class, handler::save); |
| } |
| |
| @Test |
| public void testSaveToCustomURL() throws Exception { |
| // save the configuration to a custom URL |
| final URL url = new URL("foo", "", 0, newFile("testsave-custom-url.properties", tempFolder).getAbsolutePath(), new FileURLStreamHandler()); |
| final FileHandler handlerSave = new FileHandler(conf); |
| handlerSave.save(url); |
| |
| // reload the configuration |
| final PropertiesConfiguration config2 = new PropertiesConfiguration(); |
| final FileHandler handlerLoad = new FileHandler(config2); |
| handlerLoad.load(url); |
| assertEquals("true", config2.getString("configuration.loaded")); |
| } |
| |
| /** |
| * Tests saving a file-based configuration to a HTTP server when the server reports a failure. This should cause an |
| * exception. |
| */ |
| @Test |
| public void testSaveToHTTPServerFail() throws Exception { |
| final MockHttpURLStreamHandler handler = new MockHttpURLStreamHandler(HttpURLConnection.HTTP_BAD_REQUEST, testSavePropertiesFile); |
| final URL url = new URL(null, "http://jakarta.apache.org", handler); |
| final FileHandler fileHandler = new FileHandler(conf); |
| final ConfigurationException cex = assertThrows(ConfigurationException.class, () -> fileHandler.save(url)); |
| assertInstanceOf(IOException.class, cex.getCause()); |
| } |
| |
| /** |
| * Tests saving a file-based configuration to a HTTP server. |
| */ |
| @Test |
| public void testSaveToHTTPServerSuccess() throws Exception { |
| final MockHttpURLStreamHandler handler = new MockHttpURLStreamHandler(HttpURLConnection.HTTP_OK, testSavePropertiesFile); |
| final URL url = new URL(null, "http://jakarta.apache.org", handler); |
| new FileHandler(conf).save(url); |
| final MockHttpURLConnection con = handler.getMockConnection(); |
| assertTrue(con.getDoOutput()); |
| assertEquals("PUT", con.getRequestMethod()); |
| checkSavedConfig(); |
| } |
| |
| /** |
| * Tests if the base path is taken into account by the save() method. |
| */ |
| @Test |
| public void testSaveWithBasePath() throws Exception { |
| conf.setProperty("test", "true"); |
| final FileHandler handler = new FileHandler(conf); |
| handler.setBasePath(testSavePropertiesFile.getParentFile().toURI().toURL().toString()); |
| handler.setFileName(testSavePropertiesFile.getName()); |
| handler.save(); |
| assertTrue(testSavePropertiesFile.exists()); |
| } |
| |
| /** |
| * Tests adding properties through a DataConfiguration. This is related to CONFIGURATION-332. |
| */ |
| @Test |
| public void testSaveWithDataConfig() throws ConfigurationException { |
| conf = new PropertiesConfiguration(); |
| final FileHandler handler = new FileHandler(conf); |
| handler.setFile(testSavePropertiesFile); |
| final DataConfiguration dataConfig = new DataConfiguration(conf); |
| dataConfig.setProperty("foo", "bar"); |
| assertEquals("bar", conf.getString("foo")); |
| |
| handler.save(); |
| final PropertiesConfiguration config2 = new PropertiesConfiguration(); |
| load(config2, testSavePropertiesFile.getAbsolutePath()); |
| assertEquals("bar", config2.getString("foo")); |
| } |
| |
| /** |
| * Tests whether saving works correctly with the default list delimiter handler implementation. |
| */ |
| @Test |
| public void testSaveWithDefaultListDelimiterHandler() throws ConfigurationException { |
| conf.setListDelimiterHandler(new DefaultListDelimiterHandler(',')); |
| saveTestConfig(); |
| |
| final PropertiesConfiguration checkConfig = new PropertiesConfiguration(); |
| checkConfig.setListDelimiterHandler(conf.getListDelimiterHandler()); |
| new FileHandler(checkConfig).load(testSavePropertiesFile); |
| ConfigurationAssert.assertConfigurationEquals(conf, checkConfig); |
| } |
| |
| /** |
| * Tests saving a configuration if delimiter parsing is disabled. |
| */ |
| @Test |
| public void testSaveWithDelimiterParsingDisabled() throws ConfigurationException { |
| conf.clear(); |
| conf.setListDelimiterHandler(new DisabledListDelimiterHandler()); |
| conf.addProperty("test.list", "a,b,c"); |
| conf.addProperty("test.dirs", "C:\\Temp\\,D:\\Data\\"); |
| saveTestConfig(); |
| |
| final PropertiesConfiguration checkConfig = new PropertiesConfiguration(); |
| checkConfig.setListDelimiterHandler(new DisabledListDelimiterHandler()); |
| new FileHandler(checkConfig).load(testSavePropertiesFile); |
| ConfigurationAssert.assertConfigurationEquals(conf, checkConfig); |
| } |
| |
| /** |
| * Tests whether write access to the footer comment is synchronized. |
| */ |
| @Test |
| public void testSetFooterSynchronized() { |
| final SynchronizerTestImpl sync = new SynchronizerTestImpl(); |
| conf.setSynchronizer(sync); |
| conf.setFooter("new comment"); |
| sync.verify(Methods.BEGIN_WRITE, Methods.END_WRITE); |
| } |
| |
| /** |
| * Tests whether write access to the header comment is synchronized. |
| */ |
| @Test |
| public void testSetHeaderSynchronized() { |
| final SynchronizerTestImpl sync = new SynchronizerTestImpl(); |
| conf.setSynchronizer(sync); |
| conf.setHeader("new comment"); |
| sync.verify(Methods.BEGIN_WRITE, Methods.END_WRITE); |
| } |
| |
| @Test |
| public void testSetInclude() throws Exception { |
| conf.clear(); |
| // change the include key |
| PropertiesConfiguration.setInclude("import"); |
| |
| // load the configuration |
| load(conf, testProperties); |
| |
| // restore the previous value for the other tests |
| PropertiesConfiguration.setInclude("include"); |
| |
| assertNull(conf.getString("include.loaded")); |
| } |
| |
| /** |
| * Tests setting the IOFactory to null. This should cause an exception. |
| */ |
| @Test |
| public void testSetIOFactoryNull() { |
| assertThrows(IllegalArgumentException.class, () -> conf.setIOFactory(null)); |
| } |
| |
| /** |
| * Tests setting an IOFactory that uses a specialized reader. |
| */ |
| @Test |
| public void testSetIOFactoryReader() throws ConfigurationException { |
| final int propertyCount = 10; |
| conf.clear(); |
| conf.setIOFactory(new PropertiesConfiguration.IOFactory() { |
| @Override |
| public PropertiesConfiguration.PropertiesReader createPropertiesReader(final Reader in) { |
| return new PropertiesReaderTestImpl(in, propertyCount); |
| } |
| |
| @Override |
| public PropertiesConfiguration.PropertiesWriter createPropertiesWriter(final Writer out, final ListDelimiterHandler handler) { |
| throw new UnsupportedOperationException("Unexpected call!"); |
| } |
| }); |
| load(conf, testProperties); |
| for (int i = 1; i <= propertyCount; i++) { |
| assertEquals(PROP_VALUE + i, conf.getString(PROP_NAME + i), "Wrong property value at " + i); |
| } |
| } |
| |
| /** |
| * Tests setting an IOFactory that uses a specialized writer. |
| */ |
| @Test |
| public void testSetIOFactoryWriter() throws ConfigurationException, IOException { |
| final MutableObject<Writer> propertiesWriter = new MutableObject<>(); |
| conf.setIOFactory(new PropertiesConfiguration.IOFactory() { |
| @Override |
| public PropertiesConfiguration.PropertiesReader createPropertiesReader(final Reader in) { |
| throw new UnsupportedOperationException("Unexpected call!"); |
| } |
| |
| @Override |
| public PropertiesConfiguration.PropertiesWriter createPropertiesWriter(final Writer out, final ListDelimiterHandler handler) { |
| try { |
| final PropertiesWriterTestImpl propWriter = new PropertiesWriterTestImpl(handler); |
| propertiesWriter.setValue(propWriter); |
| return propWriter; |
| } catch (final IOException e) { |
| return null; |
| } |
| } |
| }); |
| new FileHandler(conf).save(new StringWriter()); |
| propertiesWriter.getValue().close(); |
| checkSavedConfig(); |
| } |
| |
| /** |
| * Tests whether a list property is handled correctly if delimiter parsing is disabled. This test is related to |
| * CONFIGURATION-495. |
| */ |
| @Test |
| public void testSetPropertyListWithDelimiterParsingDisabled() throws ConfigurationException { |
| final String prop = "delimiterListProp"; |
| conf.setListDelimiterHandler(DisabledListDelimiterHandler.INSTANCE); |
| final List<String> list = Arrays.asList("val", "val2", "val3"); |
| conf.setProperty(prop, list); |
| saveTestConfig(); |
| conf.clear(); |
| load(conf, testSavePropertiesFile.getAbsolutePath()); |
| assertEquals(list, conf.getProperty(prop)); |
| } |
| |
| /** |
| * Tests whether properties with slashes in their values can be saved. This test is related to CONFIGURATION-408. |
| */ |
| @Test |
| public void testSlashEscaping() throws ConfigurationException { |
| conf.setProperty(PROP_NAME, "http://www.apache.org"); |
| final StringWriter writer = new StringWriter(); |
| new FileHandler(conf).save(writer); |
| final String s = writer.toString(); |
| assertTrue(s.contains(PROP_NAME + " = http://www.apache.org")); |
| } |
| |
| /** |
| * Tests whether special characters in a property value are un-escaped. This test is related to CONFIGURATION-640. |
| */ |
| @Test |
| public void testUnEscapeCharacters() { |
| assertEquals("#1 =: me!", conf.getString("test.unescape.characters")); |
| } |
| |
| @Test |
| public void testUnescapeJava() { |
| assertEquals("test\\,test", PropertiesConfiguration.unescapeJava("test\\,test")); |
| } |
| |
| /** |
| * Tests whether a footer comment is correctly written out. |
| */ |
| @Test |
| public void testWriteFooterComment() throws ConfigurationException, IOException { |
| final String footer = "my footer"; |
| conf.clear(); |
| conf.setProperty(PROP_NAME, PROP_VALUE); |
| conf.setFooter(footer); |
| final StringWriter out = new StringWriter(); |
| conf.write(out); |
| assertEquals(PROP_NAME + " = " + PROP_VALUE + CR + "# " + footer + CR, out.toString()); |
| } |
| } |
