1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 package org.apache.commons.beanutils;
19
20
21 import java.util.ArrayList;
22 import java.util.HashMap;
23 import java.util.List;
24 import java.util.Map;
25
26
27 /**
28 * General purpose test bean for JUnit tests for the "beanutils" component.
29 *
30 * @author Craig R. McClanahan
31 * @author Rodney Waldhoff
32 * @version $Revision: 1.20 $ $Date: 2004/02/28 13:18:36 $
33 */
34
35 public class TestBean {
36
37
38
39 public TestBean() {
40 }
41
42 public TestBean(String stringProperty) {
43 setStringProperty(stringProperty);
44 }
45
46 public TestBean(float floatProperty) {
47 setFloatProperty(floatProperty);
48 }
49
50 public TestBean(boolean booleanProperty) {
51 setBooleanProperty(booleanProperty);
52 }
53
54 public TestBean(Boolean booleanSecond) {
55 setBooleanSecond(booleanSecond.booleanValue());
56 }
57
58 public TestBean(float floatProperty, String stringProperty) {
59 setFloatProperty(floatProperty);
60 setStringProperty(stringProperty);
61 }
62
63 public TestBean(boolean booleanProperty, String stringProperty) {
64 setBooleanProperty(booleanProperty);
65 setStringProperty(stringProperty);
66 }
67
68 public TestBean(Boolean booleanSecond, String stringProperty) {
69 setBooleanSecond(booleanSecond.booleanValue());
70 setStringProperty(stringProperty);
71 }
72
73 public TestBean(Integer intProperty) {
74 setIntProperty(intProperty.intValue());
75 }
76
77 public TestBean(double doubleProperty) {
78 setDoubleProperty(doubleProperty);
79 }
80
81 TestBean(int intProperty) {
82 setIntProperty(intProperty);
83 }
84
85 protected TestBean(boolean booleanProperty, boolean booleanSecond, String stringProperty) {
86 setBooleanProperty(booleanProperty);
87 setBooleanSecond(booleanSecond);
88 setStringProperty(stringProperty);
89 }
90
91
92
93
94 /**
95 * A boolean property.
96 */
97 private boolean booleanProperty = true;
98
99 public boolean getBooleanProperty() {
100 return (booleanProperty);
101 }
102
103 public void setBooleanProperty(boolean booleanProperty) {
104 this.booleanProperty = booleanProperty;
105 }
106
107
108 /**
109 * A boolean property that uses an "is" method for the getter.
110 */
111 private boolean booleanSecond = true;
112
113 public boolean isBooleanSecond() {
114 return (booleanSecond);
115 }
116
117 public void setBooleanSecond(boolean booleanSecond) {
118 this.booleanSecond = booleanSecond;
119 }
120
121
122 /**
123 * A byte property.
124 */
125 private byte byteProperty = (byte) 121;
126
127 public byte getByteProperty() {
128 return (this.byteProperty);
129 }
130
131 public void setByteProperty(byte byteProperty) {
132 this.byteProperty = byteProperty;
133 }
134
135
136 /**
137 * A double property.
138 */
139 private double doubleProperty = 321.0;
140
141 public double getDoubleProperty() {
142 return (this.doubleProperty);
143 }
144
145 public void setDoubleProperty(double doubleProperty) {
146 this.doubleProperty = doubleProperty;
147 }
148
149
150 /**
151 * An "indexed property" accessible via both array and subscript
152 * based getters and setters.
153 */
154 private String dupProperty[] =
155 { "Dup 0", "Dup 1", "Dup 2", "Dup 3", "Dup 4" };
156
157 public String[] getDupProperty() {
158 return (this.dupProperty);
159 }
160
161 public String getDupProperty(int index) {
162 return (this.dupProperty[index]);
163 }
164
165 public void setDupProperty(int index, String value) {
166 this.dupProperty[index] = value;
167 }
168
169 public void setDupProperty(String dupProperty[]) {
170 this.dupProperty = dupProperty;
171 }
172
173
174 /**
175 * A float property.
176 */
177 private float floatProperty = (float) 123.0;
178
179 public float getFloatProperty() {
180 return (this.floatProperty);
181 }
182
183 public void setFloatProperty(float floatProperty) {
184 this.floatProperty = floatProperty;
185 }
186
187
188 /**
189 * An integer array property accessed as an array.
190 */
191 private int intArray[] = { 0, 10, 20, 30, 40 };
192
193 public int[] getIntArray() {
194 return (this.intArray);
195 }
196
197 public void setIntArray(int intArray[]) {
198 this.intArray = intArray;
199 }
200
201
202 /**
203 * An integer array property accessed as an indexed property.
204 */
205 private int intIndexed[] = { 0, 10, 20, 30, 40 };
206
207 public int getIntIndexed(int index) {
208 return (intIndexed[index]);
209 }
210
211 public void setIntIndexed(int index, int value) {
212 intIndexed[index] = value;
213 }
214
215
216 /**
217 * An integer property.
218 */
219 private int intProperty = 123;
220
221 public int getIntProperty() {
222 return (this.intProperty);
223 }
224
225 public void setIntProperty(int intProperty) {
226 this.intProperty = intProperty;
227 }
228
229
230 /**
231 * A List property accessed as an indexed property.
232 */
233 private static List listIndexed = new ArrayList();
234
235 static {
236 listIndexed.add("String 0");
237 listIndexed.add("String 1");
238 listIndexed.add("String 2");
239 listIndexed.add("String 3");
240 listIndexed.add("String 4");
241 }
242
243 public List getListIndexed() {
244 return (listIndexed);
245 }
246
247
248 /**
249 * A long property.
250 */
251 private long longProperty = 321;
252
253 public long getLongProperty() {
254 return (this.longProperty);
255 }
256
257 public void setLongProperty(long longProperty) {
258 this.longProperty = longProperty;
259 }
260
261
262 /**
263 * A mapped property with only a getter and setter for a Map.
264 */
265 private Map mapProperty = null;
266
267 public Map getMapProperty() {
268
269 if (mapProperty == null) {
270 mapProperty = new HashMap();
271 mapProperty.put("First Key", "First Value");
272 mapProperty.put("Second Key", "Second Value");
273 }
274 return (mapProperty);
275 }
276
277 public void setMapProperty(Map mapProperty) {
278
279 if (mapProperty == null) {
280 mapProperty = new HashMap();
281 mapProperty.put("First Key", "First Value");
282 mapProperty.put("Second Key", "Second Value");
283 }
284 this.mapProperty = mapProperty;
285 }
286
287
288 /**
289 * A mapped property that has String keys and Object values.
290 */
291 private HashMap mappedObjects = null;
292
293 public Object getMappedObjects(String key) {
294
295 if (mappedObjects == null) {
296 mappedObjects = new HashMap();
297 mappedObjects.put("First Key", "First Value");
298 mappedObjects.put("Second Key", "Second Value");
299 }
300 return (mappedObjects.get(key));
301 }
302
303 public void setMappedObjects(String key, Object value) {
304
305 if (mappedObjects == null) {
306 mappedObjects = new HashMap();
307 mappedObjects.put("First Key", "First Value");
308 mappedObjects.put("Second Key", "Second Value");
309 }
310 mappedObjects.put(key, value);
311 }
312
313
314 /**
315 * A mapped property that has String keys and String values.
316 */
317 private HashMap mappedProperty = null;
318
319 public String getMappedProperty(String key) {
320
321 if (mappedProperty == null) {
322 mappedProperty = new HashMap();
323 mappedProperty.put("First Key", "First Value");
324 mappedProperty.put("Second Key", "Second Value");
325 }
326 return ((String) mappedProperty.get(key));
327 }
328
329 public void setMappedProperty(String key, String value) {
330
331 if (mappedProperty == null) {
332 mappedProperty = new HashMap();
333 mappedProperty.put("First Key", "First Value");
334 mappedProperty.put("Second Key", "Second Value");
335 }
336 mappedProperty.put(key, value);
337 }
338
339
340 /**
341 * A mapped property that has String keys and int values.
342 */
343 private HashMap mappedIntProperty = null;
344
345 public int getMappedIntProperty(String key) {
346
347 if (mappedProperty == null) {
348 mappedProperty = new HashMap();
349 mappedProperty.put("One", new Integer(1));
350 mappedProperty.put("Two", new Integer(2));
351 }
352 Integer x = (Integer) mappedIntProperty.get(key);
353 return ((x == null) ? 0 : x.intValue());
354 }
355
356 public void setMappedIntProperty(String key, int value) {
357 mappedIntProperty.put(key, new Integer(value));
358 }
359
360
361 /**
362 * A nested reference to another test bean (populated as needed).
363 */
364 private TestBean nested = null;
365
366 public TestBean getNested() {
367 if (nested == null)
368 nested = new TestBean();
369 return (nested);
370 }
371
372 /**
373 * Another nested reference to another test bean,
374 */
375 private TestBean anotherNested = null;
376
377 public TestBean getAnotherNested() {
378 return anotherNested;
379 }
380
381 public void setAnotherNested( TestBean anotherNested ) {
382 this.anotherNested = anotherNested;
383 }
384
385
386
387
388 class MappedTestBean {
389 public void setValue(String key,String val) { }
390 public String getValue(String key) { return "Mapped Value"; }
391 }
392
393 private MappedTestBean mappedNested = null;
394
395 public MappedTestBean getMappedNested() {
396 if (mappedNested == null)
397 {
398 mappedNested = new MappedTestBean();
399 }
400 return mappedNested;
401 }
402
403 /**
404 * A String property with an initial value of null.
405 */
406 private String nullProperty = null;
407
408 public String getNullProperty() {
409 return (this.nullProperty);
410 }
411
412 public void setNullProperty(String nullProperty) {
413 this.nullProperty = nullProperty;
414 }
415
416
417 /**
418 * A read-only String property.
419 */
420 private String readOnlyProperty = "Read Only String Property";
421
422 public String getReadOnlyProperty() {
423 return (this.readOnlyProperty);
424 }
425
426
427 /**
428 * A short property.
429 */
430 private short shortProperty = (short) 987;
431
432 public short getShortProperty() {
433 return (this.shortProperty);
434 }
435
436 public void setShortProperty(short shortProperty) {
437 this.shortProperty = shortProperty;
438 }
439
440
441 /**
442 * A String array property accessed as a String.
443 */
444 private String stringArray[] =
445 { "String 0", "String 1", "String 2", "String 3", "String 4" };
446
447 public String[] getStringArray() {
448 return (this.stringArray);
449 }
450
451 public void setStringArray(String stringArray[]) {
452 this.stringArray = stringArray;
453 }
454
455
456 /**
457 * A String array property accessed as an indexed property.
458 */
459 private String stringIndexed[] =
460 { "String 0", "String 1", "String 2", "String 3", "String 4" };
461
462 public String getStringIndexed(int index) {
463 return (stringIndexed[index]);
464 }
465
466 public void setStringIndexed(int index, String value) {
467 stringIndexed[index] = value;
468 }
469
470
471 /**
472 * A String property.
473 */
474 private String stringProperty = "This is a string";
475
476 public String getStringProperty() {
477 return (this.stringProperty);
478 }
479
480 public void setStringProperty(String stringProperty) {
481 this.stringProperty = stringProperty;
482 }
483
484
485 /**
486 * A write-only String property.
487 */
488 private String writeOnlyProperty = "Write Only String Property";
489
490 public String getWriteOnlyPropertyValue() {
491 return (this.writeOnlyProperty);
492 }
493
494 public void setWriteOnlyProperty(String writeOnlyProperty) {
495 this.writeOnlyProperty = writeOnlyProperty;
496 }
497
498
499
500
501
502 /**
503 * <p>An invalid property that has two boolean getters (getInvalidBoolean
504 * and isInvalidBoolean) plus a String setter (setInvalidBoolean). By the
505 * rules described in the JavaBeans Specification, this will be considered
506 * a read-only boolean property, using isInvalidBoolean() as the getter.</p>
507 */
508 private boolean invalidBoolean = false;
509
510 public boolean getInvalidBoolean() {
511 return (this.invalidBoolean);
512 }
513
514 public boolean isInvalidBoolean() {
515 return (this.invalidBoolean);
516 }
517
518 public void setInvalidBoolean(String invalidBoolean) {
519 if ("true".equalsIgnoreCase(invalidBoolean) ||
520 "yes".equalsIgnoreCase(invalidBoolean) ||
521 "1".equalsIgnoreCase(invalidBoolean)) {
522 this.invalidBoolean = true;
523 } else {
524 this.invalidBoolean = false;
525 }
526 }
527
528
529
530
531
532
533 /**
534 * A static variable that is accessed and updated via static methods
535 * for MethodUtils testing.
536 */
537 private static int counter = 0;
538
539
540 /**
541 * Return the current value of the counter.
542 */
543 public static int currentCounter() {
544
545 return (counter);
546
547 }
548
549
550 /**
551 * Increment the current value of the counter by 1.
552 */
553 public static void incrementCounter() {
554
555 incrementCounter(1);
556
557 }
558
559
560 /**
561 * Increment the current value of the counter by the specified amount.
562 *
563 * @param amount Amount to be added to the current counter
564 */
565 public static void incrementCounter(int amount) {
566
567 counter += amount;
568
569 }
570
571
572 }