Java > Open Source Codes > org > joda > time > TestPeriodType


1 /*
2  * Copyright 2001-2005 Stephen Colebourne
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 package org.joda.time;
17
18 import java.io.ByteArrayInputStream ;
19 import java.io.ByteArrayOutputStream ;
20 import java.io.ObjectInputStream ;
21 import java.io.ObjectOutputStream ;
22 import java.util.Locale ;
23 import java.util.TimeZone ;
24
25 import junit.framework.TestCase;
26 import junit.framework.TestSuite;
27
28 /**
29  * This class is a JUnit test for PeriodType.
30  *
31  * @author Stephen Colebourne
32  */
33 public class TestPeriodType extends TestCase {
34     // Test in 2002/03 as time zones are more well known
35 // (before the late 90's they were all over the place)
36
37     private static final DateTimeZone PARIS = DateTimeZone.forID("Europe/Paris");
38     private static final DateTimeZone LONDON = DateTimeZone.forID("Europe/London");
39     
40     long y2002days = 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 +
41                      366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 +
42                      365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 +
43                      366 + 365;
44     long y2003days = 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 +
45                      366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 +
46                      365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 +
47                      366 + 365 + 365;
48     
49     // 2002-06-09
50 private long TEST_TIME_NOW =
51             (y2002days + 31L + 28L + 31L + 30L + 31L + 9L -1L) * DateTimeConstants.MILLIS_PER_DAY;
52             
53     // 2002-04-05
54 private long TEST_TIME1 =
55             (y2002days + 31L + 28L + 31L + 5L -1L) * DateTimeConstants.MILLIS_PER_DAY
56             + 12L * DateTimeConstants.MILLIS_PER_HOUR
57             + 24L * DateTimeConstants.MILLIS_PER_MINUTE;
58         
59     // 2003-05-06
60 private long TEST_TIME2 =
61             (y2003days + 31L + 28L + 31L + 30L + 6L -1L) * DateTimeConstants.MILLIS_PER_DAY
62             + 14L * DateTimeConstants.MILLIS_PER_HOUR
63             + 28L * DateTimeConstants.MILLIS_PER_MINUTE;
64     
65     private DateTimeZone originalDateTimeZone = null;
66     private TimeZone originalTimeZone = null;
67     private Locale originalLocale = null;
68
69     public static void main(String [] args) {
70         junit.textui.TestRunner.run(suite());
71     }
72
73     public static TestSuite suite() {
74         return new TestSuite(TestPeriodType.class);
75     }
76
77     public TestPeriodType(String name) {
78         super(name);
79     }
80
81     protected void setUp() throws Exception {
82         DateTimeUtils.setCurrentMillisFixed(TEST_TIME_NOW);
83         originalDateTimeZone = DateTimeZone.getDefault();
84         originalTimeZone = TimeZone.getDefault();
85         originalLocale = Locale.getDefault();
86         DateTimeZone.setDefault(LONDON);
87         TimeZone.setDefault(TimeZone.getTimeZone("Europe/London"));
88         Locale.setDefault(Locale.UK);
89     }
90
91     protected void tearDown() throws Exception {
92         DateTimeUtils.setCurrentMillisSystem();
93         DateTimeZone.setDefault(originalDateTimeZone);
94         TimeZone.setDefault(originalTimeZone);
95         Locale.setDefault(originalLocale);
96         originalDateTimeZone = null;
97         originalTimeZone = null;
98         originalLocale = null;
99     }
100
101     //-----------------------------------------------------------------------
102 public void testTest() {
103         assertEquals("2002-06-09T00:00:00.000Z", new Instant(TEST_TIME_NOW).toString());
104         assertEquals("2002-04-05T12:24:00.000Z", new Instant(TEST_TIME1).toString());
105         assertEquals("2003-05-06T14:28:00.000Z", new Instant(TEST_TIME2).toString());
106     }
107
108     //-----------------------------------------------------------------------
109 private void assertEqualsAfterSerialization(PeriodType type) throws Exception {
110         ByteArrayOutputStream baos = new ByteArrayOutputStream ();
111         ObjectOutputStream oos = new ObjectOutputStream (baos);
112         oos.writeObject(type);
113         byte[] bytes = baos.toByteArray();
114         oos.close();
115         
116         ByteArrayInputStream bais = new ByteArrayInputStream (bytes);
117         ObjectInputStream ois = new ObjectInputStream (bais);
118         PeriodType result = (PeriodType) ois.readObject();
119         ois.close();
120         
121         assertEquals(type, result);
122     }
123
124     private void assertSameAfterSerialization(PeriodType type) throws Exception {
125         ByteArrayOutputStream baos = new ByteArrayOutputStream ();
126         ObjectOutputStream oos = new ObjectOutputStream (baos);
127         oos.writeObject(type);
128         byte[] bytes = baos.toByteArray();
129         oos.close();
130         
131         ByteArrayInputStream bais = new ByteArrayInputStream (bytes);
132         ObjectInputStream ois = new ObjectInputStream (bais);
133         PeriodType result = (PeriodType) ois.readObject();
134         ois.close();
135         
136         assertEquals(type, result);
137     }
138
139     //-----------------------------------------------------------------------
140 public void testStandard() throws Exception {
141         PeriodType type = PeriodType.standard();
142         assertEquals(8, type.size());
143         assertEquals(DurationFieldType.years(), type.getFieldType(0));
144         assertEquals(DurationFieldType.months(), type.getFieldType(1));
145         assertEquals(DurationFieldType.weeks(), type.getFieldType(2));
146         assertEquals(DurationFieldType.days(), type.getFieldType(3));
147         assertEquals(DurationFieldType.hours(), type.getFieldType(4));
148         assertEquals(DurationFieldType.minutes(), type.getFieldType(5));
149         assertEquals(DurationFieldType.seconds(), type.getFieldType(6));
150         assertEquals(DurationFieldType.millis(), type.getFieldType(7));
151         assertEquals("Standard", type.getName());
152         assertEquals("PeriodType[Standard]", type.toString());
153         assertEquals(true, type.equals(type));
154         assertEquals(true, type == PeriodType.standard());
155         assertEquals(false, type.equals(PeriodType.millis()));
156         assertEquals(true, type.hashCode() == type.hashCode());
157         assertEquals(true, type.hashCode() == PeriodType.standard().hashCode());
158         assertEquals(false, type.hashCode() == PeriodType.millis().hashCode());
159         assertSameAfterSerialization(type);
160     }
161
162     //-----------------------------------------------------------------------
163 public void testYearMonthDayTime() throws Exception {
164         PeriodType type = PeriodType.yearMonthDayTime();
165         assertEquals(7, type.size());
166         assertEquals(DurationFieldType.years(), type.getFieldType(0));
167         assertEquals(DurationFieldType.months(), type.getFieldType(1));
168         assertEquals(DurationFieldType.days(), type.getFieldType(2));
169         assertEquals(DurationFieldType.hours(), type.getFieldType(3));
170         assertEquals(DurationFieldType.minutes(), type.getFieldType(4));
171         assertEquals(DurationFieldType.seconds(), type.getFieldType(5));
172         assertEquals(DurationFieldType.millis(), type.getFieldType(6));
173         assertEquals("YearMonthDayTime", type.getName());
174         assertEquals("PeriodType[YearMonthDayTime]", type.toString());
175         assertEquals(true, type.equals(type));
176         assertEquals(true, type == PeriodType.yearMonthDayTime());
177         assertEquals(false, type.equals(PeriodType.millis()));
178         assertEquals(true, type.hashCode() == type.hashCode());
179         assertEquals(true, type.hashCode() == PeriodType.yearMonthDayTime().hashCode());
180         assertEquals(false, type.hashCode() == PeriodType.millis().hashCode());
181         assertSameAfterSerialization(type);
182     }
183
184     //-----------------------------------------------------------------------
185 public void testYearMonthDay() throws Exception {
186         PeriodType type = PeriodType.yearMonthDay();
187         assertEquals(3, type.size());
188         assertEquals(DurationFieldType.years(), type.getFieldType(0));
189         assertEquals(DurationFieldType.months(), type.getFieldType(1));
190         assertEquals(DurationFieldType.days(), type.getFieldType(2));
191         assertEquals("YearMonthDay", type.getName());
192         assertEquals("PeriodType[YearMonthDay]", type.toString());
193         assertEquals(true, type.equals(type));
194         assertEquals(true, type == PeriodType.yearMonthDay());
195         assertEquals(false, type.equals(PeriodType.millis()));
196         assertEquals(true, type.hashCode() == type.hashCode());
197         assertEquals(true, type.hashCode() == PeriodType.yearMonthDay().hashCode());
198         assertEquals(false, type.hashCode() == PeriodType.millis().hashCode());
199         assertSameAfterSerialization(type);
200     }
201
202     //-----------------------------------------------------------------------
203 public void testYearWeekDayTime() throws Exception {
204         PeriodType type = PeriodType.yearWeekDayTime();
205         assertEquals(7, type.size());
206         assertEquals(DurationFieldType.years(), type.getFieldType(0));
207         assertEquals(DurationFieldType.weeks(), type.getFieldType(1));
208         assertEquals(DurationFieldType.days(), type.getFieldType(2));
209         assertEquals(DurationFieldType.hours(), type.getFieldType(3));
210         assertEquals(DurationFieldType.minutes(), type.getFieldType(4));
211         assertEquals(DurationFieldType.seconds(), type.getFieldType(5));
212         assertEquals(DurationFieldType.millis(), type.getFieldType(6));
213         assertEquals("YearWeekDayTime", type.getName());
214         assertEquals("PeriodType[YearWeekDayTime]", type.toString());
215         assertEquals(true, type.equals(type));
216         assertEquals(true, type == PeriodType.yearWeekDayTime());
217         assertEquals(false, type.equals(PeriodType.millis()));
218         assertEquals(true, type.hashCode() == type.hashCode());
219         assertEquals(true, type.hashCode() == PeriodType.yearWeekDayTime().hashCode());
220         assertEquals(false, type.hashCode() == PeriodType.millis().hashCode());
221         assertSameAfterSerialization(type);
222     }
223
224     //-----------------------------------------------------------------------
225 public void testYearWeekDay() throws Exception {
226         PeriodType type = PeriodType.yearWeekDay();
227         assertEquals(3, type.size());
228         assertEquals(DurationFieldType.years(), type.getFieldType(0));
229         assertEquals(DurationFieldType.weeks(), type.getFieldType(1));
230         assertEquals(DurationFieldType.days(), type.getFieldType(2));
231         assertEquals("YearWeekDay", type.getName());
232         assertEquals("PeriodType[YearWeekDay]", type.toString());
233         assertEquals(true, type.equals(type));
234         assertEquals(true, type == PeriodType.yearWeekDay());
235         assertEquals(false, type.equals(PeriodType.millis()));
236         assertEquals(true, type.hashCode() == type.hashCode());
237         assertEquals(true, type.hashCode() == PeriodType.yearWeekDay().hashCode());
238         assertEquals(false, type.hashCode() == PeriodType.millis().hashCode());
239         assertSameAfterSerialization(type);
240     }
241
242     //-----------------------------------------------------------------------
243 public void testYearDayTime() throws Exception {
244         PeriodType type = PeriodType.yearDayTime();
245         assertEquals(6, type.size());
246         assertEquals(DurationFieldType.years(), type.getFieldType(0));
247         assertEquals(DurationFieldType.days(), type.getFieldType(1));
248         assertEquals(DurationFieldType.hours(), type.getFieldType(2));
249         assertEquals(DurationFieldType.minutes(), type.getFieldType(3));
250         assertEquals(DurationFieldType.seconds(), type.getFieldType(4));
251         assertEquals(DurationFieldType.millis(), type.getFieldType(5));
252         assertEquals("YearDayTime", type.getName());
253         assertEquals("PeriodType[YearDayTime]", type.toString());
254         assertEquals(true, type.equals(type));
255         assertEquals(true, type == PeriodType.yearDayTime());
256         assertEquals(false, type.equals(PeriodType.millis()));
257         assertEquals(true, type.hashCode() == type.hashCode());
258         assertEquals(true, type.hashCode() == PeriodType.yearDayTime().hashCode());
259         assertEquals(false, type.hashCode() == PeriodType.millis().hashCode());
260         assertSameAfterSerialization(type);
261     }
262
263     //-----------------------------------------------------------------------
264 public void testYearDay() throws Exception {
265         PeriodType type = PeriodType.yearDay();
266         assertEquals(2, type.size());
267         assertEquals(DurationFieldType.years(), type.getFieldType(0));
268         assertEquals(DurationFieldType.days(), type.getFieldType(1));
269         assertEquals("YearDay", type.getName());
270         assertEquals("PeriodType[YearDay]", type.toString());
271         assertEquals(true, type.equals(type));
272         assertEquals(true, type == PeriodType.yearDay());
273         assertEquals(false, type.equals(PeriodType.millis()));
274         assertEquals(true, type.hashCode() == type.hashCode());
275         assertEquals(true, type.hashCode() == PeriodType.yearDay().hashCode());
276         assertEquals(false, type.hashCode() == PeriodType.millis().hashCode());
277         assertSameAfterSerialization(type);
278     }
279
280     //-----------------------------------------------------------------------
281 public void testDayTime() throws Exception {
282         PeriodType type = PeriodType.dayTime();
283         assertEquals(5, type.size());
284         assertEquals(DurationFieldType.days(), type.getFieldType(0));
285         assertEquals(DurationFieldType.hours(), type.getFieldType(1));
286         assertEquals(DurationFieldType.minutes(), type.getFieldType(2));
287         assertEquals(DurationFieldType.seconds(), type.getFieldType(3));
288         assertEquals(DurationFieldType.millis(), type.getFieldType(4));
289         assertEquals("DayTime", type.getName());
290         assertEquals("PeriodType[DayTime]", type.toString());
291         assertEquals(true, type.equals(type));
292         assertEquals(true, type == PeriodType.dayTime());
293         assertEquals(false, type.equals(PeriodType.millis()));
294         assertEquals(true, type.hashCode() == type.hashCode());
295         assertEquals(true, type.hashCode() == PeriodType.dayTime().hashCode());
296         assertEquals(false, type.hashCode() == PeriodType.millis().hashCode());
297         assertSameAfterSerialization(type);
298     }
299
300     //-----------------------------------------------------------------------
301 public void testTime() throws Exception {
302         PeriodType type = PeriodType.time();
303         assertEquals(4, type.size());
304         assertEquals(DurationFieldType.hours(), type.getFieldType(0));
305         assertEquals(DurationFieldType.minutes(), type.getFieldType(1));
306         assertEquals(DurationFieldType.seconds(), type.getFieldType(2));
307         assertEquals(DurationFieldType.millis(), type.getFieldType(3));
308         assertEquals("Time", type.getName());
309         assertEquals("PeriodType[Time]", type.toString());
310         assertEquals(true, type.equals(type));
311         assertEquals(true, type == PeriodType.time());
312         assertEquals(false, type.equals(PeriodType.millis()));
313         assertEquals(true, type.hashCode() == type.hashCode());
314         assertEquals(true, type.hashCode() == PeriodType.time().hashCode());
315         assertEquals(false, type.hashCode() == PeriodType.millis().hashCode());
316         assertSameAfterSerialization(type);
317     }
318
319     //-----------------------------------------------------------------------
320 public void testYears() throws Exception {
321         PeriodType type = PeriodType.years();
322         assertEquals(1, type.size());
323         assertEquals(DurationFieldType.years(), type.getFieldType(0));
324         assertEquals("Years", type.getName());
325         assertEquals("PeriodType[Years]", type.toString());
326         assertEquals(true, type.equals(type));
327         assertEquals(true, type == PeriodType.years());
328         assertEquals(false, type.equals(PeriodType.standard()));
329         assertEquals(true, type.hashCode() == type.hashCode());
330         assertEquals(true, type.hashCode() == PeriodType.years().hashCode());
331         assertEquals(false, type.hashCode() == PeriodType.standard().hashCode());
332         assertSameAfterSerialization(type);
333     }
334
335     //-----------------------------------------------------------------------
336 public void testMonths() throws Exception {
337         PeriodType type = PeriodType.months();
338         assertEquals(1, type.size());
339         assertEquals(DurationFieldType.months(), type.getFieldType(0));
340         assertEquals("Months", type.getName());
341         assertEquals("PeriodType[Months]", type.toString());
342         assertEquals(true, type.equals(type));
343         assertEquals(true, type == PeriodType.months());
344         assertEquals(false, type.equals(PeriodType.standard()));
345         assertEquals(true, type.hashCode() == type.hashCode());
346         assertEquals(true, type.hashCode() == PeriodType.months().hashCode());
347         assertEquals(false, type.hashCode() == PeriodType.standard().hashCode());
348         assertSameAfterSerialization(type);
349     }
350
351     //-----------------------------------------------------------------------
352 public void testWeeks() throws Exception {
353         PeriodType type = PeriodType.weeks();
354         assertEquals(1, type.size());
355         assertEquals(DurationFieldType.weeks(), type.getFieldType(0));
356         assertEquals("Weeks", type.getName());
357         assertEquals("PeriodType[Weeks]", type.toString());
358         assertEquals(true, type.equals(type));
359         assertEquals(true, type == PeriodType.weeks());
360         assertEquals(false, type.equals(PeriodType.standard()));
361         assertEquals(true, type.hashCode() == type.hashCode());
362         assertEquals(true, type.hashCode() == PeriodType.weeks().hashCode());
363         assertEquals(false, type.hashCode() == PeriodType.standard().hashCode());
364         assertSameAfterSerialization(type);
365     }
366
367     //-----------------------------------------------------------------------
368 public void testDays() throws Exception {
369         PeriodType type = PeriodType.days();
370         assertEquals(1, type.size());
371         assertEquals(DurationFieldType.days(), type.getFieldType(0));
372         assertEquals("Days", type.getName());
373         assertEquals("PeriodType[Days]", type.toString());
374         assertEquals(true, type.equals(type));
375         assertEquals(true, type == PeriodType.days());
376         assertEquals(false, type.equals(PeriodType.standard()));
377         assertEquals(true, type.hashCode() == type.hashCode());
378         assertEquals(true, type.hashCode() == PeriodType.days().hashCode());
379         assertEquals(false, type.hashCode() == PeriodType.standard().hashCode());
380         assertSameAfterSerialization(type);
381     }
382
383     //-----------------------------------------------------------------------
384 public void testHours() throws Exception {
385         PeriodType type = PeriodType.hours();
386         assertEquals(1, type.size());
387         assertEquals(DurationFieldType.hours(), type.getFieldType(0));
388         assertEquals("Hours", type.getName());
389         assertEquals("PeriodType[Hours]", type.toString());
390         assertEquals(true, type.equals(type));
391         assertEquals(true, type == PeriodType.hours());
392         assertEquals(false, type.equals(PeriodType.standard()));
393         assertEquals(true, type.hashCode() == type.hashCode());
394         assertEquals(true, type.hashCode() == PeriodType.hours().hashCode());
395         assertEquals(false, type.hashCode() == PeriodType.standard().hashCode());
396         assertSameAfterSerialization(type);
397     }
398
399     //-----------------------------------------------------------------------
400 public void testMinutes() throws Exception {
401         PeriodType type = PeriodType.minutes();
402         assertEquals(1, type.size());
403         assertEquals(DurationFieldType.minutes(), type.getFieldType(0));
404         assertEquals("Minutes", type.getName());
405         assertEquals("PeriodType[Minutes]", type.toString());
406         assertEquals(true, type.equals(type));
407         assertEquals(true, type == PeriodType.minutes());
408         assertEquals(false, type.equals(PeriodType.standard()));
409         assertEquals(true, type.hashCode() == type.hashCode());
410         assertEquals(true, type.hashCode() == PeriodType.minutes().hashCode());
411         assertEquals(false, type.hashCode() == PeriodType.standard().hashCode());
412         assertSameAfterSerialization(type);
413     }
414
415     //-----------------------------------------------------------------------
416 public void testSeconds() throws Exception {
417         PeriodType type = PeriodType.seconds();
418         assertEquals(1, type.size());
419         assertEquals(DurationFieldType.seconds(), type.getFieldType(0));
420         assertEquals("Seconds", type.getName());
421         assertEquals("PeriodType[Seconds]", type.toString());
422         assertEquals(true, type.equals(type));
423         assertEquals(true, type == PeriodType.seconds());
424         assertEquals(false, type.equals(PeriodType.standard()));
425         assertEquals(true, type.hashCode() == type.hashCode());
426         assertEquals(true, type.hashCode() == PeriodType.seconds().hashCode());
427         assertEquals(false, type.hashCode() == PeriodType.standard().hashCode());
428         assertSameAfterSerialization(type);
429     }
430
431     //-----------------------------------------------------------------------
432 public void testMillis() throws Exception {
433         PeriodType type = PeriodType.millis();
434         assertEquals(1, type.size());
435         assertEquals(DurationFieldType.millis(), type.getFieldType(0));
436         assertEquals("Millis", type.getName());
437         assertEquals("PeriodType[Millis]", type.toString());
438         assertEquals(true, type.equals(type));
439         assertEquals(true, type == PeriodType.millis());
440         assertEquals(false, type.equals(PeriodType.standard()));
441         assertEquals(true, type.hashCode() == type.hashCode());
442         assertEquals(true, type.hashCode() == PeriodType.millis().hashCode());
443         assertEquals(false, type.hashCode() == PeriodType.standard().hashCode());
444         assertSameAfterSerialization(type);
445     }
446
447     //-----------------------------------------------------------------------
448 public void testForFields1() throws Exception {
449         PeriodType type = PeriodType.forFields(new DurationFieldType[] {
450             DurationFieldType.years(),
451         });
452         assertSame(PeriodType.years(), type);
453         type = PeriodType.forFields(new DurationFieldType[] {
454             DurationFieldType.months(),
455         });
456         assertSame(PeriodType.months(), type);
457         type = PeriodType.forFields(new DurationFieldType[] {
458                 DurationFieldType.weeks(),
459         });
460         assertSame(PeriodType.weeks(), type);
461         type = PeriodType.forFields(new DurationFieldType[] {
462                 DurationFieldType.days(),
463         });
464         assertSame(PeriodType.days(), type);
465         type = PeriodType.forFields(new DurationFieldType[] {
466                 DurationFieldType.hours(),
467         });
468         assertSame(PeriodType.hours(), type);
469         type = PeriodType.forFields(new DurationFieldType[] {
470                 DurationFieldType.minutes(),
471         });
472         assertSame(PeriodType.minutes(), type);
473         type = PeriodType.forFields(new DurationFieldType[] {
474                 DurationFieldType.seconds(),
475         });
476         assertSame(PeriodType.seconds(), type);
477         type = PeriodType.forFields(new DurationFieldType[] {
478                 DurationFieldType.millis(),
479         });
480         assertSame(PeriodType.millis(), type);
481     }
482
483     public void testForFields2() throws Exception {
484         DurationFieldType[] types = new DurationFieldType[] {
485             DurationFieldType.years(),
486             DurationFieldType.hours(),
487         };
488         PeriodType type = PeriodType.forFields(types);
489         assertEquals(2, type.size());
490         assertEquals(DurationFieldType.years(), type.getFieldType(0));
491         assertEquals(DurationFieldType.hours(), type.getFieldType(1));
492         assertEquals("StandardNoMonthsNoWeeksNoDaysNoMinutesNoSecondsNoMillis", type.getName());
493         assertEquals("PeriodType[StandardNoMonthsNoWeeksNoDaysNoMinutesNoSecondsNoMillis]", type.toString());
494         assertEquals(true, type.equals(type));
495         assertEquals(true, type == PeriodType.forFields(types));
496         assertEquals(false, type.equals(PeriodType.millis()));
497         assertEquals(true, type.hashCode() == type.hashCode());
498         assertEquals(true, type.hashCode() == PeriodType.forFields(types).hashCode());
499         assertEquals(false, type.hashCode() == PeriodType.millis().hashCode());
500         assertSameAfterSerialization(type);
501     }
502
503     public void testForFields3() throws Exception {
504         DurationFieldType[] types = new DurationFieldType[] {
505             DurationFieldType.months(),
506             DurationFieldType.weeks(),
507         };
508         PeriodType type = PeriodType.forFields(types);
509         assertEquals(2, type.size());
510         assertEquals(DurationFieldType.months(), type.getFieldType(0));
511         assertEquals(DurationFieldType.weeks(), type.getFieldType(1));
512         assertEquals("StandardNoYearsNoDaysNoHoursNoMinutesNoSecondsNoMillis", type.getName());
513         assertEquals("PeriodType[StandardNoYearsNoDaysNoHoursNoMinutesNoSecondsNoMillis]", type.toString());
514         assertEquals(true, type.equals(type));
515         assertEquals(true, type == PeriodType.forFields(types));
516         assertEquals(false, type.equals(PeriodType.millis()));
517         assertEquals(true, type.hashCode() == type.hashCode());
518         assertEquals(true, type.hashCode() == PeriodType.forFields(types).hashCode());
519         assertEquals(false, type.hashCode() == PeriodType.millis().hashCode());
520         assertSameAfterSerialization(type);
521     }
522
523     public void testForFields4() throws Exception {
524         DurationFieldType[] types = new DurationFieldType[] {
525             DurationFieldType.weeks(),
526             DurationFieldType.months(),
527         };
528         DurationFieldType[] types2 = new DurationFieldType[] {
529             DurationFieldType.months(),
530             DurationFieldType.weeks(),
531         };
532         PeriodType type = PeriodType.forFields(types);
533         PeriodType type2 = PeriodType.forFields(types2);
534         assertEquals(true, type == type2);
535     }
536
537     public void testForFields5() throws Exception {
538         DurationFieldType[] types = new DurationFieldType[] {
539             DurationFieldType.centuries(),
540             DurationFieldType.months(),
541         };
542         try {
543             PeriodType.forFields(types);
544             fail();
545         } catch (IllegalArgumentException ex) {
546             // expected
547 }
548         try {
549             PeriodType.forFields(types); // repeated for test coverage of cache
550 fail();
551         } catch (IllegalArgumentException ex) {
552             // expected
553 }
554     }
555
556     public void testForFields6() throws Exception {
557         DurationFieldType[] types = null;
558         try {
559             PeriodType.forFields(types);
560             fail();
561         } catch (IllegalArgumentException ex) {
562             // expected
563 }
564         
565         types = new DurationFieldType[0];
566         try {
567             PeriodType.forFields(types);
568             fail();
569         } catch (IllegalArgumentException ex) {
570             // expected
571 }
572         
573         types = new DurationFieldType[] {
574             null,
575             DurationFieldType.months(),
576         };
577         try {
578             PeriodType.forFields(types);
579             fail();
580         } catch (IllegalArgumentException ex) {
581             // expected
582 }
583         
584         types = new DurationFieldType[] {
585             DurationFieldType.months(),
586             null,
587         };
588         try {
589             PeriodType.forFields(types);
590             fail();
591         } catch (IllegalArgumentException ex) {
592             // expected
593 }
594     }
595
596     //-----------------------------------------------------------------------
597 public void testMaskYears() throws Exception {
598         PeriodType type = PeriodType.standard().withYearsRemoved();
599         assertEquals(7, type.size());
600         assertEquals(DurationFieldType.months(), type.getFieldType(0));
601         assertEquals(DurationFieldType.weeks(), type.getFieldType(1));
602         assertEquals(DurationFieldType.days(), type.getFieldType(2));
603         assertEquals(DurationFieldType.hours(), type.getFieldType(3));
604         assertEquals(DurationFieldType.minutes(), type.getFieldType(4));
605         assertEquals(DurationFieldType.seconds(), type.getFieldType(5));
606         assertEquals(DurationFieldType.millis(), type.getFieldType(6));
607         assertEquals(true, type.equals(type));
608         assertEquals(true, type.equals(PeriodType.standard().withYearsRemoved()));
609         assertEquals(false, type.equals(PeriodType.millis()));
610         assertEquals(true, type.hashCode() == type.hashCode());
611         assertEquals(true, type.hashCode() == PeriodType.standard().withYearsRemoved().hashCode());
612         assertEquals(false, type.hashCode() == PeriodType.millis().hashCode());
613         assertEquals("StandardNoYears", type.getName());
614         assertEquals("PeriodType[StandardNoYears]", type.toString());
615         assertEqualsAfterSerialization(type);
616     }
617
618     //-----------------------------------------------------------------------
619 public void testMaskMonths() throws Exception {
620         PeriodType type = PeriodType.standard().withMonthsRemoved();
621         assertEquals(7, type.size());
622         assertEquals(DurationFieldType.years(), type.getFieldType(0));
623         assertEquals(DurationFieldType.weeks(), type.getFieldType(1));
624         assertEquals(DurationFieldType.days(), type.getFieldType(2));
625         assertEquals(DurationFieldType.hours(), type.getFieldType(3));
626         assertEquals(DurationFieldType.minutes(), type.getFieldType(4));
627         assertEquals(DurationFieldType.seconds(), type.getFieldType(5));
628         assertEquals(DurationFieldType.millis(), type.getFieldType(6));
629         assertEquals(true, type.equals(type));
630         assertEquals(true, type.equals(PeriodType.standard().withMonthsRemoved()));
631         assertEquals(false, type.equals(PeriodType.millis()));
632         assertEquals(true, type.hashCode() == type.hashCode());
633         assertEquals(true, type.hashCode() == PeriodType.standard().withMonthsRemoved().hashCode());
634         assertEquals(false, type.hashCode() == PeriodType.millis().hashCode());
635         assertEquals("StandardNoMonths", type.getName());
636         assertEquals("PeriodType[StandardNoMonths]", type.toString());
637         assertEqualsAfterSerialization(type);
638     }
639
640     //-----------------------------------------------------------------------
641 public void testMaskWeeks() throws Exception {
642         PeriodType type = PeriodType.standard().withWeeksRemoved();
643         assertEquals(7, type.size());
644         assertEquals(DurationFieldType.years(), type.getFieldType(0));
645         assertEquals(DurationFieldType.months(), type.getFieldType(1));
646         assertEquals(DurationFieldType.days(), type.getFieldType(2));
647         assertEquals(DurationFieldType.hours(), type.getFieldType(3));
648         assertEquals(DurationFieldType.minutes(), type.getFieldType(4));
649         assertEquals(DurationFieldType.seconds(), type.getFieldType(5));
650         assertEquals(DurationFieldType.millis(), type.getFieldType(6));
651         assertEquals(true, type.equals(type));
652         assertEquals(true, type.equals(PeriodType.standard().withWeeksRemoved()));
653         assertEquals(false, type.equals(PeriodType.millis()));
654         assertEquals(true, type.hashCode() == type.hashCode());
655         assertEquals(true, type.hashCode() == PeriodType.standard().withWeeksRemoved().hashCode());
656         assertEquals(false, type.hashCode() == PeriodType.millis().hashCode());
657         assertEquals("StandardNoWeeks", type.getName());
658         assertEquals("PeriodType[StandardNoWeeks]", type.toString());
659         assertEqualsAfterSerialization(type);
660     }
661
662     //-----------------------------------------------------------------------
663 public void testMaskDays() throws Exception {
664         PeriodType type = PeriodType.standard().withDaysRemoved();
665         assertEquals(7, type.size());
666         assertEquals(DurationFieldType.years(), type.getFieldType(0));
667         assertEquals(DurationFieldType.months(), type.getFieldType(1));
668         assertEquals(DurationFieldType.weeks(), type.getFieldType(2));
669         assertEquals(DurationFieldType.hours(), type.getFieldType(3));
670         assertEquals(DurationFieldType.minutes(), type.getFieldType(4));
671         assertEquals(DurationFieldType.seconds(), type.getFieldType(5));
672         assertEquals(DurationFieldType.millis(), type.getFieldType(6));
673         assertEquals(true, type.equals(type));
674         assertEquals(true, type.equals(PeriodType.standard().withDaysRemoved()));
675         assertEquals(false, type.equals(PeriodType.millis()));
676         assertEquals(true, type.hashCode() == type.hashCode());
677         assertEquals(true, type.hashCode() == PeriodType.standard().withDaysRemoved().hashCode());
678         assertEquals(false, type.hashCode() == PeriodType.millis().hashCode());
679         assertEquals("StandardNoDays", type.getName());
680         assertEquals("PeriodType[StandardNoDays]", type.toString());
681         assertEqualsAfterSerialization(type);
682     }
683
684     //-----------------------------------------------------------------------
685 public void testMaskHours() throws Exception {
686         PeriodType type = PeriodType.standard().withHoursRemoved();
687         assertEquals(7, type.size());
688         assertEquals(DurationFieldType.years(), type.getFieldType(0));
689         assertEquals(DurationFieldType.months(), type.getFieldType(1));
690         assertEquals(DurationFieldType.weeks(), type.getFieldType(2));
691         assertEquals(DurationFieldType.days(), type.getFieldType(3));
692         assertEquals(DurationFieldType.minutes(), type.getFieldType(4));
693         assertEquals(DurationFieldType.seconds(), type.getFieldType(5));
694         assertEquals(DurationFieldType.millis(), type.getFieldType(6));
695         assertEquals(true, type.equals(type));
696         assertEquals(true, type.equals(PeriodType.standard().withHoursRemoved()));
697         assertEquals(false, type.equals(PeriodType.millis()));
698         assertEquals(true, type.hashCode() == type.hashCode());
699         assertEquals(true, type.hashCode() == PeriodType.standard().withHoursRemoved().hashCode());
700         assertEquals(false, type.hashCode() == PeriodType.millis().hashCode());
701         assertEquals("StandardNoHours", type.getName());
702         assertEquals("PeriodType[StandardNoHours]", type.toString());
703         assertEqualsAfterSerialization(type);
704     }
705
706     //-----------------------------------------------------------------------
707 public void testMaskMinutes() throws Exception {
708         PeriodType type = PeriodType.standard().withMinutesRemoved();
709         assertEquals(7, type.size());
710         assertEquals(DurationFieldType.years(), type.getFieldType(0));
711         assertEquals(DurationFieldType.months(), type.getFieldType(1));
712         assertEquals(DurationFieldType.weeks(), type.getFieldType(2));
713         assertEquals(DurationFieldType.days(), type.getFieldType(3));
714         assertEquals(DurationFieldType.hours(), type.getFieldType(4));
715         assertEquals(DurationFieldType.seconds(), type.getFieldType(5));
716         assertEquals(DurationFieldType.millis(), type.getFieldType(6));
717         assertEquals(true, type.equals(type));
718         assertEquals(true, type.equals(PeriodType.standard().withMinutesRemoved()));
719         assertEquals(false, type.equals(PeriodType.millis()));
720         assertEquals(true, type.hashCode() == type.hashCode());
721         assertEquals(true, type.hashCode() == PeriodType.standard().withMinutesRemoved().hashCode());
722         assertEquals(false, type.hashCode() == PeriodType.millis().hashCode());
723         assertEquals("StandardNoMinutes", type.getName());
724         assertEquals("PeriodType[StandardNoMinutes]", type.toString());
725         assertEqualsAfterSerialization(type);
726     }
727
728     //-----------------------------------------------------------------------
729 public void testMaskSeconds() throws Exception {
730         PeriodType type = PeriodType.standard().withSecondsRemoved();
731         assertEquals(7, type.size());
732         assertEquals(DurationFieldType.years(), type.getFieldType(0));
733         assertEquals(DurationFieldType.months(), type.getFieldType(1));
734         assertEquals(DurationFieldType.weeks(), type.getFieldType(2));
735         assertEquals(DurationFieldType.days(), type.getFieldType(3));
736         assertEquals(DurationFieldType.hours(), type.getFieldType(4));
737         assertEquals(DurationFieldType.minutes(), type.getFieldType(5));
738         assertEquals(DurationFieldType.millis(), type.getFieldType(6));
739         assertEquals(true, type.equals(type));
740         assertEquals(true, type.equals(PeriodType.standard().withSecondsRemoved()));
741         assertEquals(false, type.equals(PeriodType.millis()));
742         assertEquals(true, type.hashCode() == type.hashCode());
743         assertEquals(true, type.hashCode() == PeriodType.standard().withSecondsRemoved().hashCode());
744         assertEquals(false, type.hashCode() == PeriodType.millis().hashCode());
745         assertEquals("StandardNoSeconds", type.getName());
746         assertEquals("PeriodType[StandardNoSeconds]", type.toString());
747         assertEqualsAfterSerialization(type);
748     }
749
750     //-----------------------------------------------------------------------
751 public void testMaskMillis() throws Exception {
752         PeriodType type = PeriodType.standard().withMillisRemoved();
753         assertEquals(7, type.size());
754         assertEquals(DurationFieldType.years(), type.getFieldType(0));
755         assertEquals(DurationFieldType.months(), type.getFieldType(1));
756         assertEquals(DurationFieldType.weeks(), type.getFieldType(2));
757         assertEquals(DurationFieldType.days(), type.getFieldType(3));
758         assertEquals(DurationFieldType.hours(), type.getFieldType(4));
759         assertEquals(DurationFieldType.minutes(), type.getFieldType(5));
760         assertEquals(DurationFieldType.seconds(), type.getFieldType(6));
761         assertEquals(true, type.equals(type));
762         assertEquals(true, type.equals(PeriodType.standard().withMillisRemoved()));
763         assertEquals(false, type.equals(PeriodType.millis()));
764         assertEquals(true, type.hashCode() == type.hashCode());
765         assertEquals(true, type.hashCode() == PeriodType.standard().withMillisRemoved().hashCode());
766         assertEquals(false, type.hashCode() == PeriodType.millis().hashCode());
767         assertEquals("StandardNoMillis", type.getName());
768         assertEquals("PeriodType[StandardNoMillis]", type.toString());
769         assertEqualsAfterSerialization(type);
770     }
771
772     //-----------------------------------------------------------------------
773 public void testMaskHoursMinutesSeconds() throws Exception {
774         PeriodType type = PeriodType.standard().withHoursRemoved().withMinutesRemoved().withSecondsRemoved();
775         assertEquals(5, type.size());
776         assertEquals(DurationFieldType.years(), type.getFieldType(0));
777         assertEquals(DurationFieldType.months(), type.getFieldType(1));
778         assertEquals(DurationFieldType.weeks(), type.getFieldType(2));
779         assertEquals(DurationFieldType.days(), type.getFieldType(3));
780         assertEquals(DurationFieldType.millis(), type.getFieldType(4));
781         assertEquals(true, type.equals(type));
782         assertEquals(true, type.equals(PeriodType.standard().withHoursRemoved().withMinutesRemoved().withSecondsRemoved()));
783         assertEquals(false, type.equals(PeriodType.millis()));
784         assertEquals(true, type.hashCode() == type.hashCode());
785         assertEquals(true, type.hashCode() == PeriodType.standard().withHoursRemoved().withMinutesRemoved().withSecondsRemoved().hashCode());
786         assertEquals(false, type.hashCode() == PeriodType.millis().hashCode());
787         assertEquals("StandardNoHoursNoMinutesNoSeconds", type.getName());
788         assertEquals("PeriodType[StandardNoHoursNoMinutesNoSeconds]", type.toString());
789         assertEqualsAfterSerialization(type);
790     }
791
792     //-----------------------------------------------------------------------
793 public void testMaskTwice1() throws Exception {
794         PeriodType type = PeriodType.standard().withYearsRemoved();
795         PeriodType type2 = type.withYearsRemoved();
796         assertEquals(true, type == type2);
797         
798         type = PeriodType.standard().withMonthsRemoved();
799         type2 = type.withMonthsRemoved();
800         assertEquals(true, type == type2);
801         
802         type = PeriodType.standard().withWeeksRemoved();
803         type2 = type.withWeeksRemoved();
804         assertEquals(true, type == type2);
805         
806         type = PeriodType.standard().withDaysRemoved();
807         type2 = type.withDaysRemoved();
808         assertEquals(true, type == type2);
809         
810         type = PeriodType.standard().withHoursRemoved();
811         type2 = type.withHoursRemoved();
812         assertEquals(true, type == type2);
813         
814         type = PeriodType.standard().withMinutesRemoved();
815         type2 = type.withMinutesRemoved();
816         assertEquals(true, type == type2);
817         
818         type = PeriodType.standard().withSecondsRemoved();
819         type2 = type.withSecondsRemoved();
820         assertEquals(true, type == type2);
821         
822         type = PeriodType.standard().withMillisRemoved();
823         type2 = type.withMillisRemoved();
824         assertEquals(true, type == type2);
825     }
826
827     //-----------------------------------------------------------------------
828 public void testMaskTwice2() throws Exception {
829         PeriodType type = PeriodType.dayTime();
830         PeriodType type2 = type.withYearsRemoved();
831         assertEquals(true, type == type2);
832         
833         type = PeriodType.dayTime();
834         type2 = type.withMonthsRemoved();
835         assertEquals(true, type == type2);
836         
837         type = PeriodType.dayTime();
838         type2 = type.withWeeksRemoved();
839         assertEquals(true, type == type2);
840         
841         type = PeriodType.millis();
842         type2 = type.withDaysRemoved();
843         assertEquals(true, type == type2);
844         
845         type = PeriodType.millis();
846         type2 = type.withHoursRemoved();
847         assertEquals(true, type == type2);
848         
849         type = PeriodType.millis();
850         type2 = type.withMinutesRemoved();
851         assertEquals(true, type == type2);
852         
853         type = PeriodType.millis();
854         type2 = type.withSecondsRemoved();
855         assertEquals(true, type == type2);
856     }
857
858     //-----------------------------------------------------------------------
859 public void testEquals() throws Exception {
860         PeriodType type = PeriodType.dayTime().withMillisRemoved();
861         assertEquals(true, type.equals(type));
862         assertEquals(true, type.equals(PeriodType.dayTime().withMillisRemoved()));
863         assertEquals(false, type.equals(null));
864         assertEquals(false, type.equals(""));
865     }
866
867     public void testHashCode() throws Exception {
868         PeriodType type = PeriodType.dayTime().withMillisRemoved();
869         assertEquals(type.hashCode(), type.hashCode());
870     }
871
872     //-----------------------------------------------------------------------
873 public void testIsSupported() throws Exception {
874         PeriodType type = PeriodType.dayTime().withMillisRemoved();
875         assertEquals(false, type.isSupported(DurationFieldType.years()));
876         assertEquals(false, type.isSupported(DurationFieldType.months()));
877         assertEquals(false, type.isSupported(DurationFieldType.weeks()));
878         assertEquals(true, type.isSupported(DurationFieldType.days()));
879         assertEquals(true, type.isSupported(DurationFieldType.hours()));
880         assertEquals(true, type.isSupported(DurationFieldType.minutes()));
881         assertEquals(true, type.isSupported(DurationFieldType.seconds()));
882         assertEquals(false, type.isSupported(DurationFieldType.millis()));
883     }
884
885     //-----------------------------------------------------------------------
886 public void testIndexOf() throws Exception {
887         PeriodType type = PeriodType.dayTime().withMillisRemoved();
888         assertEquals(-1, type.indexOf(DurationFieldType.years()));
889         assertEquals(-1, type.indexOf(DurationFieldType.months()));
890         assertEquals(-1, type.indexOf(DurationFieldType.weeks()));
891         assertEquals(0, type.indexOf(DurationFieldType.days()));
892         assertEquals(1, type.indexOf(DurationFieldType.hours()));
893         assertEquals(2, type.indexOf(DurationFieldType.minutes()));
894         assertEquals(3, type.indexOf(DurationFieldType.seconds()));
895         assertEquals(-1, type.indexOf(DurationFieldType.millis()));
896     }
897
898 }
899

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags