1   package org.apache.commons.configuration;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one or more
5    * contributor license agreements.  See the NOTICE file distributed with
6    * this work for additional information regarding copyright ownership.
7    * The ASF licenses this file to You under the Apache License, Version 2.0
8    * (the "License"); you may not use this file except in compliance with
9    * the License.  You may obtain a copy of the License at
10   *
11   *     http://www.apache.org/licenses/LICENSE-2.0
12   *
13   * Unless required by applicable law or agreed to in writing, software
14   * distributed under the License is distributed on an "AS IS" BASIS,
15   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16   * See the License for the specific language governing permissions and
17   * limitations under the License.
18   */
19  
20  import java.io.File;
21  import java.util.Iterator;
22  import java.util.List;
23  
24  import junit.framework.TestCase;
25  
26  /***
27   * Compare the behaviour of various methods between CompositeConfiguration
28   * and normal (Properties) Configuration
29   * 
30   * @version $Id: TestEqualBehaviour.java 439648 2006-09-02 20:42:10Z oheger $
31   */
32  public class TestEqualBehaviour  extends TestCase
33  {
34      private Configuration setupSimpleConfiguration()
35              throws Exception
36      {
37          String simpleConfigurationFile = new File("conf/testEqual.properties").getAbsolutePath();
38          return new PropertiesConfiguration(simpleConfigurationFile);
39      }
40  
41      private Configuration setupCompositeConfiguration()
42              throws Exception
43      {
44          String compositeConfigurationFile = new File("conf/testEqualDigester.xml").getAbsolutePath();
45  
46          ConfigurationFactory configurationFactory = new ConfigurationFactory();
47          configurationFactory.setConfigurationFileName(compositeConfigurationFile);
48          return configurationFactory.getConfiguration();
49      }
50  
51      /***
52       * Checks whether two configurations have the same size, 
53       * the same key sequence and contain the same key -> value mappings
54       */
55      private void checkEquality(String msg, Configuration c1, Configuration c2)
56      {
57          Iterator it1 = c1.getKeys();
58          Iterator it2 = c2.getKeys();
59  
60          while(it1.hasNext() && it2.hasNext())
61          {
62              String key1 = (String) it1.next();
63              String key2 = (String) it2.next();
64              assertEquals(msg + ", Keys: ", key1, key2);
65              assertEquals(msg + ", Contains: ", c1.containsKey(key1), c2.containsKey(key2));
66          }
67          assertEquals(msg + ", Iterator: ", it1.hasNext(), it2.hasNext());
68      }
69  
70      /***
71       * Checks whether two configurations have the same key -> value mapping
72       */
73      private void checkSameKey(String msg, String key, Configuration c1, Configuration c2)
74      {
75          String [] s1 = c1.getStringArray(key);
76          String [] s2 = c2.getStringArray(key);
77  
78          assertEquals(msg + ", length: ", s1.length, s2.length);
79  
80          for (int i = 0; i < s1.length ; i++)
81          {
82              assertEquals(msg + ", String Array: ", s1[i], s2[i]);
83          }
84  
85          List list1 = c1.getList(key);
86          List list2 = c2.getList(key);
87  
88          assertEquals(msg + ", Size: ", list1.size(), list2.size());
89  
90          Iterator it1 = list1.iterator();
91          Iterator it2 = list2.iterator();
92  
93          while(it1.hasNext() && it2.hasNext())
94          {
95              String val1 = (String) it1.next();
96              String val2 = (String) it2.next();
97              assertEquals(msg + ", List: ", val1, val2);
98          }
99          assertEquals(msg + ", Iterator End: ", it1.hasNext(), it2.hasNext());
100     }
101 
102     /***
103      * Are both configurations equal after loading?
104      */
105     public void testLoading() throws Exception
106     {
107         Configuration simple = setupSimpleConfiguration();
108         Configuration composite = setupCompositeConfiguration();
109 
110         checkEquality("testLoading", simple, composite);
111     }
112 
113     /***
114      * If we delete a key, does it vanish? Does it leave all
115      * the other keys unchanged? How about an unset key?
116      */
117     public void testDeletingExisting() throws Exception
118     {
119         Configuration simple = setupSimpleConfiguration();
120         Configuration composite = setupCompositeConfiguration();
121 
122         String key = "clear.property";
123 
124         assertTrue(simple.containsKey(key));
125         assertEquals(simple.containsKey(key), composite.containsKey(key));
126 
127         simple.clearProperty(key);
128         composite.clearProperty(key);
129 
130         assertFalse(simple.containsKey(key));
131         assertEquals(simple.containsKey(key), composite.containsKey(key));
132 
133         checkEquality("testDeletingExisting", simple, composite);
134     }
135 
136     public void testDeletingNonExisting() throws Exception
137     {
138         Configuration simple = setupSimpleConfiguration();
139         Configuration composite = setupCompositeConfiguration();
140 
141         String key = "nonexisting.clear.property";
142 
143         assertFalse(simple.containsKey(key));
144         assertEquals(simple.containsKey(key), composite.containsKey(key));
145 
146         simple.clearProperty(key);
147         composite.clearProperty(key);
148 
149         assertFalse(simple.containsKey(key));
150         assertEquals(simple.containsKey(key), composite.containsKey(key));
151 
152         checkEquality("testDeletingNonExisting", simple, composite);
153     }
154 
155     /***
156      * If we set a key, does it work? How about an existing
157      * key? Can we change it?
158      */
159     public void testSettingNonExisting() throws Exception
160     {
161         Configuration simple = setupSimpleConfiguration();
162         Configuration composite = setupCompositeConfiguration();
163 
164         String key = "nonexisting.property";
165         String value = "new value";
166 
167         assertFalse(simple.containsKey(key));
168         assertEquals(simple.containsKey(key), composite.containsKey(key));
169 
170         simple.setProperty(key, value);
171         composite.setProperty(key, value);
172 
173         assertTrue(simple.containsKey(key));
174         assertEquals(simple.containsKey(key), composite.containsKey(key));
175 
176         checkSameKey("testSettingNonExisting", key, simple, composite);
177         checkEquality("testSettingNonExisting", simple, composite);
178     }
179 
180     public void testSettingExisting() throws Exception
181     {
182         Configuration simple = setupSimpleConfiguration();
183         Configuration composite = setupCompositeConfiguration();
184 
185         String key = "existing.property";
186         String value = "new value";
187 
188         assertTrue(simple.containsKey(key));
189         assertFalse(simple.getString(key).equals(value));
190         assertEquals(simple.containsKey(key), composite.containsKey(key));
191 
192         simple.setProperty(key, value);
193         composite.setProperty(key, value);
194 
195         assertTrue(simple.containsKey(key));
196         assertEquals(simple.getString(key), value);
197         assertEquals(simple.containsKey(key), composite.containsKey(key));
198 
199         checkSameKey("testSettingExisting", key, simple, composite);
200         checkEquality("testSettingExisting", simple, composite);
201     }
202 
203     /***
204      * If we add a key, does it work?
205      */
206     public void testAddingUnset() throws Exception
207     {
208         Configuration simple = setupSimpleConfiguration();
209         Configuration composite = setupCompositeConfiguration();
210 
211         String key = "nonexisting.property";
212         String value = "new value";
213 
214         assertFalse(simple.containsKey(key));
215         assertEquals(simple.containsKey(key), composite.containsKey(key));
216 
217         simple.addProperty(key, value);
218         composite.addProperty(key, value);
219 
220         checkSameKey("testAddingUnset", key, simple, composite);
221         checkEquality("testAddingUnset", simple, composite);
222     }
223 
224     /***
225      * If we add a to an existing key, does it work?
226      */
227     public void testAddingSet() throws Exception
228     {
229         Configuration simple = setupSimpleConfiguration();
230         Configuration composite = setupCompositeConfiguration();
231 
232         String key = "existing.property";
233         String value = "new value";
234 
235         assertTrue(simple.containsKey(key));
236         assertEquals(simple.containsKey(key), composite.containsKey(key));
237 
238         simple.addProperty(key, value);
239         composite.addProperty(key, value);
240 
241         assertTrue(simple.containsKey(key));
242         assertEquals(simple.containsKey(key), composite.containsKey(key));
243 
244         checkSameKey("testAddingSet", key, simple, composite);
245         checkEquality("testAddingSet", simple, composite);
246     }
247 }