001 /*
002 * Copyright 2002-2004 the original author or authors.
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
005 * use this file except in compliance with the License. You may obtain a copy of
006 * the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
012 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
013 * License for the specific language governing permissions and limitations under
014 * the License.
015 */
016 package org.springframework.richclient.settings;
017
018 import java.util.Arrays;
019
020 import junit.framework.TestCase;
021
022 import org.springframework.core.enums.LabeledEnum;
023
024 /**
025 * @author Peter De Bruycker
026 */
027 public abstract class SettingsAbstractTests extends TestCase {
028 private Settings settings;
029
030 private TestablePropertyChangeListener propertyChangeListener;
031
032 protected final void setUp() throws Exception {
033 doSetUp();
034
035 settings = createSettings();
036 propertyChangeListener = new TestablePropertyChangeListener();
037 settings.addPropertyChangeListener( propertyChangeListener );
038
039 assertNotNull( "settings cannot be null", settings );
040 }
041
042 protected void doSetUp() throws Exception {
043
044 }
045
046 public final void testGetSettings() {
047 Settings childSettings = settings.getSettings( "child" );
048 assertTrue( Arrays.asList( settings.getChildSettings() ).contains( "child" ) );
049
050 assertNotNull( childSettings );
051 assertEquals( "child", childSettings.getName() );
052 assertEquals( settings, childSettings.getParent() );
053 }
054
055 public final void testRemove() {
056 settings.setString( "key", "value" );
057 assertTrue( settings.contains( "key" ) );
058 settings.remove( "key" );
059 assertFalse( settings.contains( "key" ) );
060 }
061
062 public final void testRemoveSettings() {
063 Settings childSettings = settings.getSettings( "child" );
064 assertTrue( Arrays.asList( settings.getChildSettings() ).contains( "child" ) );
065
066 childSettings.removeSettings();
067
068 assertFalse( Arrays.asList( settings.getChildSettings() ).contains( "child" ) );
069 }
070
071 public final void testBoolean() {
072 String key = "boolean-value";
073 Boolean defaultValue = Boolean.FALSE;
074 Boolean newValue = Boolean.TRUE;
075
076 // default value
077 assertEquals( defaultValue.booleanValue(), settings.getBoolean( key ) );
078 assertEquals( defaultValue.booleanValue(), settings.getDefaultBoolean( key ) );
079 assertTrue( settings.isDefault( key ) );
080 assertFalse( settings.contains( key ) );
081
082 // change the value
083 settings.setBoolean( key, newValue.booleanValue() );
084
085 assertEquals( newValue.booleanValue(), settings.getBoolean( key ) );
086 assertFalse( settings.isDefault( key ) );
087 assertTrue( settings.contains( key ) );
088
089 // check property change event
090 assertPropertyChangeEventFired( key, defaultValue, newValue );
091 propertyChangeListener.reset();
092
093 // change the value to the same value, no property change event should
094 // be fired
095 settings.setBoolean( key, newValue.booleanValue() );
096 assertEquals( 0, propertyChangeListener.getCount() );
097 }
098
099 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 }