View Javadoc

1   /*
2    *  Copyright 2001-2009 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.Arrays;
23  import java.util.Locale;
24  
25  import junit.framework.TestCase;
26  import junit.framework.TestSuite;
27  
28  import org.joda.time.chrono.BuddhistChronology;
29  import org.joda.time.chrono.CopticChronology;
30  import org.joda.time.chrono.GregorianChronology;
31  import org.joda.time.chrono.ISOChronology;
32  import org.joda.time.format.DateTimeFormat;
33  import org.joda.time.format.DateTimeFormatter;
34  
35  /**
36   * This class is a Junit unit test for YearMonth.
37   *
38   * @author Stephen Colebourne
39   */
40  public class TestYearMonth_Basics extends TestCase {
41  
42      private static final DateTimeZone PARIS = DateTimeZone.forID("Europe/Paris");
43      private static final DateTimeZone LONDON = DateTimeZone.forID("Europe/London");
44      private static final DateTimeZone TOKYO = DateTimeZone.forID("Asia/Tokyo");
45      private static final Chronology COPTIC_PARIS = CopticChronology.getInstance(PARIS);
46      private static final Chronology COPTIC_LONDON = CopticChronology.getInstance(LONDON);
47      private static final Chronology COPTIC_TOKYO = CopticChronology.getInstance(TOKYO);
48      private static final Chronology COPTIC_UTC = CopticChronology.getInstanceUTC();
49  //    private static final Chronology ISO_PARIS = ISOChronology.getInstance(PARIS);
50  //    private static final Chronology ISO_LONDON = ISOChronology.getInstance(LONDON);
51  //    private static final Chronology ISO_TOKYO = ISOChronology.getInstance(TOKYO);
52      private static final Chronology ISO_UTC = ISOChronology.getInstanceUTC();
53  //    private static final Chronology BUDDHIST_PARIS = BuddhistChronology.getInstance(PARIS);
54  //    private static final Chronology BUDDHIST_LONDON = BuddhistChronology.getInstance(LONDON);
55      private static final Chronology BUDDHIST_TOKYO = BuddhistChronology.getInstance(TOKYO);
56      private static final Chronology BUDDHIST_UTC = BuddhistChronology.getInstanceUTC();
57      
58      private long TEST_TIME_NOW =
59              (31L + 28L + 31L + 30L + 31L + 9L -1L) * DateTimeConstants.MILLIS_PER_DAY;
60  
61      private DateTimeZone zone = null;
62  
63      public static void main(String[] args) {
64          junit.textui.TestRunner.run(suite());
65      }
66  
67      public static TestSuite suite() {
68          return new TestSuite(TestYearMonth_Basics.class);
69      }
70  
71      public TestYearMonth_Basics(String name) {
72          super(name);
73      }
74  
75      protected void setUp() throws Exception {
76          DateTimeUtils.setCurrentMillisFixed(TEST_TIME_NOW);
77          zone = DateTimeZone.getDefault();
78          DateTimeZone.setDefault(LONDON);
79      }
80  
81      protected void tearDown() throws Exception {
82          DateTimeUtils.setCurrentMillisSystem();
83          DateTimeZone.setDefault(zone);
84          zone = null;
85      }
86  
87      //-----------------------------------------------------------------------
88      public void testGet() {
89          YearMonth test = new YearMonth();
90          assertEquals(1970, test.get(DateTimeFieldType.year()));
91          assertEquals(6, test.get(DateTimeFieldType.monthOfYear()));
92          try {
93              test.get(null);
94              fail();
95          } catch (IllegalArgumentException ex) {}
96          try {
97              test.get(DateTimeFieldType.dayOfMonth());
98              fail();
99          } catch (IllegalArgumentException ex) {}
100     }
101 
102     public void testSize() {
103         YearMonth test = new YearMonth();
104         assertEquals(2, test.size());
105     }
106 
107     public void testGetFieldType() {
108         YearMonth test = new YearMonth(COPTIC_PARIS);
109         assertSame(DateTimeFieldType.year(), test.getFieldType(0));
110         assertSame(DateTimeFieldType.monthOfYear(), test.getFieldType(1));
111         try {
112             test.getFieldType(-1);
113         } catch (IndexOutOfBoundsException ex) {}
114         try {
115             test.getFieldType(2);
116         } catch (IndexOutOfBoundsException ex) {}
117     }
118 
119     public void testGetFieldTypes() {
120         YearMonth test = new YearMonth(COPTIC_PARIS);
121         DateTimeFieldType[] fields = test.getFieldTypes();
122         assertEquals(2, fields.length);
123         assertSame(DateTimeFieldType.year(), fields[0]);
124         assertSame(DateTimeFieldType.monthOfYear(), fields[1]);
125         assertNotSame(test.getFieldTypes(), test.getFieldTypes());
126     }
127 
128     public void testGetField() {
129         YearMonth test = new YearMonth(COPTIC_PARIS);
130         assertSame(COPTIC_UTC.year(), test.getField(0));
131         assertSame(COPTIC_UTC.monthOfYear(), test.getField(1));
132         try {
133             test.getField(-1);
134         } catch (IndexOutOfBoundsException ex) {}
135         try {
136             test.getField(2);
137         } catch (IndexOutOfBoundsException ex) {}
138     }
139 
140     public void testGetFields() {
141         YearMonth test = new YearMonth(COPTIC_PARIS);
142         DateTimeField[] fields = test.getFields();
143         assertEquals(2, fields.length);
144         assertSame(COPTIC_UTC.year(), fields[0]);
145         assertSame(COPTIC_UTC.monthOfYear(), fields[1]);
146         assertNotSame(test.getFields(), test.getFields());
147     }
148 
149     public void testGetValue() {
150         YearMonth test = new YearMonth();
151         assertEquals(1970, test.getValue(0));
152         assertEquals(6, test.getValue(1));
153         try {
154             test.getValue(-1);
155         } catch (IndexOutOfBoundsException ex) {}
156         try {
157             test.getValue(2);
158         } catch (IndexOutOfBoundsException ex) {}
159     }
160 
161     public void testGetValues() {
162         YearMonth test = new YearMonth();
163         int[] values = test.getValues();
164         assertEquals(2, values.length);
165         assertEquals(1970, values[0]);
166         assertEquals(6, values[1]);
167         assertNotSame(test.getValues(), test.getValues());
168     }
169 
170     public void testIsSupported() {
171         YearMonth test = new YearMonth(COPTIC_PARIS);
172         assertEquals(true, test.isSupported(DateTimeFieldType.year()));
173         assertEquals(true, test.isSupported(DateTimeFieldType.monthOfYear()));
174         assertEquals(false, test.isSupported(DateTimeFieldType.dayOfMonth()));
175         assertEquals(false, test.isSupported(DateTimeFieldType.hourOfDay()));
176     }
177 
178     public void testEqualsHashCode() {
179         YearMonth test1 = new YearMonth(1970, 6, COPTIC_PARIS);
180         YearMonth test2 = new YearMonth(1970, 6, COPTIC_PARIS);
181         assertEquals(true, test1.equals(test2));
182         assertEquals(true, test2.equals(test1));
183         assertEquals(true, test1.equals(test1));
184         assertEquals(true, test2.equals(test2));
185         assertEquals(true, test1.hashCode() == test2.hashCode());
186         assertEquals(true, test1.hashCode() == test1.hashCode());
187         assertEquals(true, test2.hashCode() == test2.hashCode());
188         
189         YearMonth test3 = new YearMonth(1971, 6);
190         assertEquals(false, test1.equals(test3));
191         assertEquals(false, test2.equals(test3));
192         assertEquals(false, test3.equals(test1));
193         assertEquals(false, test3.equals(test2));
194         assertEquals(false, test1.hashCode() == test3.hashCode());
195         assertEquals(false, test2.hashCode() == test3.hashCode());
196         
197         assertEquals(false, test1.equals("Hello"));
198         assertEquals(true, test1.equals(new MockYM()));
199         assertEquals(false, test1.equals(MockPartial.EMPTY_INSTANCE));
200     }
201     
202     class MockYM extends MockPartial {
203         public Chronology getChronology() {
204             return COPTIC_UTC;
205         }
206         public DateTimeField[] getFields() {
207             return new DateTimeField[] {
208                 COPTIC_UTC.year(),
209                 COPTIC_UTC.monthOfYear(),
210             };
211         }
212         public int[] getValues() {
213             return new int[] {1970, 6};
214         }
215     }
216 
217     //-----------------------------------------------------------------------
218     public void testCompareTo() {
219         YearMonth test1 = new YearMonth(2005, 6);
220         YearMonth test1a = new YearMonth(2005, 6);
221         assertEquals(0, test1.compareTo(test1a));
222         assertEquals(0, test1a.compareTo(test1));
223         assertEquals(0, test1.compareTo(test1));
224         assertEquals(0, test1a.compareTo(test1a));
225         
226         YearMonth test2 = new YearMonth(2005, 7);
227         assertEquals(-1, test1.compareTo(test2));
228         assertEquals(+1, test2.compareTo(test1));
229         
230         YearMonth test3 = new YearMonth(2005, 7, GregorianChronology.getInstanceUTC());
231         assertEquals(-1, test1.compareTo(test3));
232         assertEquals(+1, test3.compareTo(test1));
233         assertEquals(0, test3.compareTo(test2));
234         
235         DateTimeFieldType[] types = new DateTimeFieldType[] {
236             DateTimeFieldType.year(),
237             DateTimeFieldType.monthOfYear(),
238         };
239         int[] values = new int[] {2005, 6};
240         Partial p = new Partial(types, values);
241         assertEquals(0, test1.compareTo(p));
242         try {
243             test1.compareTo(null);
244             fail();
245         } catch (NullPointerException ex) {}
246         try {
247             test1.compareTo(new LocalTime());
248             fail();
249         } catch (ClassCastException ex) {}
250         Partial partial = new Partial()
251             .with(DateTimeFieldType.centuryOfEra(), 1)
252             .with(DateTimeFieldType.halfdayOfDay(), 0)
253             .with(DateTimeFieldType.dayOfMonth(), 9);
254         try {
255             new YearMonth(1970, 6).compareTo(partial);
256             fail();
257         } catch (ClassCastException ex) {}
258     }
259     
260     //-----------------------------------------------------------------------
261     public void testIsEqual_YM() {
262         YearMonth test1 = new YearMonth(2005, 6);
263         YearMonth test1a = new YearMonth(2005, 6);
264         assertEquals(true, test1.isEqual(test1a));
265         assertEquals(true, test1a.isEqual(test1));
266         assertEquals(true, test1.isEqual(test1));
267         assertEquals(true, test1a.isEqual(test1a));
268         
269         YearMonth test2 = new YearMonth(2005, 7);
270         assertEquals(false, test1.isEqual(test2));
271         assertEquals(false, test2.isEqual(test1));
272         
273         YearMonth test3 = new YearMonth(2005, 7, GregorianChronology.getInstanceUTC());
274         assertEquals(false, test1.isEqual(test3));
275         assertEquals(false, test3.isEqual(test1));
276         assertEquals(true, test3.isEqual(test2));
277         
278         try {
279             new YearMonth(2005, 7).isEqual(null);
280             fail();
281         } catch (IllegalArgumentException ex) {}
282     }
283     
284     //-----------------------------------------------------------------------
285     public void testIsBefore_YM() {
286         YearMonth test1 = new YearMonth(2005, 6);
287         YearMonth test1a = new YearMonth(2005, 6);
288         assertEquals(false, test1.isBefore(test1a));
289         assertEquals(false, test1a.isBefore(test1));
290         assertEquals(false, test1.isBefore(test1));
291         assertEquals(false, test1a.isBefore(test1a));
292         
293         YearMonth test2 = new YearMonth(2005, 7);
294         assertEquals(true, test1.isBefore(test2));
295         assertEquals(false, test2.isBefore(test1));
296         
297         YearMonth test3 = new YearMonth(2005, 7, GregorianChronology.getInstanceUTC());
298         assertEquals(true, test1.isBefore(test3));
299         assertEquals(false, test3.isBefore(test1));
300         assertEquals(false, test3.isBefore(test2));
301         
302         try {
303             new YearMonth(2005, 7).isBefore(null);
304             fail();
305         } catch (IllegalArgumentException ex) {}
306     }
307     
308     //-----------------------------------------------------------------------
309     public void testIsAfter_YM() {
310         YearMonth test1 = new YearMonth(2005, 6);
311         YearMonth test1a = new YearMonth(2005, 6);
312         assertEquals(false, test1.isAfter(test1a));
313         assertEquals(false, test1a.isAfter(test1));
314         assertEquals(false, test1.isAfter(test1));
315         assertEquals(false, test1a.isAfter(test1a));
316         
317         YearMonth test2 = new YearMonth(2005, 7);
318         assertEquals(false, test1.isAfter(test2));
319         assertEquals(true, test2.isAfter(test1));
320         
321         YearMonth test3 = new YearMonth(2005, 7, GregorianChronology.getInstanceUTC());
322         assertEquals(false, test1.isAfter(test3));
323         assertEquals(true, test3.isAfter(test1));
324         assertEquals(false, test3.isAfter(test2));
325         
326         try {
327             new YearMonth(2005, 7).isAfter(null);
328             fail();
329         } catch (IllegalArgumentException ex) {}
330     }
331     
332     //-----------------------------------------------------------------------
333     public void testWithChronologyRetainFields_Chrono() {
334         YearMonth base = new YearMonth(2005, 6, COPTIC_PARIS);
335         YearMonth test = base.withChronologyRetainFields(BUDDHIST_TOKYO);
336         check(base, 2005, 6);
337         assertEquals(COPTIC_UTC, base.getChronology());
338         check(test, 2005, 6);
339         assertEquals(BUDDHIST_UTC, test.getChronology());
340     }
341 
342     public void testWithChronologyRetainFields_sameChrono() {
343         YearMonth base = new YearMonth(2005, 6, COPTIC_PARIS);
344         YearMonth test = base.withChronologyRetainFields(COPTIC_TOKYO);
345         assertSame(base, test);
346     }
347 
348     public void testWithChronologyRetainFields_nullChrono() {
349         YearMonth base = new YearMonth(2005, 6, COPTIC_PARIS);
350         YearMonth test = base.withChronologyRetainFields(null);
351         check(base, 2005, 6);
352         assertEquals(COPTIC_UTC, base.getChronology());
353         check(test, 2005, 6);
354         assertEquals(ISO_UTC, test.getChronology());
355     }
356 
357     public void testWithChronologyRetainFields_invalidInNewChrono() {
358         YearMonth base = new YearMonth(2005, 13, COPTIC_UTC);
359         try {
360             base.withChronologyRetainFields(ISO_UTC);
361             fail();
362         } catch (IllegalArgumentException ex) {
363             // expected
364         }
365     }
366 
367     //-----------------------------------------------------------------------
368     public void testWithField() {
369         YearMonth test = new YearMonth(2004, 6);
370         YearMonth result = test.withField(DateTimeFieldType.year(), 2006);
371         
372         assertEquals(new YearMonth(2004, 6), test);
373         assertEquals(new YearMonth(2006, 6), result);
374     }
375 
376     public void testWithField_nullField() {
377         YearMonth test = new YearMonth(2004, 6);
378         try {
379             test.withField(null, 6);
380             fail();
381         } catch (IllegalArgumentException ex) {}
382     }
383 
384     public void testWithField_unknownField() {
385         YearMonth test = new YearMonth(2004, 6);
386         try {
387             test.withField(DateTimeFieldType.hourOfDay(), 6);
388             fail();
389         } catch (IllegalArgumentException ex) {}
390     }
391 
392     public void testWithField_same() {
393         YearMonth test = new YearMonth(2004, 6);
394         YearMonth result = test.withField(DateTimeFieldType.year(), 2004);
395         assertEquals(new YearMonth(2004, 6), test);
396         assertSame(test, result);
397     }
398 
399     //-----------------------------------------------------------------------
400     public void testWithFieldAdded() {
401         YearMonth test = new YearMonth(2004, 6);
402         YearMonth result = test.withFieldAdded(DurationFieldType.years(), 6);
403         
404         assertEquals(new YearMonth(2004, 6), test);
405         assertEquals(new YearMonth(2010, 6), result);
406     }
407 
408     public void testWithFieldAdded_nullField_zero() {
409         YearMonth test = new YearMonth(2004, 6);
410         try {
411             test.withFieldAdded(null, 0);
412             fail();
413         } catch (IllegalArgumentException ex) {}
414     }
415 
416     public void testWithFieldAdded_nullField_nonZero() {
417         YearMonth test = new YearMonth(2004, 6);
418         try {
419             test.withFieldAdded(null, 6);
420             fail();
421         } catch (IllegalArgumentException ex) {}
422     }
423 
424     public void testWithFieldAdded_zero() {
425         YearMonth test = new YearMonth(2004, 6);
426         YearMonth result = test.withFieldAdded(DurationFieldType.years(), 0);
427         assertSame(test, result);
428     }
429 
430     public void testWithFieldAdded_unknownField() {
431         YearMonth test = new YearMonth(2004, 6);
432         try {
433             test.withFieldAdded(DurationFieldType.hours(), 6);
434             fail();
435         } catch (IllegalArgumentException ex) {}
436     }
437 
438     //-----------------------------------------------------------------------
439     public void testPlus_RP() {
440         YearMonth test = new YearMonth(2002, 5, BuddhistChronology.getInstance());
441         YearMonth result = test.plus(new Period(1, 2, 3, 4, 5, 6, 7, 8));
442         YearMonth expected = new YearMonth(2003, 7, BuddhistChronology.getInstance());
443         assertEquals(expected, result);
444         
445         result = test.plus((ReadablePeriod) null);
446         assertSame(test, result);
447     }
448 
449     public void testPlusYears_int() {
450         YearMonth test = new YearMonth(2002, 5, BuddhistChronology.getInstance());
451         YearMonth result = test.plusYears(1);
452         YearMonth expected = new YearMonth(2003, 5, BuddhistChronology.getInstance());
453         assertEquals(expected, result);
454         
455         result = test.plusYears(0);
456         assertSame(test, result);
457     }
458 
459     public void testPlusMonths_int() {
460         YearMonth test = new YearMonth(2002, 5, BuddhistChronology.getInstance());
461         YearMonth result = test.plusMonths(1);
462         YearMonth expected = new YearMonth(2002, 6, BuddhistChronology.getInstance());
463         assertEquals(expected, result);
464         
465         result = test.plusMonths(0);
466         assertSame(test, result);
467     }
468 
469     //-----------------------------------------------------------------------
470     public void testMinus_RP() {
471         YearMonth test = new YearMonth(2002, 5, BuddhistChronology.getInstance());
472         YearMonth result = test.minus(new Period(1, 1, 1, 1, 1, 1, 1, 1));
473         YearMonth expected = new YearMonth(2001, 4, BuddhistChronology.getInstance());
474         assertEquals(expected, result);
475         
476         result = test.minus((ReadablePeriod) null);
477         assertSame(test, result);
478     }
479 
480     public void testMinusYears_int() {
481         YearMonth test = new YearMonth(2002, 5, BuddhistChronology.getInstance());
482         YearMonth result = test.minusYears(1);
483         YearMonth expected = new YearMonth(2001, 5, BuddhistChronology.getInstance());
484         assertEquals(expected, result);
485         
486         result = test.minusYears(0);
487         assertSame(test, result);
488     }
489 
490     public void testMinusMonths_int() {
491         YearMonth test = new YearMonth(2002, 5, BuddhistChronology.getInstance());
492         YearMonth result = test.minusMonths(1);
493         YearMonth expected = new YearMonth(2002, 4, BuddhistChronology.getInstance());
494         assertEquals(expected, result);
495         
496         result = test.minusMonths(0);
497         assertSame(test, result);
498     }
499 
500     //-----------------------------------------------------------------------
501     public void testToLocalDate() {
502         YearMonth base = new YearMonth(2005, 6, COPTIC_UTC);
503         LocalDate test = base.toLocalDate(9);
504         assertEquals(new LocalDate(2005, 6, 9, COPTIC_UTC), test);
505         try {
506             base.toLocalDate(0);
507             fail();
508         } catch (IllegalArgumentException ex) {}
509     }
510 
511     //-----------------------------------------------------------------------
512     public void testToDateTime_RI() {
513         YearMonth base = new YearMonth(2005, 6, COPTIC_PARIS);
514         DateTime dt = new DateTime(2002, 1, 3, 4, 5, 6, 7);
515         
516         DateTime test = base.toDateTime(dt);
517         check(base, 2005, 6);
518         DateTime expected = dt;
519         expected = expected.year().setCopy(2005);
520         expected = expected.monthOfYear().setCopy(6);
521         assertEquals(expected, test);
522     }
523 
524     public void testToDateTime_nullRI() {
525         YearMonth base = new YearMonth(2005, 6);
526         DateTime dt = new DateTime(2002, 1, 3, 4, 5, 6, 7);
527         DateTimeUtils.setCurrentMillisFixed(dt.getMillis());
528         
529         DateTime test = base.toDateTime((ReadableInstant) null);
530         check(base, 2005, 6);
531         DateTime expected = dt;
532         expected = expected.year().setCopy(2005);
533         expected = expected.monthOfYear().setCopy(6);
534         assertEquals(expected, test);
535     }
536 
537     //-----------------------------------------------------------------------
538     public void testToInterval() {
539         YearMonth base = new YearMonth(2005, 6, COPTIC_PARIS); // PARIS irrelevant
540         Interval test = base.toInterval();
541         check(base, 2005, 6);
542         DateTime start = new DateTime(2005, 6, 1, 0, 0, COPTIC_LONDON);
543         DateTime end = new DateTime(2005, 7, 1, 0, 0, COPTIC_LONDON);
544         Interval expected = new Interval(start, end);
545         assertEquals(expected, test);
546     }
547 
548     //-----------------------------------------------------------------------
549     public void testToInterval_Zone() {
550         YearMonth base = new YearMonth(2005, 6, COPTIC_PARIS); // PARIS irrelevant
551         Interval test = base.toInterval(TOKYO);
552         check(base, 2005, 6);
553         DateTime start = new DateTime(2005, 6, 1, 0, 0, COPTIC_TOKYO);
554         DateTime end = new DateTime(2005, 7, 1, 0, 0, COPTIC_TOKYO);
555         Interval expected = new Interval(start, end);
556         assertEquals(expected, test);
557     }
558 
559     public void testToInterval_nullZone() {
560         YearMonth base = new YearMonth(2005, 6, COPTIC_PARIS); // PARIS irrelevant
561         Interval test = base.toInterval(null);
562         check(base, 2005, 6);
563         DateTime start = new DateTime(2005, 6, 1, 0, 0, COPTIC_LONDON);
564         DateTime end = new DateTime(2005, 7, 1, 0, 0, COPTIC_LONDON);
565         Interval expected = new Interval(start, end);
566         assertEquals(expected, test);
567     }
568 
569     //-----------------------------------------------------------------------
570     public void testWithers() {
571         YearMonth test = new YearMonth(1970, 6);
572         check(test.withYear(2000), 2000, 6);
573         check(test.withMonthOfYear(2), 1970, 2);
574         try {
575             test.withMonthOfYear(0);
576             fail();
577         } catch (IllegalArgumentException ex) {}
578         try {
579             test.withMonthOfYear(13);
580             fail();
581         } catch (IllegalArgumentException ex) {}
582     }
583 
584     //-----------------------------------------------------------------------
585     public void testProperty() {
586         YearMonth test = new YearMonth(2005, 6);
587         assertEquals(test.year(), test.property(DateTimeFieldType.year()));
588         assertEquals(test.monthOfYear(), test.property(DateTimeFieldType.monthOfYear()));
589         try {
590             test.property(DateTimeFieldType.millisOfDay());
591             fail();
592         } catch (IllegalArgumentException ex) {}
593         try {
594             test.property(null);
595             fail();
596         } catch (IllegalArgumentException ex) {}
597     }
598 
599     //-----------------------------------------------------------------------
600     public void testSerialization() throws Exception {
601         YearMonth test = new YearMonth(1972, 6, COPTIC_PARIS);
602         
603         ByteArrayOutputStream baos = new ByteArrayOutputStream();
604         ObjectOutputStream oos = new ObjectOutputStream(baos);
605         oos.writeObject(test);
606         byte[] bytes = baos.toByteArray();
607         oos.close();
608         
609         ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
610         ObjectInputStream ois = new ObjectInputStream(bais);
611         YearMonth result = (YearMonth) ois.readObject();
612         ois.close();
613         
614         assertEquals(test, result);
615         assertTrue(Arrays.equals(test.getValues(), result.getValues()));
616         assertTrue(Arrays.equals(test.getFields(), result.getFields()));
617         assertEquals(test.getChronology(), result.getChronology());
618     }
619 
620     //-----------------------------------------------------------------------
621     public void testToString() {
622         YearMonth test = new YearMonth(2002, 6);
623         assertEquals("2002-06", test.toString());
624     }
625 
626     //-----------------------------------------------------------------------
627     public void testToString_String() {
628         YearMonth test = new YearMonth(2002, 6);
629         assertEquals("2002 \ufffd\ufffd", test.toString("yyyy HH"));
630         assertEquals("2002-06", test.toString((String) null));
631     }
632 
633     //-----------------------------------------------------------------------
634     public void testToString_String_Locale() {
635         YearMonth test = new YearMonth(2002, 6);
636         assertEquals("\ufffd \ufffd/6", test.toString("EEE d/M", Locale.ENGLISH));
637         assertEquals("\ufffd \ufffd/6", test.toString("EEE d/M", Locale.FRENCH));
638         assertEquals("2002-06", test.toString(null, Locale.ENGLISH));
639         assertEquals("\ufffd \ufffd/6", test.toString("EEE d/M", null));
640         assertEquals("2002-06", test.toString(null, null));
641     }
642 
643     //-----------------------------------------------------------------------
644     public void testToString_DTFormatter() {
645         YearMonth test = new YearMonth(2002, 6);
646         assertEquals("2002 \ufffd\ufffd", test.toString(DateTimeFormat.forPattern("yyyy HH")));
647         assertEquals("2002-06", test.toString((DateTimeFormatter) null));
648     }
649 
650     //-----------------------------------------------------------------------
651     private void check(YearMonth test, int year, int month) {
652         assertEquals(year, test.getYear());
653         assertEquals(month, test.getMonthOfYear());
654     }
655 }