Source code: org/apache/commons/beanutils/BeanPropertyValueChangeClosureTest.java
1 /*
2 * Copyright 2001-2004 The Apache Software Foundation.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of 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,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 package org.apache.commons.beanutils;
18
19 import junit.framework.TestCase;
20
21
22 /**
23 * Test cases for <code>BeanPropertyValueChangeClosure</code>.
24 *
25 * @author Norm Deane
26 */
27 public class BeanPropertyValueChangeClosureTest extends TestCase {
28
29 private static final Integer expectedIntegerValue = new Integer(123);
30 private static final Float expectedFloatValue = new Float(123.123f);
31 private static final Double expectedDoubleValue = new Double(567879.12344d);
32 private static final Boolean expectedBooleanValue = Boolean.TRUE;
33 private static final Byte expectedByteValue = new Byte("12");
34
35 /**
36 * Constructor for BeanPropertyValueChangeClosureTest.
37 *
38 * @param name Name of this test case.
39 */
40 public BeanPropertyValueChangeClosureTest(String name) {
41 super(name);
42 }
43
44 /**
45 * Test execute with simple float property and Float value.
46 */
47 public void testExecuteWithSimpleFloatPropertyAndFloatValue() {
48 TestBean testBean = new TestBean();
49 new BeanPropertyValueChangeClosure("floatProperty", expectedFloatValue).execute(testBean);
50 assertTrue(expectedFloatValue.floatValue() == testBean.getFloatProperty());
51 }
52
53 /**
54 * Test execute with simple float property and String value.
55 */
56 public void testExecuteWithSimpleFloatPropertyAndStringValue() {
57 try {
58 new BeanPropertyValueChangeClosure("floatProperty", "123").execute(new TestBean());
59 fail("Should have thrown an IllegalArgumentException");
60 } catch (IllegalArgumentException e) {
61 /* this is what we expect */
62 }
63 }
64
65 /**
66 * Test execute with simple float property and Double value.
67 */
68 public void testExecuteWithSimpleFloatPropertyAndDoubleValue() {
69 try {
70 new BeanPropertyValueChangeClosure("floatProperty", expectedDoubleValue).execute(new TestBean());
71 fail("Should have thrown an IllegalArgumentException");
72 } catch (IllegalArgumentException e) {
73 /* this is what we expect */
74 }
75 }
76
77 /**
78 * Test execute with simple float property and Integer value.
79 */
80 public void testExecuteWithSimpleFloatPropertyAndIntegerValue() {
81 TestBean testBean = new TestBean();
82 new BeanPropertyValueChangeClosure("floatProperty", expectedIntegerValue).execute(testBean);
83 assertTrue(expectedIntegerValue.floatValue() == testBean.getFloatProperty());
84 }
85
86 /**
87 * Test execute with simple double property and Double value.
88 */
89 public void testExecuteWithSimpleDoublePropertyAndDoubleValue() {
90 TestBean testBean = new TestBean();
91 new BeanPropertyValueChangeClosure("doubleProperty", expectedDoubleValue).execute(testBean);
92 assertTrue(expectedDoubleValue.doubleValue() == testBean.getDoubleProperty());
93 }
94
95 /**
96 * Test execute with simple double property and String value.
97 */
98 public void testExecuteWithSimpleDoublePropertyAndStringValue() {
99 try {
100 new BeanPropertyValueChangeClosure("doubleProperty", "123").execute(new TestBean());
101 fail("Should have thrown an IllegalArgumentException");
102 } catch (IllegalArgumentException e) {
103 /* this is what we expect */
104 }
105 }
106
107 /**
108 * Test execute with simple double property and Float value.
109 */
110 public void testExecuteWithSimpleDoublePropertyAndFloatValue() {
111 TestBean testBean = new TestBean();
112 new BeanPropertyValueChangeClosure("doubleProperty", expectedFloatValue).execute(testBean);
113 assertTrue(expectedFloatValue.doubleValue() == testBean.getDoubleProperty());
114 }
115
116 /**
117 * Test execute with simple double property and Integer value.
118 */
119 public void testExecuteWithSimpleDoublePropertyAndIntegerValue() {
120 TestBean testBean = new TestBean();
121 new BeanPropertyValueChangeClosure("doubleProperty", expectedIntegerValue).execute(testBean);
122 assertTrue(expectedIntegerValue.doubleValue() == testBean.getDoubleProperty());
123 }
124
125 /**
126 * Test execute with simple int property and Double value.
127 */
128 public void testExecuteWithSimpleIntPropertyAndDoubleValue() {
129 try {
130 new BeanPropertyValueChangeClosure("intProperty", expectedDoubleValue).execute(new TestBean());
131 fail("Should have thrown an IllegalArgumentException");
132 } catch (IllegalArgumentException e) {
133 /* this is what we expect */
134 }
135 }
136
137 /**
138 * Test execute with simple int property and String value.
139 */
140 public void testExecuteWithSimpleIntPropertyAndStringValue() {
141 try {
142 new BeanPropertyValueChangeClosure("intProperty", "123").execute(new TestBean());
143 fail("Should have thrown an IllegalArgumentException");
144 } catch (IllegalArgumentException e) {
145 /* this is what we expect */
146 }
147 }
148
149 /**
150 * Test execute with simple int property and Float value.
151 */
152 public void testExecuteWithSimpleIntPropertyAndFloatValue() {
153 try {
154 new BeanPropertyValueChangeClosure("intProperty", expectedFloatValue).execute(new TestBean());
155 fail("Should have thrown an IllegalArgumentException");
156 } catch (IllegalArgumentException e) {
157 /* this is what we expect */
158 }
159 }
160
161 /**
162 * Test execute with simple int property and Integer value.
163 */
164 public void testExecuteWithSimpleIntPropertyAndIntegerValue() {
165 TestBean testBean = new TestBean();
166 new BeanPropertyValueChangeClosure("intProperty", expectedIntegerValue).execute(testBean);
167 assertTrue(expectedIntegerValue.intValue() == testBean.getIntProperty());
168 }
169
170 /**
171 * Test execute with simple boolean property and Boolean value.
172 */
173 public void testExecuteWithSimpleBooleanPropertyAndBooleanValue() {
174 TestBean testBean = new TestBean();
175 new BeanPropertyValueChangeClosure("booleanProperty", expectedBooleanValue).execute(testBean);
176 assertTrue(expectedBooleanValue.booleanValue() == testBean.getBooleanProperty());
177 }
178
179 /**
180 * Test execute with simple boolean property and String value.
181 */
182 public void testExecuteWithSimpleBooleanPropertyAndStringValue() {
183 try {
184 new BeanPropertyValueChangeClosure("booleanProperty", "true").execute(new TestBean());
185 fail("Should have thrown an IllegalArgumentException");
186 } catch (IllegalArgumentException e) {
187 /* this is what we expect */
188 }
189 }
190
191 /**
192 * Test execute with simple byte property and Byte value.
193 */
194 public void testExecuteWithSimpleBytePropertyAndByteValue() {
195 TestBean testBean = new TestBean();
196 new BeanPropertyValueChangeClosure("byteProperty", expectedByteValue).execute(testBean);
197 assertTrue(expectedByteValue.byteValue() == testBean.getByteProperty());
198 }
199
200 /**
201 * Test execute with simple boolean property and String value.
202 */
203 public void testExecuteWithSimpleBytePropertyAndStringValue() {
204 try {
205 new BeanPropertyValueChangeClosure("byteProperty", "foo").execute(new TestBean());
206 fail("Should have thrown an IllegalArgumentException");
207 } catch (IllegalArgumentException e) {
208 /* this is what we expect */
209 }
210 }
211
212 /**
213 * Test execute with simple primitive property and null value.
214 */
215 public void testExecuteWithSimplePrimitivePropertyAndNullValue() {
216 try {
217 new BeanPropertyValueChangeClosure("intProperty", null).execute(new TestBean());
218 fail("Should have thrown an IllegalArgumentException");
219 } catch (NullPointerException e) {
220 /* this is what we expect */
221 }
222 }
223
224 /**
225 * Test execute with read only property.
226 */
227 public void testExecuteWithReadOnlyProperty() {
228 try {
229 new BeanPropertyValueChangeClosure("readOnlyProperty", "foo").execute(new TestBean());
230 fail("Should have thrown an IllegalArgumentException");
231 } catch (IllegalArgumentException e) {
232 /* this is what we expect */
233 }
234 }
235
236 /**
237 * Test execute with write only property.
238 */
239 public void testExecuteWithWriteOnlyProperty() {
240 TestBean testBean = new TestBean();
241 new BeanPropertyValueChangeClosure("writeOnlyProperty", "foo").execute(testBean);
242 assertEquals("foo", testBean.getWriteOnlyPropertyValue());
243 }
244
245 /**
246 * Test execute with a nested property.
247 */
248 public void testExecuteWithNestedProperty() {
249 TestBean testBean = new TestBean();
250 new BeanPropertyValueChangeClosure("nested.stringProperty", "bar").execute(testBean);
251 assertEquals("bar", testBean.getNested().getStringProperty());
252 }
253
254 /**
255 * Test execute with a nested property and null in the property path.
256 */
257 public void testExecuteWithNullInPropertyPath() {
258 try {
259 new BeanPropertyValueChangeClosure("anotherNested.stringProperty", "foo").execute(new TestBean());
260 fail("Should have thrown an IllegalArgumentException");
261 } catch (IllegalArgumentException e) {
262 /* this is what we expect */
263 }
264 }
265
266 /**
267 * Test execute with a nested property and null in the property path and ignoreNull = true.
268 */
269 public void testExecuteWithNullInPropertyPathAngIgnoreTrue() {
270 TestBean testBean = new TestBean();
271
272 // create a closure that will attempt to set a property on the null bean in the path
273 BeanPropertyValueChangeClosure closure = new BeanPropertyValueChangeClosure("anotherNested.stringProperty",
274 "Should ignore exception", true);
275
276 try {
277 closure.execute(testBean);
278 } catch (IllegalArgumentException e) {
279 fail("Should have ignored the exception.");
280 }
281 }
282
283 /**
284 * Test execute with indexed property.
285 */
286 public void testExecuteWithIndexedProperty() {
287 TestBean testBean = new TestBean();
288 new BeanPropertyValueChangeClosure("intIndexed[0]", expectedIntegerValue).execute(testBean);
289 assertTrue(expectedIntegerValue.intValue() == testBean.getIntIndexed(0));
290 }
291
292 /**
293 * Test execute with mapped property.
294 */
295 public void testExecuteWithMappedProperty() {
296 TestBean testBean = new TestBean();
297 new BeanPropertyValueChangeClosure("mappedProperty(fred)", "barney").execute(testBean);
298 assertEquals("barney", testBean.getMappedProperty("fred"));
299 }
300
301 /**
302 * Test execute with a simple String property.
303 */
304 public void testExecuteWithSimpleStringProperty() {
305 TestBean testBean = new TestBean();
306 new BeanPropertyValueChangeClosure("stringProperty", "barney").execute(testBean);
307 assertEquals("barney", testBean.getStringProperty());
308 }
309
310 /**
311 * Test execute with an invalid property name.
312 */
313 public void testExecuteWithInvalidPropertyName() {
314 try {
315 new BeanPropertyValueChangeClosure("bogusProperty", "foo").execute(new TestBean());
316 fail("Should have thrown an IllegalArgumentException");
317 } catch (IllegalArgumentException e) {
318 /* this is what we expect */
319 }
320 }
321 }