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.sql.Date;
22 import java.sql.Time;
23 import java.sql.Timestamp;
24 import java.text.DateFormat;
25 import java.text.SimpleDateFormat;
26 import java.util.Locale;
27
28 import junit.framework.Test;
29 import junit.framework.TestCase;
30 import junit.framework.TestSuite;
31
32 import org.apache.commons.beanutils.converters.DateConverter;
33
34
35
36
37
38
39
40
41
42
43 public class ConvertUtilsTestCase extends TestCase {
44
45
46
47
48
49
50
51
52
53
54
55
56 public ConvertUtilsTestCase(final String name) {
57 super(name);
58 }
59
60
61
62
63
64
65
66
67 @Override
68 public void setUp() {
69
70 ConvertUtils.deregister();
71
72 }
73
74
75
76
77
78 public static Test suite() {
79 return (new TestSuite(ConvertUtilsTestCase.class));
80 }
81
82
83
84
85
86 @Override
87 public void tearDown() {
88
89 }
90
91
92
93
94
95
96
97
98 public void testNegativeIntegerArray() {
99
100 Object value = null;
101 final int intArray[] = new int[0];
102
103 value = ConvertUtils.convert((String) null, intArray.getClass());
104 checkIntegerArray(value, intArray);
105 value = ConvertUtils.convert("a", intArray.getClass());
106 checkIntegerArray(value, intArray);
107 value = ConvertUtils.convert("{ a }", intArray.getClass());
108 checkIntegerArray(value, intArray);
109 value = ConvertUtils.convert("1a3", intArray.getClass());
110 checkIntegerArray(value, intArray);
111 value = ConvertUtils.convert("{ 1a3 }", intArray.getClass());
112 checkIntegerArray(value, intArray);
113 value = ConvertUtils.convert("0,1a3", intArray.getClass());
114 checkIntegerArray(value, intArray);
115 value = ConvertUtils.convert("{ 0, 1a3 }", intArray.getClass());
116 checkIntegerArray(value, intArray);
117
118
119 }
120
121
122
123
124
125
126 public void testNegativeScalar() {
127
128 Object value = null;
129
130 value = ConvertUtils.convert("foo", Boolean.TYPE);
131 assertTrue(value instanceof Boolean);
132 assertEquals(((Boolean) value).booleanValue(), false);
133
134 value = ConvertUtils.convert("foo", Boolean.class);
135 assertTrue(value instanceof Boolean);
136 assertEquals(((Boolean) value).booleanValue(), false);
137
138 value = ConvertUtils.convert("foo", Byte.TYPE);
139 assertTrue(value instanceof Byte);
140 assertEquals(((Byte) value).byteValue(), (byte) 0);
141
142 value = ConvertUtils.convert("foo", Byte.class);
143 assertTrue(value instanceof Byte);
144 assertEquals(((Byte) value).byteValue(), (byte) 0);
145
146 try {
147 value = ConvertUtils.convert
148 ("org.apache.commons.beanutils.Undefined", Class.class);
149 fail("Should have thrown conversion exception");
150 } catch (final ConversionException e) {
151
152 }
153
154 value = ConvertUtils.convert("foo", Double.TYPE);
155 assertTrue(value instanceof Double);
156 assertEquals(((Double) value).doubleValue(), 0.0,
157 0.005);
158
159 value = ConvertUtils.convert("foo", Double.class);
160 assertTrue(value instanceof Double);
161 assertEquals(((Double) value).doubleValue(), 0.0, 0.005);
162
163 value = ConvertUtils.convert("foo", Float.TYPE);
164 assertTrue(value instanceof Float);
165 assertEquals(((Float) value).floatValue(), (float) 0.0,
166 (float) 0.005);
167
168 value = ConvertUtils.convert("foo", Float.class);
169 assertTrue(value instanceof Float);
170 assertEquals(((Float) value).floatValue(), (float) 0.0,
171 (float) 0.005);
172
173 value = ConvertUtils.convert("foo", Integer.TYPE);
174 assertTrue(value instanceof Integer);
175 assertEquals(((Integer) value).intValue(), 0);
176
177 value = ConvertUtils.convert("foo", Integer.class);
178 assertTrue(value instanceof Integer);
179 assertEquals(((Integer) value).intValue(), 0);
180
181 value = ConvertUtils.convert("foo", Byte.TYPE);
182 assertTrue(value instanceof Byte);
183 assertEquals(((Byte) value).byteValue(), (byte) 0);
184
185 value = ConvertUtils.convert("foo", Long.class);
186 assertTrue(value instanceof Long);
187 assertEquals(((Long) value).longValue(), 0);
188
189 value = ConvertUtils.convert("foo", Short.TYPE);
190 assertTrue(value instanceof Short);
191 assertEquals(((Short) value).shortValue(), (short) 0);
192
193 value = ConvertUtils.convert("foo", Short.class);
194 assertTrue(value instanceof Short);
195 assertEquals(((Short) value).shortValue(), (short) 0);
196
197 }
198
199
200
201
202
203 public void testNegativeStringArray() {
204
205 Object value = null;
206 final String stringArray[] = new String[0];
207
208 value = ConvertUtils.convert((String) null, stringArray.getClass());
209 checkStringArray(value, stringArray);
210
211 }
212
213
214
215
216
217 public void testObjectToStringArray() {
218
219 final int intArray0[] = new int[0];
220 final int intArray1[] = { 123 };
221 final int intArray2[] = { 123, 456 };
222 final String stringArray0[] = new String[0];
223 final String stringArray1[] = { "abc" };
224 final String stringArray2[] = { "abc", "def" };
225
226 assertEquals("intArray0", null,
227 ConvertUtils.convert(intArray0));
228 assertEquals("intArray1", "123",
229 ConvertUtils.convert(intArray1));
230 assertEquals("intArray2", "123",
231 ConvertUtils.convert(intArray2));
232
233 assertEquals("stringArray0", null,
234 ConvertUtils.convert(stringArray0));
235 assertEquals("stringArray1", "abc",
236 ConvertUtils.convert(stringArray1));
237 assertEquals("stringArray2", "abc",
238 ConvertUtils.convert(stringArray2));
239
240 }
241
242
243
244
245
246 public void testObjectToStringScalar() {
247
248 assertEquals("Boolean->String", "false",
249 ConvertUtils.convert(Boolean.FALSE));
250 assertEquals("Boolean->String", "true",
251 ConvertUtils.convert(Boolean.TRUE));
252 assertEquals("Byte->String", "123",
253 ConvertUtils.convert(new Byte((byte) 123)));
254 assertEquals("Character->String", "a",
255 ConvertUtils.convert(new Character('a')));
256 assertEquals("Double->String", "123.0",
257 ConvertUtils.convert(new Double(123.0)));
258 assertEquals("Float->String", "123.0",
259 ConvertUtils.convert(new Float((float) 123.0)));
260 assertEquals("Integer->String", "123",
261 ConvertUtils.convert(new Integer(123)));
262 assertEquals("Long->String", "123",
263 ConvertUtils.convert(new Long(123)));
264 assertEquals("Short->String", "123",
265 ConvertUtils.convert(new Short((short) 123)));
266 assertEquals("String->String", "abc",
267 ConvertUtils.convert("abc"));
268 assertEquals("String->String null", null,
269 ConvertUtils.convert(null));
270
271 }
272
273
274
275
276
277 public void testPositiveArray() {
278
279 final String values1[] = { "10", "20", "30" };
280 Object value = ConvertUtils.convert(values1, Integer.TYPE);
281 final int shape[] = new int[0];
282 assertEquals(shape.getClass(), value.getClass());
283 final int results1[] = (int[]) value;
284 assertEquals(results1[0], 10);
285 assertEquals(results1[1], 20);
286 assertEquals(results1[2], 30);
287
288 final String values2[] = { "100", "200", "300" };
289 value = ConvertUtils.convert(values2, shape.getClass());
290 assertEquals(shape.getClass(), value.getClass());
291 final int results2[] = (int[]) value;
292 assertEquals(results2[0], 100);
293 assertEquals(results2[1], 200);
294 assertEquals(results2[2], 300);
295
296 }
297
298
299
300
301
302 public void testPositiveIntegerArray() {
303
304 Object value = null;
305 final int intArray[] = new int[0];
306 final int intArray1[] = new int[] { 0 };
307 final int intArray2[] = new int[] { 0, 10 };
308
309 value = ConvertUtils.convert("{ }", intArray.getClass());
310 checkIntegerArray(value, intArray);
311
312 value = ConvertUtils.convert("0", intArray.getClass());
313 checkIntegerArray(value, intArray1);
314 value = ConvertUtils.convert(" 0 ", intArray.getClass());
315 checkIntegerArray(value, intArray1);
316 value = ConvertUtils.convert("{ 0 }", intArray.getClass());
317 checkIntegerArray(value, intArray1);
318
319 value = ConvertUtils.convert("0,10", intArray.getClass());
320 checkIntegerArray(value, intArray2);
321 value = ConvertUtils.convert("0 10", intArray.getClass());
322 checkIntegerArray(value, intArray2);
323 value = ConvertUtils.convert("{0,10}", intArray.getClass());
324 checkIntegerArray(value, intArray2);
325 value = ConvertUtils.convert("{0 10}", intArray.getClass());
326 checkIntegerArray(value, intArray2);
327 value = ConvertUtils.convert("{ 0, 10 }", intArray.getClass());
328 checkIntegerArray(value, intArray2);
329 value = ConvertUtils.convert("{ 0 10 }", intArray.getClass());
330 checkIntegerArray(value, intArray2);
331
332 }
333
334
335
336
337
338 public void testPositiveScalar() {
339
340 Object value = null;
341
342 value = ConvertUtils.convert("true", Boolean.TYPE);
343 assertTrue(value instanceof Boolean);
344 assertEquals(((Boolean) value).booleanValue(), true);
345
346 value = ConvertUtils.convert("true", Boolean.class);
347 assertTrue(value instanceof Boolean);
348 assertEquals(((Boolean) value).booleanValue(), true);
349
350 value = ConvertUtils.convert("yes", Boolean.TYPE);
351 assertTrue(value instanceof Boolean);
352 assertEquals(((Boolean) value).booleanValue(), true);
353
354 value = ConvertUtils.convert("yes", Boolean.class);
355 assertTrue(value instanceof Boolean);
356 assertEquals(((Boolean) value).booleanValue(), true);
357
358 value = ConvertUtils.convert("y", Boolean.TYPE);
359 assertTrue(value instanceof Boolean);
360 assertEquals(((Boolean) value).booleanValue(), true);
361
362 value = ConvertUtils.convert("y", Boolean.class);
363 assertTrue(value instanceof Boolean);
364 assertEquals(((Boolean) value).booleanValue(), true);
365
366 value = ConvertUtils.convert("on", Boolean.TYPE);
367 assertTrue(value instanceof Boolean);
368 assertEquals(((Boolean) value).booleanValue(), true);
369
370 value = ConvertUtils.convert("on", Boolean.class);
371 assertTrue(value instanceof Boolean);
372 assertEquals(((Boolean) value).booleanValue(), true);
373
374 value = ConvertUtils.convert("false", Boolean.TYPE);
375 assertTrue(value instanceof Boolean);
376 assertEquals(((Boolean) value).booleanValue(), false);
377
378 value = ConvertUtils.convert("false", Boolean.class);
379 assertTrue(value instanceof Boolean);
380 assertEquals(((Boolean) value).booleanValue(), false);
381
382 value = ConvertUtils.convert("no", Boolean.TYPE);
383 assertTrue(value instanceof Boolean);
384 assertEquals(((Boolean) value).booleanValue(), false);
385
386 value = ConvertUtils.convert("no", Boolean.class);
387 assertTrue(value instanceof Boolean);
388 assertEquals(((Boolean) value).booleanValue(), false);
389
390 value = ConvertUtils.convert("n", Boolean.TYPE);
391 assertTrue(value instanceof Boolean);
392 assertEquals(((Boolean) value).booleanValue(), false);
393
394 value = ConvertUtils.convert("n", Boolean.class);
395 assertTrue(value instanceof Boolean);
396 assertEquals(((Boolean) value).booleanValue(), false);
397
398 value = ConvertUtils.convert("off", Boolean.TYPE);
399 assertTrue(value instanceof Boolean);
400 assertEquals(((Boolean) value).booleanValue(), false);
401
402 value = ConvertUtils.convert("off", Boolean.class);
403 assertTrue(value instanceof Boolean);
404 assertEquals(((Boolean) value).booleanValue(), false);
405
406 value = ConvertUtils.convert("123", Byte.TYPE);
407 assertTrue(value instanceof Byte);
408 assertEquals(((Byte) value).byteValue(), (byte) 123);
409
410 value = ConvertUtils.convert("123", Byte.class);
411 assertTrue(value instanceof Byte);
412 assertEquals(((Byte) value).byteValue(), (byte) 123);
413
414 value = ConvertUtils.convert("a", Character.TYPE);
415 assertTrue(value instanceof Character);
416 assertEquals(((Character) value).charValue(), 'a');
417
418 value = ConvertUtils.convert("a", Character.class);
419 assertTrue(value instanceof Character);
420 assertEquals(((Character) value).charValue(), 'a');
421
422 value = ConvertUtils.convert("java.lang.String", Class.class);
423 assertTrue(value instanceof Class);
424 assertEquals(String.class, value);
425
426 value = ConvertUtils.convert("123.456", Double.TYPE);
427 assertTrue(value instanceof Double);
428 assertEquals(((Double) value).doubleValue(), 123.456, 0.005);
429
430 value = ConvertUtils.convert("123.456", Double.class);
431 assertTrue(value instanceof Double);
432 assertEquals(((Double) value).doubleValue(), 123.456, 0.005);
433
434 value = ConvertUtils.convert("123.456", Float.TYPE);
435 assertTrue(value instanceof Float);
436 assertEquals(((Float) value).floatValue(), (float) 123.456,
437 (float) 0.005);
438
439 value = ConvertUtils.convert("123.456", Float.class);
440 assertTrue(value instanceof Float);
441 assertEquals(((Float) value).floatValue(), (float) 123.456,
442 (float) 0.005);
443
444 value = ConvertUtils.convert("123", Integer.TYPE);
445 assertTrue(value instanceof Integer);
446 assertEquals(((Integer) value).intValue(), 123);
447
448 value = ConvertUtils.convert("123", Integer.class);
449 assertTrue(value instanceof Integer);
450 assertEquals(((Integer) value).intValue(), 123);
451
452 value = ConvertUtils.convert("123", Long.TYPE);
453 assertTrue(value instanceof Long);
454 assertEquals(((Long) value).longValue(), 123);
455
456 value = ConvertUtils.convert("123", Long.class);
457 assertTrue(value instanceof Long);
458 assertEquals(((Long) value).longValue(), 123);
459
460 value = ConvertUtils.convert("123", Short.TYPE);
461 assertTrue(value instanceof Short);
462 assertEquals(((Short) value).shortValue(), (short) 123);
463
464 value = ConvertUtils.convert("123", Short.class);
465 assertTrue(value instanceof Short);
466 assertEquals(((Short) value).shortValue(), (short) 123);
467
468 String input = null;
469
470 input = "2002-03-17";
471 value = ConvertUtils.convert(input, Date.class);
472 assertTrue(value instanceof Date);
473 assertEquals(input, value.toString());
474
475 input = "20:30:40";
476 value = ConvertUtils.convert(input, Time.class);
477 assertTrue(value instanceof Time);
478 assertEquals(input, value.toString());
479
480 input = "2002-03-17 20:30:40.0";
481 value = ConvertUtils.convert(input, Timestamp.class);
482 assertTrue(value instanceof Timestamp);
483 assertEquals(input, value.toString());
484
485 }
486
487
488
489
490
491 public void testPositiveStringArray() {
492
493 Object value = null;
494 final String stringArray[] = new String[0];
495 final String stringArray1[] = new String[]
496 { "abc" };
497 final String stringArray2[] = new String[]
498 { "abc", "de,f" };
499
500 value = ConvertUtils.convert("", stringArray.getClass());
501 checkStringArray(value, stringArray);
502 value = ConvertUtils.convert(" ", stringArray.getClass());
503 checkStringArray(value, stringArray);
504 value = ConvertUtils.convert("{}", stringArray.getClass());
505 checkStringArray(value, stringArray);
506 value = ConvertUtils.convert("{ }", stringArray.getClass());
507 checkStringArray(value, stringArray);
508
509 value = ConvertUtils.convert("abc", stringArray.getClass());
510 checkStringArray(value, stringArray1);
511 value = ConvertUtils.convert("{abc}", stringArray.getClass());
512 checkStringArray(value, stringArray1);
513 value = ConvertUtils.convert("\"abc\"", stringArray.getClass());
514 checkStringArray(value, stringArray1);
515 value = ConvertUtils.convert("{\"abc\"}", stringArray.getClass());
516 checkStringArray(value, stringArray1);
517 value = ConvertUtils.convert("'abc'", stringArray.getClass());
518 checkStringArray(value, stringArray1);
519 value = ConvertUtils.convert("{'abc'}", stringArray.getClass());
520 checkStringArray(value, stringArray1);
521
522 value = ConvertUtils.convert("abc 'de,f'",
523 stringArray.getClass());
524 checkStringArray(value, stringArray2);
525 value = ConvertUtils.convert("{abc, 'de,f'}",
526 stringArray.getClass());
527 checkStringArray(value, stringArray2);
528 value = ConvertUtils.convert("\"abc\",\"de,f\"",
529 stringArray.getClass());
530 checkStringArray(value, stringArray2);
531 value = ConvertUtils.convert("{\"abc\" 'de,f'}",
532 stringArray.getClass());
533 checkStringArray(value, stringArray2);
534 value = ConvertUtils.convert("'abc' 'de,f'",
535 stringArray.getClass());
536 checkStringArray(value, stringArray2);
537 value = ConvertUtils.convert("{'abc', \"de,f\"}",
538 stringArray.getClass());
539 checkStringArray(value, stringArray2);
540
541
542 }
543
544 public void testSeparateConvertInstances() throws Exception {
545 final ConvertUtilsBean utilsOne = new ConvertUtilsBean();
546 final ConvertUtilsBean utilsTwo = new ConvertUtilsBean();
547
548
549 Object
550 value = utilsOne.convert("true", Boolean.TYPE);
551 assertTrue(value instanceof Boolean);
552 assertEquals(
553 "Standard conversion failed (1)",
554 ((Boolean) value).booleanValue(),
555 true);
556
557 value = utilsTwo.convert("true", Boolean.TYPE);
558 assertTrue(value instanceof Boolean);
559 assertEquals(
560 "Standard conversion failed (2)",
561 ((Boolean) value).booleanValue(),
562 true);
563
564
565
566 utilsOne.register(new ThrowExceptionConverter(), Boolean.TYPE);
567 try {
568
569 utilsOne.convert("true", Boolean.TYPE);
570 fail("Register converter failed.");
571
572 } catch (final PassTestException e) { }
573
574 try {
575
576 value = utilsTwo.convert("true", Boolean.TYPE);
577 assertTrue(value instanceof Boolean);
578 assertEquals(
579 "Standard conversion failed (3)",
580 ((Boolean) value).booleanValue(),
581 true);
582
583 } catch (final PassTestException e) {
584
585
586 fail("Registering a converter for an instance should not effect another instance.");
587 }
588
589
590 utilsOne.deregister();
591 value = utilsOne.convert("true", Boolean.TYPE);
592 assertTrue(value instanceof Boolean);
593 assertEquals("Instance deregister failed.", ((Boolean) value).booleanValue(), true);
594
595 value = utilsTwo.convert("true", Boolean.TYPE);
596 assertTrue(value instanceof Boolean);
597 assertEquals(
598 "Standard conversion failed (4)",
599 ((Boolean) value).booleanValue(),
600 true);
601 }
602
603 public void testDeregisteringSingleConverter() throws Exception {
604
605 final Object
606 value = ConvertUtils.convert("true", Boolean.TYPE);
607 assertTrue(value instanceof Boolean);
608 assertEquals(
609 "Standard conversion failed (1)",
610 ((Boolean) value).booleanValue(),
611 true);
612
613
614 ConvertUtils.deregister(Boolean.TYPE);
615 assertNull("Converter should be null",ConvertUtils.lookup(Boolean.TYPE));
616
617 }
618
619 @SuppressWarnings({ "unchecked", "rawtypes" })
620
621 public void testConvertToString() throws Exception {
622 final Converter dummyConverter = new Converter() {
623 public Object convert(final Class type, final Object value) {
624 return value;
625 }
626 };
627
628 final Converter fooConverter = new Converter() {
629 public Object convert(final Class type, final Object value) {
630 return "Foo-Converter";
631 }
632 };
633
634 final DateConverter dateConverter = new DateConverter();
635 dateConverter.setLocale(Locale.US);
636
637 final ConvertUtilsBean utils = new ConvertUtilsBean();
638 utils.register(dateConverter, java.util.Date.class);
639 utils.register(fooConverter, String.class);
640
641
642 final java.util.Date today = new java.util.Date();
643 final DateFormat fmt = new SimpleDateFormat("M/d/yy");
644 final String expected = fmt.format(today);
645 assertEquals("DateConverter M/d/yy", expected, utils.convert(today, String.class));
646
647
648 utils.register(dummyConverter, java.util.Date.class);
649 assertEquals("Date Converter doesn't do String conversion", "Foo-Converter", utils.convert(today, String.class));
650
651
652 utils.deregister(java.util.Date.class);
653 assertEquals("No registered Date converter", "Foo-Converter", utils.convert(today, String.class));
654
655
656 utils.register(dummyConverter, String.class);
657 assertEquals("String Converter doesn't do Strings!!!", today.toString(), utils.convert(today, String.class));
658
659
660 utils.deregister(String.class);
661 assertEquals("Object's toString()", today.toString(), utils.convert(today, String.class));
662
663 }
664
665
666
667
668 public void testConvertUnsupportedTargetType() {
669 final ConvertUtilsBean utils = new ConvertUtilsBean();
670 final Object value = "A test value";
671 assertSame("Got different object", value,
672 utils.convert(value, getClass()));
673 }
674
675
676
677
678 private void checkIntegerArray(final Object value, final int intArray[]) {
679
680 assertNotNull("Returned value is not null", value);
681 assertEquals("Returned value is int[]",
682 intArray.getClass(), value.getClass());
683 final int results[] = (int[]) value;
684 assertEquals("Returned array length", intArray.length, results.length);
685 for (int i = 0; i < intArray.length; i++) {
686 assertEquals("Returned array value " + i,
687 intArray[i], results[i]);
688 }
689
690 }
691
692
693 private void checkStringArray(final Object value, final String stringArray[]) {
694
695 assertNotNull("Returned value is not null", value);
696 assertEquals("Returned value is String[]",
697 stringArray.getClass(), value.getClass());
698 final String results[] = (String[]) value;
699 assertEquals("Returned array length",
700 stringArray.length, results.length);
701 for (int i = 0; i < stringArray.length; i++) {
702 assertEquals("Returned array value " + i,
703 stringArray[i], results[i]);
704 }
705
706 }
707
708
709 }
710