1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 package org.apache.commons.beanutils.converters;
19
20 import java.text.DateFormat;
21 import java.text.SimpleDateFormat;
22 import java.util.Calendar;
23 import java.util.Date;
24 import java.util.GregorianCalendar;
25 import java.util.Locale;
26
27 import junit.framework.TestCase;
28
29 import org.apache.commons.beanutils.ConversionException;
30 import org.apache.commons.beanutils.Converter;
31
32
33
34
35
36
37
38 public abstract class DateConverterTestBase extends TestCase {
39
40
41
42
43
44
45
46 public DateConverterTestBase(final String name) {
47 super(name);
48 }
49
50
51
52
53
54
55
56 protected abstract DateTimeConverter makeConverter();
57
58
59
60
61
62
63 protected abstract DateTimeConverter makeConverter(Object defaultValue);
64
65
66
67
68
69 protected abstract Class<?> getExpectedType();
70
71
72
73
74
75
76
77 protected abstract Object toType(Calendar value);
78
79
80
81
82
83
84 public void testConvertNull() {
85 try {
86 makeConverter().convert(getExpectedType(), null);
87 fail("Expected ConversionException");
88 } catch(final ConversionException e) {
89
90 }
91 }
92
93
94
95
96
97 public void testConvertDate() {
98 final String[] message= {
99 "from Date",
100 "from Calendar",
101 "from SQL Date",
102 "from SQL Time",
103 "from SQL Timestamp"
104 };
105
106 final long now = System.currentTimeMillis();
107
108 final Object[] date = {
109 new Date(now),
110 new java.util.GregorianCalendar(),
111 new java.sql.Date(now),
112 new java.sql.Time(now),
113 new java.sql.Timestamp(now)
114 };
115
116
117 ((GregorianCalendar)date[1]).setTime(new Date(now));
118
119 for (int i = 0; i < date.length; i++) {
120 final Object val = makeConverter().convert(getExpectedType(), date[i]);
121 assertNotNull("Convert " + message[i] + " should not be null", val);
122 assertTrue("Convert " + message[i] + " should return a " + getExpectedType().getName(),
123 getExpectedType().isInstance(val));
124 assertEquals("Convert " + message[i] + " should return a " + date[0],
125 now, getTimeInMillis(val));
126 }
127 }
128
129
130
131
132 public void testDefaultType() {
133 final String pattern = "yyyy-MM-dd";
134
135
136 final DateTimeConverter converter = makeConverter();
137 converter.setPattern(pattern);
138
139
140 final String testString = "2006-10-29";
141 final Calendar calendar = toCalendar(testString, pattern, null);
142 final Object expected = toType(calendar);
143
144 final Object result = converter.convert(null, testString);
145 if (getExpectedType().equals(Calendar.class)) {
146 assertTrue("TYPE ", getExpectedType().isAssignableFrom(result.getClass()));
147 } else {
148 assertEquals("TYPE ", getExpectedType(), result.getClass());
149 }
150 assertEquals("VALUE ", expected, result);
151 }
152
153
154
155
156
157
158
159 public void testDefaultStringToTypeConvert() {
160
161
162 final DateTimeConverter converter = makeConverter();
163 converter.setUseLocaleFormat(false);
164 try {
165 converter.convert(getExpectedType(), "2006-10-23");
166 fail("Expected Conversion exception");
167 } catch (final ConversionException e) {
168
169 }
170
171 }
172
173
174
175
176 public void testStringConversion() {
177
178 final String pattern = "yyyy-MM-dd";
179
180
181 final DateTimeConverter converter = makeConverter();
182 converter.setPattern(pattern);
183
184
185 final String expected = "2006-10-29";
186 final Calendar calendar = toCalendar(expected, pattern, null);
187
188
189 stringConversion(converter, expected, toType(calendar));
190
191
192 stringConversion(converter, expected, calendar);
193
194
195 stringConversion(converter, expected, toDate(calendar));
196
197
198 stringConversion(converter, expected, toSqlDate(calendar));
199
200
201 stringConversion(converter, expected, toSqlTimestamp(calendar));
202
203
204 stringConversion(converter, expected, toSqlTime(calendar));
205
206 stringConversion(converter, null, null);
207 stringConversion(converter, "", "");
208
209 }
210
211
212
213
214 public void testPatternNoDefault() {
215
216 final String pattern = "yyyy-MM-dd";
217
218
219 final DateTimeConverter converter = makeConverter();
220 converter.setPattern(pattern);
221
222
223 final String testString = "2006-10-29";
224 final Calendar calendar = toCalendar(testString, pattern, null);
225 final Object expected = toType(calendar);
226 validConversion(converter, expected, testString);
227
228
229 validConversion(converter, expected, calendar);
230
231
232 validConversion(converter, expected, toDate(calendar));
233
234
235 validConversion(converter, expected, toSqlDate(calendar));
236
237
238 validConversion(converter, expected, toSqlTimestamp(calendar));
239
240
241 validConversion(converter, expected, toSqlTime(calendar));
242
243
244 invalidConversion(converter, null);
245 invalidConversion(converter, "");
246 invalidConversion(converter, "2006-10-2X");
247 invalidConversion(converter, "2006/10/01");
248 invalidConversion(converter, "02/10/2006");
249 invalidConversion(converter, "02/10/06");
250 invalidConversion(converter, new Integer(2));
251
252 }
253
254
255
256
257 public void testPatternDefault() {
258
259 final String pattern = "yyyy-MM-dd";
260
261
262 final Object defaultValue = toType("2000-01-01", pattern, null);
263 assertNotNull("Check default date", defaultValue);
264 final DateTimeConverter converter = makeConverter(defaultValue);
265 converter.setPattern(pattern);
266
267
268 final String testString = "2006-10-29";
269 final Object expected = toType(testString, pattern, null);
270 validConversion(converter, expected, testString);
271
272
273 validConversion(converter, defaultValue, null);
274 validConversion(converter, defaultValue, "");
275 validConversion(converter, defaultValue, "2006-10-2X");
276 validConversion(converter, defaultValue, "2006/10/01");
277 validConversion(converter, defaultValue, "02/10/06");
278 validConversion(converter, defaultValue, new Integer(2));
279
280 }
281
282
283
284
285 public void testPatternNullDefault() {
286
287 final String pattern = "yyyy-MM-dd";
288
289
290 final Object defaultValue = null;
291 final DateTimeConverter converter = makeConverter(defaultValue);
292 converter.setPattern(pattern);
293
294
295 final String testString = "2006-10-29";
296 final Object expected = toType(testString, pattern, null);
297 validConversion(converter, expected, testString);
298
299
300 validConversion(converter, defaultValue, null);
301 validConversion(converter, defaultValue, "");
302 validConversion(converter, defaultValue, "2006-10-2X");
303 validConversion(converter, defaultValue, "2006/10/01");
304 validConversion(converter, defaultValue, "02/10/06");
305 validConversion(converter, defaultValue, new Integer(2));
306
307 }
308
309
310
311
312 public void testMultiplePatterns() {
313 String testString = null;
314 Object expected = null;
315
316
317 final String[] patterns = new String[] {"yyyy-MM-dd", "yyyy/MM/dd"};
318 final DateTimeConverter converter = makeConverter();
319 converter.setPatterns(patterns);
320
321
322 testString = "2006-10-28";
323 expected = toType(testString, patterns[0], null);
324 validConversion(converter, expected, testString);
325
326
327 testString = "2006/10/18";
328 expected = toType(testString, patterns[1], null);
329 validConversion(converter, expected, testString);
330
331
332 invalidConversion(converter, "17/03/2006");
333 invalidConversion(converter, "17.03.2006");
334
335 }
336
337
338
339
340 public void testLocale() {
341
342
343 final Locale defaultLocale = Locale.getDefault();
344 Locale.setDefault(Locale.US);
345
346 final String pattern = "M/d/yy";
347
348
349 final DateTimeConverter converter = makeConverter();
350 converter.setUseLocaleFormat(true);
351
352
353 final String testString = "10/28/06";
354 final Object expected = toType(testString, pattern, null);
355 validConversion(converter, expected, testString);
356
357
358 invalidConversion(converter, null);
359 invalidConversion(converter, "");
360 invalidConversion(converter, "2006-10-2X");
361 invalidConversion(converter, "10.28.06");
362 invalidConversion(converter, "10-28-06");
363 invalidConversion(converter, new Integer(2));
364
365
366 Locale.setDefault(defaultLocale);
367
368 }
369
370
371
372
373 public void testInvalidType() {
374
375
376 final DateTimeConverter converter = makeConverter();
377
378
379 try {
380 converter.convert(Character.class, new Date());
381 fail("Requested Character.class conversion, expected ConversionException");
382 } catch (final ConversionException e) {
383
384 }
385 }
386
387
388
389
390
391
392
393 void validConversion(final Converter converter, final Object expected, final Object value) {
394 final String valueType = (value == null ? "null" : value.getClass().getName());
395 final String msg = "Converting '" + valueType + "' value '" + value + "'";
396 try {
397 final Object result = converter.convert(getExpectedType(), value);
398 final Class<?> resultType = (result == null ? null : result.getClass());
399 final Class<?> expectType = (expected == null ? null : expected.getClass());
400 assertEquals("TYPE " + msg, expectType, resultType);
401 assertEquals("VALUE " + msg, expected, result);
402 } catch (final Exception ex) {
403 fail(msg + " threw " + ex.toString());
404 }
405 }
406
407
408
409
410
411
412
413 void stringConversion(final Converter converter, final String expected, final Object value) {
414 final String valueType = (value == null ? "null" : value.getClass().getName());
415 final String msg = "Converting '" + valueType + "' value '" + value + "' to String";
416 try {
417 final Object result = converter.convert(String.class, value);
418 final Class<?> resultType = (result == null ? null : result.getClass());
419 final Class<?> expectType = (expected == null ? null : expected.getClass());
420 assertEquals("TYPE " + msg, expectType, resultType);
421 assertEquals("VALUE " + msg, expected, result);
422 } catch (final Exception ex) {
423 fail(msg + " threw " + ex.toString());
424 }
425 }
426
427
428
429
430
431
432 void invalidConversion(final Converter converter, final Object value) {
433 final String valueType = (value == null ? "null" : value.getClass().getName());
434 final String msg = "Converting '" + valueType + "' value '" + value + "'";
435 try {
436 final Object result = converter.convert(getExpectedType(), value);
437 fail(msg + ", expected ConversionException, but result = '" + result + "'");
438 } catch (final ConversionException ex) {
439
440 }
441 }
442
443
444
445
446
447
448
449
450 Object toType(final String value, final String pattern, final Locale locale) {
451 final Calendar calendar = toCalendar(value, pattern, locale);
452 return toType(calendar);
453 }
454
455
456
457
458
459
460
461
462 Calendar toCalendar(final String value, final String pattern, final Locale locale) {
463 Calendar calendar = null;
464 try {
465 final DateFormat format = (locale == null)
466 ? new SimpleDateFormat(pattern)
467 : new SimpleDateFormat(pattern, locale);
468 format.setLenient(false);
469 format.parse(value);
470 calendar = format.getCalendar();
471 } catch (final Exception e) {
472 fail("Error creating Calendar value ='"
473 + value + ", pattern='" + pattern + "' " + e.toString());
474 }
475 return calendar;
476 }
477
478
479
480
481
482
483 Date toDate(final Calendar calendar) {
484 return calendar.getTime();
485 }
486
487
488
489
490
491
492 java.sql.Date toSqlDate(final Calendar calendar) {
493 return new java.sql.Date(getTimeInMillis(calendar));
494 }
495
496
497
498
499
500
501 java.sql.Time toSqlTime(final Calendar calendar) {
502 return new java.sql.Time(getTimeInMillis(calendar));
503 }
504
505
506
507
508
509
510 java.sql.Timestamp toSqlTimestamp(final Calendar calendar) {
511 return new java.sql.Timestamp(getTimeInMillis(calendar));
512 }
513
514
515
516
517
518
519 long getTimeInMillis(final Object date) {
520
521 if (date instanceof java.sql.Timestamp) {
522
523
524
525
526 final java.sql.Timestamp timestamp = (java.sql.Timestamp)date;
527 long timeInMillis = ((timestamp.getTime() / 1000) * 1000);
528 timeInMillis += timestamp.getNanos() / 1000000;
529 return timeInMillis;
530 }
531
532 if (date instanceof Calendar) {
533 return ((Calendar)date).getTime().getTime();
534 } else {
535 return ((Date)date).getTime();
536 }
537 }
538 }