KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > jibx > runtime > UtilityTest


1 /*
2  * Created on Mar 6, 2003
3  *
4  * To change this generated comment go to
5  * Window>Preferences>Java>Code Generation>Code Template
6  */

7
8 package org.jibx.runtime;
9
10 import java.text.DateFormat JavaDoc;
11 import java.text.ParseException JavaDoc;
12 import java.text.SimpleDateFormat JavaDoc;
13 import java.util.Calendar JavaDoc;
14 import java.util.Date JavaDoc;
15 import java.util.GregorianCalendar JavaDoc;
16 import java.util.TimeZone JavaDoc;
17
18 import junit.framework.TestCase;
19
20 /**
21  * @author dennis
22  */

23  
24 public class UtilityTest extends TestCase {
25     
26     private static long LMS_PER_DAY = (long)24*60*60*1000;
27     private DateFormat JavaDoc m_dateTimeFormat =
28         new SimpleDateFormat JavaDoc("yyyy-MM-dd'T'hh:mm:ss");
29     private DateFormat JavaDoc m_dateFormat =
30         new SimpleDateFormat JavaDoc("yyyy-MM-dd");
31     private DateFormat JavaDoc m_yearFormat =
32         new SimpleDateFormat JavaDoc("yyyy");
33     private Calendar JavaDoc m_calendar =
34         new GregorianCalendar JavaDoc(TimeZone.getTimeZone("UTC"));
35
36     /**
37      * Constructor for UtilityTest.
38      * @param arg0
39      */

40     public UtilityTest(String JavaDoc arg0) {
41         super(arg0);
42         m_dateTimeFormat.setCalendar(m_calendar);
43         m_dateFormat.setCalendar(m_calendar);
44         m_yearFormat.setCalendar(m_calendar);
45     }
46
47     public void testParseInt() throws JiBXException {
48         assertEquals(0, Utility.parseInt("0"));
49         assertEquals(2000000000, Utility.parseInt("2000000000"));
50         assertEquals(-2000000000, Utility.parseInt("-2000000000"));
51         assertEquals(2000000000, Utility.parseInt("+2000000000"));
52         try {
53             Utility.parseInt("-");
54             fail();
55         } catch (JiBXException ex) {}
56         try {
57             Utility.parseInt("+");
58             fail();
59         } catch (JiBXException ex) {}
60         try {
61             Utility.parseInt("20000000000");
62             fail();
63         } catch (JiBXException ex) {}
64         try {
65             Utility.parseInt("-20000000000");
66             fail();
67         } catch (JiBXException ex) {}
68         try {
69             Utility.parseInt("+20000000000");
70             fail();
71         } catch (JiBXException ex) {}
72         try {
73             Utility.parseInt("2000000X");
74             fail();
75         } catch (JiBXException ex) {}
76     }
77
78     public void testSerializeInt() throws JiBXException {
79         assertEquals("0", Utility.serializeInt(0));
80         assertEquals("2000000", Utility.serializeInt(2000000));
81         assertEquals("2000000000", Utility.serializeInt(2000000000));
82         assertEquals("-2000000", Utility.serializeInt(-2000000));
83         assertEquals("-2000000000", Utility.serializeInt(-2000000000));
84     }
85
86     public void testParseLong() throws JiBXException {
87         assertEquals(0, Utility.parseLong("0"));
88         assertEquals(2000000000, Utility.parseLong("2000000000"));
89         assertEquals(-2000000000, Utility.parseLong("-2000000000"));
90         assertEquals(2000000000, Utility.parseLong("+2000000000"));
91         assertEquals(200000000000000L, Utility.parseLong("200000000000000"));
92         assertEquals(-200000000000000L, Utility.parseLong("-200000000000000"));
93         assertEquals(200000000000000L, Utility.parseLong("+200000000000000"));
94         try {
95             Utility.parseLong("-");
96             fail();
97         } catch (JiBXException ex) {}
98         try {
99             Utility.parseLong("+");
100             fail();
101         } catch (JiBXException ex) {}
102         try {
103             Utility.parseLong("2000000X");
104             fail();
105         } catch (JiBXException ex) {}
106     }
107
108     public void testSerializeLong() {
109         assertEquals("0", Utility.serializeLong(0));
110         assertEquals("2000000", Utility.serializeLong(2000000));
111         assertEquals("2000000000000000",
112             Utility.serializeLong(2000000000000000L));
113         assertEquals("-2000000", Utility.serializeLong(-2000000));
114         assertEquals("-2000000000000000",
115             Utility.serializeLong(-2000000000000000L));
116     }
117     
118     public void testParseShort() throws JiBXException {
119         assertEquals(0, Utility.parseShort("0"));
120         assertEquals(20000, Utility.parseShort("20000"));
121         assertEquals(-20000, Utility.parseShort("-20000"));
122         assertEquals(20000, Utility.parseShort("+20000"));
123         try {
124             Utility.parseShort("-");
125             fail();
126         } catch (JiBXException ex) {}
127         try {
128             Utility.parseShort("+");
129             fail();
130         } catch (JiBXException ex) {}
131         try {
132             Utility.parseShort("2000000");
133             fail();
134         } catch (JiBXException ex) {}
135         try {
136             Utility.parseShort("2000X");
137             fail();
138         } catch (JiBXException ex) {}
139     }
140
141     public void testSerializeShort() {
142         assertEquals("0", Utility.serializeShort((short)0));
143         assertEquals("20000", Utility.serializeShort((short)20000));
144         assertEquals("-20000", Utility.serializeShort((short)-20000));
145     }
146     
147     public void testParseByte() throws JiBXException {
148         assertEquals(0, Utility.parseByte("0"));
149         assertEquals(100, Utility.parseByte("100"));
150         assertEquals(-100, Utility.parseByte("-100"));
151         assertEquals(100, Utility.parseByte("+100"));
152         try {
153             Utility.parseByte("-");
154             fail();
155         } catch (JiBXException ex) {}
156         try {
157             Utility.parseByte("+");
158             fail();
159         } catch (JiBXException ex) {}
160         try {
161             Utility.parseByte("128");
162             fail();
163         } catch (JiBXException ex) {}
164         try {
165             Utility.parseByte("10X");
166             fail();
167         } catch (JiBXException ex) {}
168     }
169
170     public void testSerializeByte() {
171         assertEquals("0", Utility.serializeByte((byte)0));
172         assertEquals("100", Utility.serializeByte((byte)100));
173         assertEquals("-100", Utility.serializeByte((byte)-100));
174     }
175
176     public void testParseBoolean() throws JiBXException {
177         assertTrue(Utility.parseBoolean("true"));
178         assertTrue(Utility.parseBoolean("1"));
179         assertFalse(Utility.parseBoolean("false"));
180         assertFalse(Utility.parseBoolean("0"));
181         try {
182             Utility.parseBoolean("x");
183             fail();
184         } catch (JiBXException ex) {}
185         try {
186             Utility.parseBoolean("2");
187             fail();
188         } catch (JiBXException ex) {}
189         try {
190             Utility.parseBoolean("+1");
191             fail();
192         } catch (JiBXException ex) {}
193     }
194
195     public void testSerializeBoolean() {
196         assertEquals("true", Utility.serializeBoolean(true));
197         assertEquals("false", Utility.serializeBoolean(false));
198     }
199
200     public void testParseChar() throws JiBXException {
201         assertEquals(0, Utility.parseChar("0"));
202         assertEquals(100, Utility.parseChar("100"));
203         assertEquals(1000, Utility.parseChar("+1000"));
204         assertEquals(65000, Utility.parseChar("65000"));
205         try {
206             Utility.parseChar("-");
207             fail();
208         } catch (JiBXException ex) {}
209         try {
210             Utility.parseChar("+");
211             fail();
212         } catch (JiBXException ex) {}
213         try {
214             Utility.parseChar("-10");
215             fail();
216         } catch (JiBXException ex) {}
217         try {
218             Utility.parseChar("69000");
219             fail();
220         } catch (JiBXException ex) {}
221     }
222
223     public void testSerializeChar() {
224         assertEquals("0", Utility.serializeChar((char)0));
225         assertEquals("100", Utility.serializeChar((char)100));
226         assertEquals("60000", Utility.serializeChar((char)60000));
227     }
228
229     public void testParseFloat() throws JiBXException {
230         assertEquals(1.0f, Utility.parseFloat("1.0"), 0.000001f);
231         assertEquals(1000000000.0f, Utility.parseFloat("1000000000.0"), 100.0f);
232         assertEquals(0.0000000001f,
233             Utility.parseFloat("0.0000000001"), 1.0e-17f);
234         assertEquals(0, Float.compare(-0.0f, Utility.parseFloat("-0")));
235         assertEquals(0, Float.compare(Float.NEGATIVE_INFINITY,
236             Utility.parseFloat("-INF")));
237         assertEquals(0, Float.compare(Float.POSITIVE_INFINITY,
238             Utility.parseFloat("INF")));
239         assertEquals(0, Float.compare(Float.NaN, Utility.parseFloat("NaN")));
240         try {
241             Utility.parseFloat("NAN");
242             fail();
243         } catch (JiBXException ex) {}
244         try {
245             Utility.parseFloat("+INF");
246             fail();
247         } catch (JiBXException ex) {}
248         try {
249             Utility.parseFloat("1E+2.5");
250             fail();
251         } catch (JiBXException ex) {}
252     }
253
254     public void testSerializeFloat() {
255         assertEquals("1.0", Utility.serializeFloat(1.0f));
256         assertEquals("1.0E9", Utility.serializeFloat(1000000000.0f));
257         assertEquals("1.0E-10", Utility.serializeFloat(0.0000000001f));
258         assertEquals("-INF", Utility.serializeFloat(Float.NEGATIVE_INFINITY));
259         assertEquals("INF", Utility.serializeFloat(Float.POSITIVE_INFINITY));
260         assertEquals("NaN", Utility.serializeFloat(Float.NaN));
261     }
262
263     public void testParseDouble() throws JiBXException {
264         assertEquals(1.0d, Utility.parseDouble("1.0"), 1.0e-12d);
265         assertEquals(1000000000.0d, Utility.parseDouble("1000000000.0"), 0.01d);
266         assertEquals(0.0000000001d,
267             Utility.parseDouble("0.0000000001"), 1.0e-22d);
268         assertEquals(0, Double.compare(-0.0d, Utility.parseDouble("-0")));
269         assertEquals(0, Double.compare(Double.NEGATIVE_INFINITY,
270             Utility.parseDouble("-INF")));
271         assertEquals(0, Double.compare(Double.POSITIVE_INFINITY,
272             Utility.parseDouble("INF")));
273         assertEquals(0, Double.compare(Double.NaN, Utility.parseDouble("NaN")));
274         try {
275             Utility.parseDouble("NAN");
276             fail();
277         } catch (JiBXException ex) {}
278         try {
279             Utility.parseDouble("+INF");
280             fail();
281         } catch (JiBXException ex) {}
282         try {
283             Utility.parseDouble("1E+2.5");
284             fail();
285         } catch (JiBXException ex) {}
286     }
287
288     public void testSerializeDouble() {
289         assertEquals("1.0", Utility.serializeDouble(1.0d));
290         assertEquals("1.0E9", Utility.serializeDouble(1000000000.0d));
291         assertEquals("1.0E-10", Utility.serializeDouble(0.0000000001d));
292         assertEquals("-INF", Utility.serializeDouble(Double.NEGATIVE_INFINITY));
293         assertEquals("INF", Utility.serializeDouble(Double.POSITIVE_INFINITY));
294         assertEquals("NaN", Utility.serializeDouble(Double.NaN));
295     }
296
297     public void testParseYear() {
298     }
299
300     public void testParseYearMonth() {
301     }
302
303     public void testParseDate() throws JiBXException {
304         assertEquals(0, Utility.parseDate("1970-01-01"));
305         assertEquals(LMS_PER_DAY, Utility.parseDate("1970-01-02"));
306         assertEquals(LMS_PER_DAY,
307             Utility.parseDate("0001-03-01") - Utility.parseDate("0001-02-28"));
308         assertEquals(LMS_PER_DAY,
309             Utility.parseDate("0001-01-01") - Utility.parseDate("-0001-12-31"));
310         assertEquals(LMS_PER_DAY,
311             Utility.parseDate("-0001-03-01") -
312             Utility.parseDate("-0001-02-28"));
313         assertEquals(LMS_PER_DAY*2,
314             Utility.parseDate("-0004-03-01") -
315             Utility.parseDate("-0004-02-28"));
316         try {
317             Utility.parseDate("+1970-01-01");
318             fail();
319         } catch (JiBXException ex) {}
320         try {
321             Utility.parseDate("197X-01-01");
322             fail();
323         } catch (JiBXException ex) {}
324         try {
325             Utility.parseDate("1970-1-01");
326             fail();
327         } catch (JiBXException ex) {}
328         try {
329             Utility.parseDate("1970-01-32");
330             fail();
331         } catch (JiBXException ex) {}
332         try {
333             Utility.parseDate("1970-02-29");
334             fail();
335         } catch (JiBXException ex) {}
336         try {
337             Utility.parseDate("01-01-01");
338             fail();
339         } catch (JiBXException ex) {}
340         try {
341             Utility.parseDate("0001-02-29");
342             fail();
343         } catch (JiBXException ex) {}
344         try {
345             Utility.parseDate("0000-01-01");
346             fail();
347         } catch (JiBXException ex) {}
348         try {
349             Utility.parseDate("-0001-02-29");
350             fail();
351         } catch (JiBXException ex) {}
352         try {
353             Utility.parseDate("-0003-02-29");
354             fail();
355         } catch (JiBXException ex) {}
356     }
357
358     public void testParseDateTime() throws JiBXException {
359         assertEquals(0, Utility.parseDateTime("1970-01-01T00:00:00.000"));
360         assertEquals(0, Utility.parseDateTime("1970-01-01T00:00:00"));
361         assertEquals(1, Utility.parseDateTime("1970-01-01T00:00:00.001"));
362         assertEquals(1000, Utility.parseDateTime("1970-01-01T00:00:01"));
363         assertEquals(60*1000, Utility.parseDateTime("1970-01-01T00:01:00"));
364         assertEquals(60*60*1000, Utility.parseDateTime("1970-01-01T01:00:00Z"));
365         assertEquals(60*60*1000,
366             Utility.parseDateTime("1970-01-01T02:00:00+01:00"));
367         assertEquals(LMS_PER_DAY,
368             Utility.parseDateTime("1970-01-02T00:00:00Z"));
369         assertEquals(LMS_PER_DAY,
370             Utility.parseDateTime("0001-03-01T00:00:00Z") -
371             Utility.parseDateTime("0001-02-28T00:00:00Z"));
372         assertEquals(1000, Utility.parseDateTime("0001-01-01T00:00:00Z") -
373             Utility.parseDateTime("-0001-12-31T23:59:59Z"));
374         assertEquals(LMS_PER_DAY,
375             Utility.parseDateTime("0001-01-01T00:00:00Z") -
376             Utility.parseDateTime("-0001-12-31T00:00:00Z"));
377         assertEquals(LMS_PER_DAY,
378             Utility.parseDateTime("-0001-03-01T00:00:00Z") -
379             Utility.parseDateTime("-0001-02-28T00:00:00Z"));
380         assertEquals(LMS_PER_DAY*2,
381             Utility.parseDateTime("-0004-03-01T00:00:00Z") -
382             Utility.parseDateTime("-0004-02-28T00:00:00Z"));
383         try {
384             Utility.parseDateTime("+1970-01-01T00:00:00.000");
385             fail();
386         } catch (JiBXException ex) {}
387         try {
388             Utility.parseDateTime("197X-01-01T00:00:00.000");
389             fail();
390         } catch (JiBXException ex) {}
391         try {
392             Utility.parseDateTime("1970-1-01T00:00:00.000");
393             fail();
394         } catch (JiBXException ex) {}
395         try {
396             Utility.parseDateTime("1970-01-01T00:00");
397             fail();
398         } catch (JiBXException ex) {}
399         try {
400             Utility.parseDateTime("1970-01-32T00:00:00");
401             fail();
402         } catch (JiBXException ex) {}
403         try {
404             Utility.parseDateTime("1970-02-29T00:00:00");
405             fail();
406         } catch (JiBXException ex) {}
407         try {
408             Utility.parseDateTime("1970-01-01T60:00:00");
409             fail();
410         } catch (JiBXException ex) {}
411         try {
412             Utility.parseDateTime("1970-01-01T-5:00:00");
413             fail();
414         } catch (JiBXException ex) {}
415         try {
416             Utility.parseDateTime("01-01-01T00:00:00");
417             fail();
418         } catch (JiBXException ex) {}
419         try {
420             Utility.parseDateTime("0001-02-29T00:00:00");
421             fail();
422         } catch (JiBXException ex) {}
423         try {
424             Utility.parseDateTime("0000-01-01T00:00:00");
425             fail();
426         } catch (JiBXException ex) {}
427         try {
428             Utility.parseDateTime("-0001-02-29T00:00:00");
429             fail();
430         } catch (JiBXException ex) {}
431         try {
432             Utility.parseDateTime("-0003-02-29T00:00:00");
433             fail();
434         } catch (JiBXException ex) {}
435     }
436
437     public void testDeserializeDateTime() {
438     }
439     
440     private void trySerializeYear(String JavaDoc dt)
441         throws JiBXException, ParseException JavaDoc {
442         Date JavaDoc date = m_yearFormat.parse(dt);
443         String JavaDoc result = Utility.serializeYear(date);
444         assertEquals(dt, result);
445     }
446     
447     private void tryRoundtripYear(String JavaDoc dt) throws JiBXException {
448         long time = Utility.parseYear(dt);
449         String JavaDoc result = Utility.serializeYear(new Date JavaDoc(time));
450 // System.out.println("Parsed date " + dt + " to value " + time +
451
// ", serialized as " + result);
452
assertEquals(dt, result);
453     }
454
455     public void testSerializeYear() throws JiBXException, ParseException JavaDoc {
456         trySerializeYear("1970");
457         trySerializeYear("1969");
458         trySerializeYear("1968");
459         trySerializeYear("1967");
460         trySerializeYear("1966");
461         trySerializeYear("1965");
462         trySerializeYear("1800");
463         trySerializeYear("1600");
464         trySerializeYear("1999");
465         trySerializeYear("2000");
466         trySerializeYear("2999");
467         trySerializeYear("3000");
468         trySerializeYear("9999");
469         tryRoundtripYear("1970");
470         tryRoundtripYear("1969");
471         tryRoundtripYear("1968");
472         tryRoundtripYear("1967");
473         tryRoundtripYear("1966");
474         tryRoundtripYear("1965");
475         tryRoundtripYear("1800");
476         tryRoundtripYear("1600");
477         tryRoundtripYear("1999");
478         tryRoundtripYear("2000");
479         tryRoundtripYear("2001");
480         tryRoundtripYear("2002");
481         tryRoundtripYear("2999");
482         tryRoundtripYear("3000");
483         tryRoundtripYear("9999");
484         
485         // the following values can only be tested roundtrip (because Java
486
// conversion insists on a discontinuity in Gregorian calendar)
487
tryRoundtripYear("12999");
488         tryRoundtripYear("1300");
489         tryRoundtripYear("0300");
490         tryRoundtripYear("0001");
491         tryRoundtripYear("-0001");
492         tryRoundtripYear("-0004");
493         tryRoundtripYear("-0005");
494         tryRoundtripYear("-0199");
495         tryRoundtripYear("-0198");
496     }
497
498     public void testSerializeYearMonth() throws JiBXException {
499         assertEquals("1970-01", Utility.serializeYearMonth(new Date JavaDoc(0)));
500     }
501     
502     private void trySerializeDate(String JavaDoc dt)
503         throws JiBXException, ParseException JavaDoc {
504         Date JavaDoc date = m_dateFormat.parse(dt);
505         String JavaDoc result = Utility.serializeDate(date);
506         assertEquals(dt, result);
507     }
508     
509     private void tryRoundtripDate(String JavaDoc dt) throws JiBXException {
510         long time = Utility.parseDate(dt);
511         String JavaDoc result = Utility.serializeDate(new Date JavaDoc(time));
512 // System.out.println("Parsed date " + dt + " to value " + time +
513
// ", serialized as " + result);
514
assertEquals(dt, result);
515     }
516
517     public void testSerializeDate() throws JiBXException, ParseException JavaDoc {
518         trySerializeDate("1970-01-01");
519         trySerializeDate("1970-02-01");
520         trySerializeDate("1970-01-02");
521         trySerializeDate("1969-12-31");
522         trySerializeDate("1969-01-01");
523         trySerializeDate("1969-02-28");
524         trySerializeDate("1969-03-01");
525         trySerializeDate("1968-01-01");
526         trySerializeDate("1968-02-29");
527         trySerializeDate("1968-03-01");
528         trySerializeDate("1967-01-01");
529         trySerializeDate("1966-01-01");
530         trySerializeDate("1965-01-01");
531         trySerializeDate("1800-01-01");
532         trySerializeDate("1600-11-11");
533         trySerializeDate("1999-12-31");
534         trySerializeDate("2000-01-01");
535         trySerializeDate("2000-02-29");
536         trySerializeDate("2000-12-31");
537         trySerializeDate("2001-01-01");
538         trySerializeDate("2001-12-31");
539         trySerializeDate("2002-01-01");
540         trySerializeDate("2999-12-31");
541         trySerializeDate("3000-01-01");
542         trySerializeDate("3000-12-31");
543         trySerializeDate("9999-12-31");
544         tryRoundtripDate("1970-01-01");
545         tryRoundtripDate("1970-02-01");
546         tryRoundtripDate("1970-01-02");
547         tryRoundtripDate("1969-12-31");
548         tryRoundtripDate("1969-01-01");
549         tryRoundtripDate("1969-02-28");
550         tryRoundtripDate("1969-03-01");
551         tryRoundtripDate("1968-01-01");
552         tryRoundtripDate("1968-02-29");
553         tryRoundtripDate("1968-03-01");
554         tryRoundtripDate("1967-01-01");
555         tryRoundtripDate("1966-01-01");
556         tryRoundtripDate("1965-01-01");
557         tryRoundtripDate("1800-01-01");
558         tryRoundtripDate("1600-11-11");
559         tryRoundtripDate("1999-12-31");
560         tryRoundtripDate("2000-01-01");
561         tryRoundtripDate("2000-02-29");
562         tryRoundtripDate("2000-12-31");
563         tryRoundtripDate("2001-01-01");
564         tryRoundtripDate("2001-12-31");
565         tryRoundtripDate("2002-01-01");
566         tryRoundtripDate("2999-12-31");
567         tryRoundtripDate("3000-01-01");
568         tryRoundtripDate("3000-12-31");
569         tryRoundtripDate("9999-12-31");
570         
571         // the following values can only be tested roundtrip (because Java
572
// conversion insists on a discontinuity in Gregorian calendar)
573
tryRoundtripDate("12999-12-31");
574         tryRoundtripDate("1300-01-01");
575         tryRoundtripDate("0300-12-31");
576         tryRoundtripDate("0001-01-01");
577         tryRoundtripDate("-0001-12-31");
578         tryRoundtripDate("-0004-02-29");
579         tryRoundtripDate("-0004-03-01");
580         tryRoundtripDate("-0004-12-31");
581         tryRoundtripDate("-0005-02-28");
582         tryRoundtripDate("-0005-03-01");
583         tryRoundtripDate("-0199-12-31");
584         tryRoundtripDate("-0198-01-01");
585     }
586     
587     private void trySerializeDateTime(String JavaDoc dt)
588         throws JiBXException, ParseException JavaDoc {
589         Date JavaDoc date = m_dateTimeFormat.parse(dt);
590         String JavaDoc result = Utility.serializeDateTime(date);
591         assertEquals(dt, result);
592     }
593     
594     private void tryRoundtripDateTime(String JavaDoc dt) throws JiBXException {
595         long time = Utility.parseDateTime(dt);
596         String JavaDoc result = Utility.serializeDateTime(new Date JavaDoc(time));
597 // System.out.println("Parsed date " + dt + " to value " + time +
598
// ", serialized as " + result);
599
assertEquals(dt, result);
600     }
601
602     public void testSerializeDateTime() throws JiBXException, ParseException JavaDoc {
603         assertEquals("1970-01-01T00:00:00",
604             Utility.serializeDateTime(new Date JavaDoc(0)));
605         trySerializeDateTime("1970-01-01T00:00:00");
606         trySerializeDateTime("1970-01-01T01:00:00");
607         trySerializeDateTime("1970-01-01T00:01:00");
608         trySerializeDateTime("1970-01-01T00:00:01");
609         trySerializeDateTime("1970-01-01T23:59:59");
610         trySerializeDateTime("1970-02-01T00:00:00");
611         trySerializeDateTime("1970-01-02T00:00:00");
612         trySerializeDateTime("1969-12-31T23:59:59");
613         trySerializeDateTime("1969-01-01T00:00:00");
614         trySerializeDateTime("1969-02-28T00:00:00");
615         trySerializeDateTime("1969-03-01T00:00:00");
616         trySerializeDateTime("1968-01-01T00:00:00");
617         trySerializeDateTime("1968-02-29T00:00:00");
618         trySerializeDateTime("1968-03-01T00:00:00");
619         trySerializeDateTime("1967-01-01T00:00:00");
620         trySerializeDateTime("1966-01-01T00:00:00");
621         trySerializeDateTime("1965-01-01T00:00:00");
622         trySerializeDateTime("1800-01-01T00:00:00");
623         trySerializeDateTime("1600-11-11T23:59:59");
624         trySerializeDateTime("1999-12-31T23:59:59");
625         trySerializeDateTime("2000-01-01T00:00:00");
626         trySerializeDateTime("2000-02-29T00:00:00");
627         trySerializeDateTime("2000-12-31T23:59:59");
628         trySerializeDateTime("2001-01-01T00:00:00");
629         trySerializeDateTime("2001-02-28T18:54:31");
630         trySerializeDateTime("2001-12-31T23:59:59");
631         trySerializeDateTime("2002-01-01T00:00:00");
632         trySerializeDateTime("2999-12-31T23:59:59");
633         trySerializeDateTime("3000-01-01T00:00:00");
634         trySerializeDateTime("3000-12-31T23:59:59");
635         trySerializeDateTime("9999-12-31T23:59:59");
636         tryRoundtripDateTime("1970-01-01T00:00:00");
637         tryRoundtripDateTime("1970-01-01T01:00:00");
638         tryRoundtripDateTime("1970-01-01T00:01:00");
639         tryRoundtripDateTime("1970-01-01T00:00:01");
640         tryRoundtripDateTime("1970-01-01T23:59:59");
641         tryRoundtripDateTime("1970-02-01T00:00:00");
642         tryRoundtripDateTime("1970-01-02T00:00:00");
643         tryRoundtripDateTime("1969-12-31T23:59:59");
644         tryRoundtripDateTime("1969-01-01T00:00:00");
645         tryRoundtripDateTime("1969-02-28T00:00:00");
646         tryRoundtripDateTime("1969-03-01T00:00:00");
647         tryRoundtripDateTime("1968-01-01T00:00:00");
648         tryRoundtripDateTime("1968-02-29T00:00:00");
649         tryRoundtripDateTime("1968-03-01T00:00:00");
650         tryRoundtripDateTime("1967-01-01T00:00:00");
651         tryRoundtripDateTime("1966-01-01T00:00:00");
652         tryRoundtripDateTime("1965-01-01T00:00:00");
653         tryRoundtripDateTime("1800-01-01T00:00:00");
654         tryRoundtripDateTime("1600-11-11T23:59:59");
655         tryRoundtripDateTime("1999-12-31T23:59:59");
656         tryRoundtripDateTime("2000-01-01T00:00:00");
657         tryRoundtripDateTime("2000-02-29T00:00:00");
658         tryRoundtripDateTime("2000-12-31T23:59:59");
659         tryRoundtripDateTime("2001-01-01T00:00:00");
660         tryRoundtripDateTime("2001-02-28T18:54:31");
661         tryRoundtripDateTime("2001-12-31T23:59:59");
662         tryRoundtripDateTime("2002-01-01T00:00:00");
663         tryRoundtripDateTime("2999-12-31T23:59:59");
664         tryRoundtripDateTime("3000-01-01T00:00:00");
665         tryRoundtripDateTime("3000-12-31T23:59:59");
666         tryRoundtripDateTime("9999-12-31T23:59:59");
667         
668         // the following values can only be tested roundtrip (because Java
669
// conversion insists on a discontinuity in Gregorian calendar)
670
tryRoundtripDateTime("12999-12-31T23:59:59");
671         tryRoundtripDateTime("1300-01-01T00:00:00");
672         tryRoundtripDateTime("0300-12-31T23:59:59");
673         tryRoundtripDateTime("0001-01-01T00:00:00");
674         tryRoundtripDateTime("-0001-12-31T23:59:59");
675         tryRoundtripDateTime("-0004-02-29T23:59:59");
676         tryRoundtripDateTime("-0004-03-01T23:59:59");
677         tryRoundtripDateTime("-0199-12-31T23:59:59");
678         tryRoundtripDateTime("-0198-01-01T00:00:00");
679     }
680     
681     private boolean equalsBytes(byte[] a, byte[] b) {
682         if (a == null) {
683             return b == null;
684         } else if (b == null) {
685             return false;
686         } else if (a.length != b.length) {
687             return false;
688         } else {
689             for (int i = 0; i < a.length; i++) {
690                 if (a[i] != b[i]) {
691                     return false;
692                 }
693             }
694             return true;
695         }
696     }
697     
698     public void testParseBase64() throws JiBXException {
699         assertTrue(equalsBytes(Utility.parseBase64(""), new byte[0]));
700         assertTrue(equalsBytes(Utility.parseBase64("Cg=="), "\n".getBytes()));
701         assertTrue(equalsBytes(Utility.parseBase64("d2hhdA=="),
702             "what".getBytes()));
703         assertTrue(equalsBytes(Utility.parseBase64
704             ("d2hhdCB3aWxsIHByaW50IG91dA=="),
705             "what will print out".getBytes()));
706         assertTrue(equalsBytes(Utility.parseBase64
707             ("d2hhdCAgd2lsbCAgIHByaW50ICAgICBvdXQgICAgICA="),
708             "what will print out ".getBytes()));
709         assertTrue(equalsBytes(Utility.parseBase64
710             ("d2hhdCAgd2lsbCAgIHByaW50ICAgICBvdXQ="),
711             "what will print out".getBytes()));
712     }
713
714     public void testSerializeBase64() {
715         assertEquals(Utility.serializeBase64(new byte[0]), "");
716         assertEquals(Utility.serializeBase64("\n".getBytes()), "Cg==");
717         assertEquals(Utility.serializeBase64("what".getBytes()), "d2hhdA==");
718         assertEquals(Utility.serializeBase64("what will print out".getBytes()),
719             "d2hhdCB3aWxsIHByaW50IG91dA==");
720         assertEquals(Utility.serializeBase64
721             ("what will print out ".getBytes()),
722             "d2hhdCAgd2lsbCAgIHByaW50ICAgICBvdXQgICAgICA=");
723         assertEquals(Utility.serializeBase64
724             ("what will print out".getBytes()),
725             "d2hhdCAgd2lsbCAgIHByaW50ICAgICBvdXQ=");
726     }
727
728     public void testIsEqual() {
729         assertTrue(Utility.isEqual(null, null));
730         assertFalse(Utility.isEqual(null, "text"));
731         assertFalse(Utility.isEqual("text", null));
732         assertTrue(Utility.isEqual("text", "text"));
733     }
734     
735     public static void main(String JavaDoc[] args) {
736         String JavaDoc[] names = { UtilityTest.class.getName() };
737         junit.textui.TestRunner.main(names);
738     }
739 }
Popular Tags