1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.joda.time;
17
18 import java.util.Calendar;
19 import java.util.Date;
20 import java.util.GregorianCalendar;
21
22 import junit.framework.TestCase;
23 import junit.framework.TestSuite;
24
25 import org.joda.time.chrono.BuddhistChronology;
26 import org.joda.time.chrono.CopticChronology;
27 import org.joda.time.chrono.GregorianChronology;
28 import org.joda.time.chrono.ISOChronology;
29
30 /***
31 * This class is a Junit unit test for YearMonthDay.
32 *
33 * @author Stephen Colebourne
34 */
35 public class TestYearMonthDay_Constructors extends TestCase {
36
37 private static final DateTimeZone PARIS = DateTimeZone.forID("Europe/Paris");
38 private static final DateTimeZone LONDON = DateTimeZone.forID("Europe/London");
39 private static final Chronology COPTIC_UTC = CopticChronology.getInstanceUTC();
40 private static final Chronology ISO_UTC = ISOChronology.getInstanceUTC();
41 private static final Chronology BUDDHIST_UTC = BuddhistChronology.getInstanceUTC();
42 private static final Chronology GREGORIAN_UTC = GregorianChronology.getInstanceUTC();
43 private static final Chronology GREGORIAN_PARIS = GregorianChronology.getInstance(PARIS);
44
45 private long TEST_TIME_NOW =
46 (31L + 28L + 31L + 30L + 31L + 9L -1L) * DateTimeConstants.MILLIS_PER_DAY;
47
48 private long TEST_TIME1 =
49 (31L + 28L + 31L + 6L -1L) * DateTimeConstants.MILLIS_PER_DAY
50 + 12L * DateTimeConstants.MILLIS_PER_HOUR
51 + 24L * DateTimeConstants.MILLIS_PER_MINUTE;
52
53 private long TEST_TIME2 =
54 (365L + 31L + 28L + 31L + 30L + 7L -1L) * DateTimeConstants.MILLIS_PER_DAY
55 + 14L * DateTimeConstants.MILLIS_PER_HOUR
56 + 28L * DateTimeConstants.MILLIS_PER_MINUTE;
57
58 private DateTimeZone zone = null;
59
60 public static void main(String[] args) {
61 junit.textui.TestRunner.run(suite());
62 }
63
64 public static TestSuite suite() {
65 return new TestSuite(TestYearMonthDay_Constructors.class);
66 }
67
68 public TestYearMonthDay_Constructors(String name) {
69 super(name);
70 }
71
72 protected void setUp() throws Exception {
73 DateTimeUtils.setCurrentMillisFixed(TEST_TIME_NOW);
74 zone = DateTimeZone.getDefault();
75 DateTimeZone.setDefault(LONDON);
76 }
77
78 protected void tearDown() throws Exception {
79 DateTimeUtils.setCurrentMillisSystem();
80 DateTimeZone.setDefault(zone);
81 zone = null;
82 }
83
84
85 public void testFactory_FromCalendarFields() throws Exception {
86 GregorianCalendar cal = new GregorianCalendar(1970, 1, 3, 4, 5, 6);
87 cal.set(Calendar.MILLISECOND, 7);
88 YearMonthDay expected = new YearMonthDay(1970, 2, 3);
89 assertEquals(expected, YearMonthDay.fromCalendarFields(cal));
90 try {
91 YearMonthDay.fromCalendarFields(null);
92 fail();
93 } catch (IllegalArgumentException ex) {}
94 }
95
96
97 public void testFactory_FromDateFields() throws Exception {
98 GregorianCalendar cal = new GregorianCalendar(1970, 1, 3, 4, 5, 6);
99 cal.set(Calendar.MILLISECOND, 7);
100 YearMonthDay expected = new YearMonthDay(1970, 2, 3);
101 assertEquals(expected, YearMonthDay.fromDateFields(cal.getTime()));
102 try {
103 YearMonthDay.fromDateFields(null);
104 fail();
105 } catch (IllegalArgumentException ex) {}
106 }
107
108
109 /***
110 * Test constructor ()
111 */
112 public void testConstructor() throws Throwable {
113 YearMonthDay test = new YearMonthDay();
114 assertEquals(ISO_UTC, test.getChronology());
115 assertEquals(1970, test.getYear());
116 assertEquals(6, test.getMonthOfYear());
117 assertEquals(9, test.getDayOfMonth());
118 }
119
120 /***
121 * Test constructor (DateTimeZone)
122 */
123 public void testConstructor_DateTimeZone() throws Throwable {
124 DateTime dt = new DateTime(2005, 6, 8, 23, 59, 0, 0, LONDON);
125 DateTimeUtils.setCurrentMillisFixed(dt.getMillis());
126
127
128 YearMonthDay test = new YearMonthDay(LONDON);
129 assertEquals(ISO_UTC, test.getChronology());
130 assertEquals(2005, test.getYear());
131 assertEquals(6, test.getMonthOfYear());
132 assertEquals(8, test.getDayOfMonth());
133
134 test = new YearMonthDay(PARIS);
135 assertEquals(ISO_UTC, test.getChronology());
136 assertEquals(2005, test.getYear());
137 assertEquals(6, test.getMonthOfYear());
138 assertEquals(9, test.getDayOfMonth());
139 }
140
141 /***
142 * Test constructor (DateTimeZone=null)
143 */
144 public void testConstructor_nullDateTimeZone() throws Throwable {
145 DateTime dt = new DateTime(2005, 6, 8, 23, 59, 0, 0, LONDON);
146 DateTimeUtils.setCurrentMillisFixed(dt.getMillis());
147
148
149 YearMonthDay test = new YearMonthDay((DateTimeZone) null);
150 assertEquals(ISO_UTC, test.getChronology());
151 assertEquals(2005, test.getYear());
152 assertEquals(6, test.getMonthOfYear());
153 assertEquals(8, test.getDayOfMonth());
154 }
155
156 /***
157 * Test constructor (Chronology)
158 */
159 public void testConstructor_Chronology() throws Throwable {
160 YearMonthDay test = new YearMonthDay(GREGORIAN_PARIS);
161 assertEquals(GREGORIAN_UTC, test.getChronology());
162 assertEquals(1970, test.getYear());
163 assertEquals(6, test.getMonthOfYear());
164 assertEquals(9, test.getDayOfMonth());
165 }
166
167 /***
168 * Test constructor (Chronology=null)
169 */
170 public void testConstructor_nullChronology() throws Throwable {
171 YearMonthDay test = new YearMonthDay((Chronology) null);
172 assertEquals(ISO_UTC, test.getChronology());
173 assertEquals(1970, test.getYear());
174 assertEquals(6, test.getMonthOfYear());
175 assertEquals(9, test.getDayOfMonth());
176 }
177
178
179 /***
180 * Test constructor (long)
181 */
182 public void testConstructor_long1() throws Throwable {
183 YearMonthDay test = new YearMonthDay(TEST_TIME1);
184 assertEquals(ISO_UTC, test.getChronology());
185 assertEquals(1970, test.getYear());
186 assertEquals(4, test.getMonthOfYear());
187 assertEquals(6, test.getDayOfMonth());
188 }
189
190 /***
191 * Test constructor (long)
192 */
193 public void testConstructor_long2() throws Throwable {
194 YearMonthDay test = new YearMonthDay(TEST_TIME2);
195 assertEquals(ISO_UTC, test.getChronology());
196 assertEquals(1971, test.getYear());
197 assertEquals(5, test.getMonthOfYear());
198 assertEquals(7, test.getDayOfMonth());
199 }
200
201 /***
202 * Test constructor (long, Chronology)
203 */
204 public void testConstructor_long1_Chronology() throws Throwable {
205 YearMonthDay test = new YearMonthDay(TEST_TIME1, GREGORIAN_PARIS);
206 assertEquals(GREGORIAN_UTC, test.getChronology());
207 assertEquals(1970, test.getYear());
208 assertEquals(4, test.getMonthOfYear());
209 assertEquals(6, test.getDayOfMonth());
210 }
211
212 /***
213 * Test constructor (long, Chronology)
214 */
215 public void testConstructor_long2_Chronology() throws Throwable {
216 YearMonthDay test = new YearMonthDay(TEST_TIME2, GREGORIAN_PARIS);
217 assertEquals(GREGORIAN_UTC, test.getChronology());
218 assertEquals(1971, test.getYear());
219 assertEquals(5, test.getMonthOfYear());
220 assertEquals(7, test.getDayOfMonth());
221 }
222
223 /***
224 * Test constructor (long, Chronology=null)
225 */
226 public void testConstructor_long_nullChronology() throws Throwable {
227 YearMonthDay test = new YearMonthDay(TEST_TIME1, null);
228 assertEquals(ISO_UTC, test.getChronology());
229 assertEquals(1970, test.getYear());
230 assertEquals(4, test.getMonthOfYear());
231 assertEquals(6, test.getDayOfMonth());
232 }
233
234
235 public void testConstructor_Object() throws Throwable {
236 Date date = new Date(TEST_TIME1);
237 YearMonthDay test = new YearMonthDay(date);
238 assertEquals(ISO_UTC, test.getChronology());
239 assertEquals(1970, test.getYear());
240 assertEquals(4, test.getMonthOfYear());
241 assertEquals(6, test.getDayOfMonth());
242 }
243
244 public void testConstructor_nullObject() throws Throwable {
245 YearMonthDay test = new YearMonthDay((Object) null);
246 assertEquals(ISO_UTC, test.getChronology());
247 assertEquals(1970, test.getYear());
248 assertEquals(6, test.getMonthOfYear());
249 assertEquals(9, test.getDayOfMonth());
250 }
251
252 public void testConstructor_ObjectString1() throws Throwable {
253 YearMonthDay test = new YearMonthDay("1972-12-03");
254 assertEquals(ISO_UTC, test.getChronology());
255 assertEquals(1972, test.getYear());
256 assertEquals(12, test.getMonthOfYear());
257 assertEquals(3, test.getDayOfMonth());
258 }
259
260 public void testConstructor_ObjectString2() throws Throwable {
261 YearMonthDay test = new YearMonthDay("1972-12-03T+14:00");
262 assertEquals(ISO_UTC, test.getChronology());
263 assertEquals(1972, test.getYear());
264 assertEquals(12, test.getMonthOfYear());
265 assertEquals(2, test.getDayOfMonth());
266 }
267
268 public void testConstructor_ObjectString3() throws Throwable {
269 YearMonthDay test = new YearMonthDay("1972-12-03T10:20:30.040");
270 assertEquals(ISO_UTC, test.getChronology());
271 assertEquals(1972, test.getYear());
272 assertEquals(12, test.getMonthOfYear());
273 assertEquals(3, test.getDayOfMonth());
274 }
275
276 public void testConstructor_ObjectString4() throws Throwable {
277 YearMonthDay test = new YearMonthDay("1972-12-03T10:20:30.040+14:00");
278 assertEquals(ISO_UTC, test.getChronology());
279 assertEquals(1972, test.getYear());
280 assertEquals(12, test.getMonthOfYear());
281 assertEquals(2, test.getDayOfMonth());
282 }
283
284 public void testConstructor_ObjectString5() throws Throwable {
285 YearMonthDay test = new YearMonthDay("10");
286 assertEquals(ISO_UTC, test.getChronology());
287 assertEquals(10, test.getYear());
288 assertEquals(1, test.getMonthOfYear());
289 assertEquals(1, test.getDayOfMonth());
290 }
291
292 public void testConstructor_ObjectStringEx1() throws Throwable {
293 try {
294 new YearMonthDay("T10:20:30.040");
295 fail();
296 } catch (IllegalArgumentException ex) {
297
298 }
299 }
300
301 public void testConstructor_ObjectStringEx2() throws Throwable {
302 try {
303 new YearMonthDay("T10:20:30.040+14:00");
304 fail();
305 } catch (IllegalArgumentException ex) {
306
307 }
308 }
309
310 public void testConstructor_ObjectStringEx3() throws Throwable {
311 try {
312 new YearMonthDay("10:20:30.040");
313 fail();
314 } catch (IllegalArgumentException ex) {
315
316 }
317 }
318
319 public void testConstructor_ObjectStringEx4() throws Throwable {
320 try {
321 new YearMonthDay("10:20:30.040+14:00");
322 fail();
323 } catch (IllegalArgumentException ex) {
324
325 }
326 }
327
328
329 /***
330 * Test constructor (Object, Chronology)
331 */
332 public void testConstructor_Object_Chronology() throws Throwable {
333 Date date = new Date(TEST_TIME1);
334 YearMonthDay test = new YearMonthDay(date, GREGORIAN_PARIS);
335 assertEquals(GREGORIAN_UTC, test.getChronology());
336 assertEquals(1970, test.getYear());
337 assertEquals(4, test.getMonthOfYear());
338 assertEquals(6, test.getDayOfMonth());
339 }
340
341 /***
342 * Test constructor (Object=null, Chronology)
343 */
344 public void testConstructor_nullObject_Chronology() throws Throwable {
345 YearMonthDay test = new YearMonthDay((Object) null, GREGORIAN_PARIS);
346 assertEquals(GREGORIAN_UTC, test.getChronology());
347 assertEquals(1970, test.getYear());
348 assertEquals(6, test.getMonthOfYear());
349 assertEquals(9, test.getDayOfMonth());
350 }
351
352 /***
353 * Test constructor (Object, Chronology=null)
354 */
355 public void testConstructor_Object_nullChronology() throws Throwable {
356 Date date = new Date(TEST_TIME1);
357 YearMonthDay test = new YearMonthDay(date, null);
358 assertEquals(ISO_UTC, test.getChronology());
359 assertEquals(1970, test.getYear());
360 assertEquals(4, test.getMonthOfYear());
361 assertEquals(6, test.getDayOfMonth());
362 }
363
364 /***
365 * Test constructor (Object=null, Chronology=null)
366 */
367 public void testConstructor_nullObject_nullChronology() throws Throwable {
368 YearMonthDay test = new YearMonthDay((Object) null, null);
369 assertEquals(ISO_UTC, test.getChronology());
370 assertEquals(1970, test.getYear());
371 assertEquals(6, test.getMonthOfYear());
372 assertEquals(9, test.getDayOfMonth());
373 }
374
375
376 /***
377 * Test constructor (int, int, int)
378 */
379 public void testConstructor_int_int_int() throws Throwable {
380 YearMonthDay test = new YearMonthDay(1970, 6, 9);
381 assertEquals(ISO_UTC, test.getChronology());
382 assertEquals(1970, test.getYear());
383 assertEquals(6, test.getMonthOfYear());
384 assertEquals(9, test.getDayOfMonth());
385 try {
386 new YearMonthDay(Integer.MIN_VALUE, 6, 9);
387 fail();
388 } catch (IllegalArgumentException ex) {}
389 try {
390 new YearMonthDay(Integer.MAX_VALUE, 6, 9);
391 fail();
392 } catch (IllegalArgumentException ex) {}
393 try {
394 new YearMonthDay(1970, 0, 9);
395 fail();
396 } catch (IllegalArgumentException ex) {}
397 try {
398 new YearMonthDay(1970, 13, 9);
399 fail();
400 } catch (IllegalArgumentException ex) {}
401 try {
402 new YearMonthDay(1970, 6, 0);
403 fail();
404 } catch (IllegalArgumentException ex) {}
405 try {
406 new YearMonthDay(1970, 6, 31);
407 fail();
408 } catch (IllegalArgumentException ex) {}
409 new YearMonthDay(1970, 7, 31);
410 try {
411 new YearMonthDay(1970, 7, 32);
412 fail();
413 } catch (IllegalArgumentException ex) {}
414 }
415
416 /***
417 * Test constructor (int, int, int, Chronology)
418 */
419 public void testConstructor_int_int_int_Chronology() throws Throwable {
420 YearMonthDay test = new YearMonthDay(1970, 6, 9, GREGORIAN_PARIS);
421 assertEquals(GREGORIAN_UTC, test.getChronology());
422 assertEquals(1970, test.getYear());
423 assertEquals(6, test.getMonthOfYear());
424 assertEquals(9, test.getDayOfMonth());
425 try {
426 new YearMonthDay(Integer.MIN_VALUE, 6, 9, GREGORIAN_PARIS);
427 fail();
428 } catch (IllegalArgumentException ex) {}
429 try {
430 new YearMonthDay(Integer.MAX_VALUE, 6, 9, GREGORIAN_PARIS);
431 fail();
432 } catch (IllegalArgumentException ex) {}
433 try {
434 new YearMonthDay(1970, 0, 9, GREGORIAN_PARIS);
435 fail();
436 } catch (IllegalArgumentException ex) {}
437 try {
438 new YearMonthDay(1970, 13, 9, GREGORIAN_PARIS);
439 fail();
440 } catch (IllegalArgumentException ex) {}
441 try {
442 new YearMonthDay(1970, 6, 0, GREGORIAN_PARIS);
443 fail();
444 } catch (IllegalArgumentException ex) {}
445 try {
446 new YearMonthDay(1970, 6, 31, GREGORIAN_PARIS);
447 fail();
448 } catch (IllegalArgumentException ex) {}
449 new YearMonthDay(1970, 7, 31, GREGORIAN_PARIS);
450 try {
451 new YearMonthDay(1970, 7, 32, GREGORIAN_PARIS);
452 fail();
453 } catch (IllegalArgumentException ex) {}
454 }
455
456 /***
457 * Test constructor (int, int, int, Chronology=null)
458 */
459 public void testConstructor_int_int_int_nullChronology() throws Throwable {
460 YearMonthDay test = new YearMonthDay(1970, 6, 9, null);
461 assertEquals(ISO_UTC, test.getChronology());
462 assertEquals(1970, test.getYear());
463 assertEquals(6, test.getMonthOfYear());
464 assertEquals(9, test.getDayOfMonth());
465 }
466
467 }