1   /*
2    * Copyright 2002-2004 the original author or authors.
3    * 
4    * Licensed under the Apache License, Version 2.0 (the "License"); you may not
5    * use this file except in compliance with the License. You may obtain a copy of
6    * the License at
7    * 
8    * http://www.apache.org/licenses/LICENSE-2.0
9    * 
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12   * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13   * License for the specific language governing permissions and limitations under
14   * the License.
15   */
16  package org.springframework.richclient.settings;
17  
18  import java.util.Arrays;
19  
20  import junit.framework.TestCase;
21  
22  import org.springframework.core.enums.LabeledEnum;
23  
24  /**
25   * @author Peter De Bruycker
26   */
27  public abstract class SettingsAbstractTests extends TestCase {
28      private Settings settings;
29  
30      private TestablePropertyChangeListener propertyChangeListener;
31  
32      protected final void setUp() throws Exception {
33          doSetUp();
34  
35          settings = createSettings();
36          propertyChangeListener = new TestablePropertyChangeListener();
37          settings.addPropertyChangeListener( propertyChangeListener );
38  
39          assertNotNull( "settings cannot be null", settings );
40      }
41  
42      protected void doSetUp() throws Exception {
43  
44      }
45  
46      public final void testGetSettings() {
47          Settings childSettings = settings.getSettings( "child" );
48          assertTrue( Arrays.asList( settings.getChildSettings() ).contains( "child" ) );
49  
50          assertNotNull( childSettings );
51          assertEquals( "child", childSettings.getName() );
52          assertEquals( settings, childSettings.getParent() );
53      }
54  
55      public final void testRemove() {
56          settings.setString( "key", "value" );
57          assertTrue( settings.contains( "key" ) );
58          settings.remove( "key" );
59          assertFalse( settings.contains( "key" ) );
60      }
61  
62      public final void testRemoveSettings() {
63          Settings childSettings = settings.getSettings( "child" );
64          assertTrue( Arrays.asList( settings.getChildSettings() ).contains( "child" ) );
65  
66          childSettings.removeSettings();
67  
68          assertFalse( Arrays.asList( settings.getChildSettings() ).contains( "child" ) );
69      }
70  
71      public final void testBoolean() {
72          String key = "boolean-value";
73          Boolean defaultValue = Boolean.FALSE;
74          Boolean newValue = Boolean.TRUE;
75  
76          // default value
77          assertEquals( defaultValue.booleanValue(), settings.getBoolean( key ) );
78          assertEquals( defaultValue.booleanValue(), settings.getDefaultBoolean( key ) );
79          assertTrue( settings.isDefault( key ) );
80          assertFalse( settings.contains( key ) );
81  
82          // change the value
83          settings.setBoolean( key, newValue.booleanValue() );
84  
85          assertEquals( newValue.booleanValue(), settings.getBoolean( key ) );
86          assertFalse( settings.isDefault( key ) );
87          assertTrue( settings.contains( key ) );
88  
89          // check property change event
90          assertPropertyChangeEventFired( key, defaultValue, newValue );
91          propertyChangeListener.reset();
92  
93          // change the value to the same value, no property change event should
94          // be fired
95          settings.setBoolean( key, newValue.booleanValue() );
96          assertEquals( 0, propertyChangeListener.getCount() );
97      }
98  
99      public final void testInt() {
100         String key = "int-value";
101         Integer defaultValue = new Integer( 0 );
102         Integer newValue = new Integer( 5 );
103 
104         // default value
105         assertEquals( defaultValue.intValue(), settings.getInt( key ) );
106         assertEquals( defaultValue.intValue(), settings.getDefaultInt( key ) );
107         assertTrue( settings.isDefault( key ) );
108         assertFalse( settings.contains( key ) );
109 
110         // change the value
111         settings.setInt( key, newValue.intValue() );
112 
113         assertEquals( newValue.intValue(), settings.getInt( key ) );
114         assertFalse( settings.isDefault( key ) );
115         assertTrue( settings.contains( key ) );
116 
117         // check property change event
118         assertPropertyChangeEventFired( key, defaultValue, newValue );
119         propertyChangeListener.reset();
120 
121         // change the value to the same value, no property change event should
122         // be fired
123         settings.setInt( key, newValue.intValue() );
124         assertEquals( 0, propertyChangeListener.getCount() );
125     }
126 
127     public final void testLong() {
128         String key = "long-value";
129         Long defaultValue = new Long( 0 );
130         Long newValue = new Long( 555L );
131 
132         // default value
133         assertEquals( defaultValue.longValue(), settings.getLong( key ) );
134         assertEquals( defaultValue.longValue(), settings.getDefaultLong( key ) );
135         assertTrue( settings.isDefault( key ) );
136         assertFalse( settings.contains( key ) );
137 
138         // change the value
139         settings.setLong( key, newValue.longValue() );
140 
141         assertEquals( newValue.longValue(), settings.getLong( key ) );
142         assertFalse( settings.isDefault( key ) );
143         assertTrue( settings.contains( key ) );
144 
145         // check property change event
146         assertPropertyChangeEventFired( key, defaultValue, newValue );
147         propertyChangeListener.reset();
148 
149         // change the value to the same value, no property change event should
150         // be fired
151         settings.setLong( key, newValue.longValue() );
152         assertEquals( 0, propertyChangeListener.getCount() );
153     }
154 
155     public final void testFloat() {
156         String key = "float-value";
157         Float defaultValue = new Float( 0.0f );
158         Float newValue = new Float( 1.23f );
159 
160         // default value
161         assertEquals( defaultValue.floatValue(), settings.getFloat( key ), 0.0f );
162         assertEquals( defaultValue.floatValue(), settings.getDefaultFloat( key ), 0.0f );
163         assertTrue( settings.isDefault( key ) );
164         assertFalse( settings.contains( key ) );
165 
166         // change the value
167         settings.setFloat( key, newValue.floatValue() );
168 
169         assertEquals( newValue.floatValue(), settings.getFloat( key ), 0.0f );
170         assertFalse( settings.isDefault( key ) );
171         assertTrue( settings.contains( key ) );
172 
173         // check property change event
174         assertPropertyChangeEventFired( key, defaultValue, newValue );
175         propertyChangeListener.reset();
176 
177         // change the value to the same value, no property change event should
178         // be fired
179         settings.setFloat( key, newValue.floatValue() );
180         assertEquals( 0, propertyChangeListener.getCount() );
181     }
182 
183     public final void testDouble() {
184         String key = "double-value";
185         Double defaultValue = new Double( 0.0 );
186         Double newValue = new Double( 1.23 );
187 
188         // default value
189         assertEquals( defaultValue.doubleValue(), settings.getDouble( key ), 0.0 );
190         assertEquals( defaultValue.doubleValue(), settings.getDefaultDouble( key ), 0.0 );
191         assertTrue( settings.isDefault( key ) );
192         assertFalse( settings.contains( key ) );
193 
194         // change the value
195         settings.setDouble( key, newValue.doubleValue() );
196 
197         assertEquals( newValue.doubleValue(), settings.getDouble( key ), 0.0 );
198         assertFalse( settings.isDefault( key ) );
199         assertTrue( settings.contains( key ) );
200 
201         // check property change event
202         assertPropertyChangeEventFired( key, defaultValue, newValue );
203         propertyChangeListener.reset();
204 
205         // change the value to the same value, no property change event should
206         // be fired
207         settings.setDouble( key, newValue.doubleValue() );
208         assertEquals( 0, propertyChangeListener.getCount() );
209     }
210 
211     public final void testString() {
212         String key = "string-value";
213         String defaultValue = "";
214         String newValue = "value";
215 
216         // default value
217         assertEquals( defaultValue, settings.getString( key ) );
218         assertEquals( defaultValue, settings.getDefaultString( key ) );
219         assertTrue( settings.isDefault( key ) );
220         assertFalse( settings.contains( key ) );
221 
222         // change the value
223         settings.setString( key, newValue );
224 
225         assertEquals( newValue, settings.getString( key ) );
226         assertFalse( settings.isDefault( key ) );
227         assertTrue( settings.contains( key ) );
228 
229         // check property change event
230         assertPropertyChangeEventFired( key, defaultValue, newValue );
231         propertyChangeListener.reset();
232 
233         // change the value to the same value, no property change event should
234         // be fired
235         settings.setString( key, newValue );
236         assertEquals( 0, propertyChangeListener.getCount() );
237     }
238 
239     public final void testEnum() {
240         String key = "enum-value";
241         LabeledEnum defaultValue = null;
242         LabeledEnum newValue = TestEnum.ENUM2;
243 
244         // default value
245         assertEquals( defaultValue, settings.getLabeledEnum( key ) );
246         assertEquals( defaultValue, settings.getDefaultLabeledEnum( key ) );
247         assertTrue( settings.isDefault( key ) );
248         assertFalse( settings.contains( key ) );
249 
250         // change the value
251         settings.setLabeledEnum( key, newValue );
252 
253         assertEquals( newValue, settings.getLabeledEnum( key ) );
254         assertFalse( settings.isDefault( key ) );
255         assertTrue( settings.contains( key ) );
256 
257         // check property change event
258         assertPropertyChangeEventFired( key, defaultValue, newValue );
259         propertyChangeListener.reset();
260 
261         // change the value to the same value, no property change event should
262         // be fired
263         settings.setLabeledEnum( key, newValue );
264         assertEquals( 0, propertyChangeListener.getCount() );
265     }
266 
267     private void assertPropertyChangeEventFired( String key, Object oldValue, Object newValue ) {
268         assertEquals( 1, propertyChangeListener.getCount() );
269         assertEquals( key, propertyChangeListener.getEvent().getPropertyName() );
270         assertEquals( newValue, propertyChangeListener.getEvent().getNewValue() );
271         assertEquals( oldValue, propertyChangeListener.getEvent().getOldValue() );
272     }
273 
274     protected abstract Settings createSettings() throws Exception;
275 }