001 /*
002 * Copyright 2001-2005 Stephen Colebourne
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016 package org.joda.time;
017
018 import java.util.Arrays;
019
020 import junit.framework.TestCase;
021 import junit.framework.TestSuite;
022
023 import org.joda.time.chrono.GregorianChronology;
024 import org.joda.time.chrono.ISOChronology;
025
026 /**
027 * This class is a Junit unit test for Partial.
028 *
029 * @author Stephen Colebourne
030 */
031 public class TestPartial_Constructors extends TestCase {
032
033 private static final DateTimeZone LONDON = DateTimeZone.forID("Europe/London");
034 private static final DateTimeZone PARIS = DateTimeZone.forID("Europe/Paris");
035 private static final Chronology ISO_UTC = ISOChronology.getInstanceUTC();
036 private static final Chronology GREGORIAN_PARIS = GregorianChronology.getInstance(PARIS);
037 private static final Chronology GREGORIAN_UTC = GregorianChronology.getInstanceUTC();
038 private static final int OFFSET = 1;
039
040 private long TEST_TIME_NOW =
041 10L * DateTimeConstants.MILLIS_PER_HOUR
042 + 20L * DateTimeConstants.MILLIS_PER_MINUTE
043 + 30L * DateTimeConstants.MILLIS_PER_SECOND
044 + 40L;
045
046 private long TEST_TIME1 =
047 1L * DateTimeConstants.MILLIS_PER_HOUR
048 + 2L * DateTimeConstants.MILLIS_PER_MINUTE
049 + 3L * DateTimeConstants.MILLIS_PER_SECOND
050 + 4L;
051
052 private long TEST_TIME2 =
053 1L * DateTimeConstants.MILLIS_PER_DAY
054 + 5L * DateTimeConstants.MILLIS_PER_HOUR
055 + 6L * DateTimeConstants.MILLIS_PER_MINUTE
056 + 7L * DateTimeConstants.MILLIS_PER_SECOND
057 + 8L;
058
059 private DateTimeZone zone = null;
060
061 public static void main(String[] args) {
062 junit.textui.TestRunner.run(suite());
063 }
064
065 public static TestSuite suite() {
066 return new TestSuite(TestPartial_Constructors.class);
067 }
068
069 public TestPartial_Constructors(String name) {
070 super(name);
071 }
072
073 protected void setUp() throws Exception {
074 DateTimeUtils.setCurrentMillisFixed(TEST_TIME_NOW);
075 zone = DateTimeZone.getDefault();
076 DateTimeZone.setDefault(LONDON);
077 }
078
079 protected void tearDown() throws Exception {
080 DateTimeUtils.setCurrentMillisSystem();
081 DateTimeZone.setDefault(zone);
082 zone = null;
083 }
084
085 //-----------------------------------------------------------------------
086 /**
087 * Test constructor
088 */
089 public void testConstructor() throws Throwable {
090 Partial test = new Partial();
091 assertEquals(ISO_UTC, test.getChronology());
092 assertEquals(0, test.size());
093 }
094
095 //-----------------------------------------------------------------------
096 /**
097 * Test constructor
098 */
099 public void testConstructor_Chrono() throws Throwable {
100 Partial test = new Partial((Chronology) null);
101 assertEquals(ISO_UTC, test.getChronology());
102 assertEquals(0, test.size());
103
104 test = new Partial(GREGORIAN_PARIS);
105 assertEquals(GREGORIAN_UTC, test.getChronology());
106 assertEquals(0, test.size());
107 }
108
109 //-----------------------------------------------------------------------
110 /**
111 * Test constructor
112 */
113 public void testConstructor_Type_int() throws Throwable {
114 Partial test = new Partial(DateTimeFieldType.dayOfYear(), 4);
115 assertEquals(ISO_UTC, test.getChronology());
116 assertEquals(1, test.size());
117 assertEquals(4, test.getValue(0));
118 assertEquals(4, test.get(DateTimeFieldType.dayOfYear()));
119 assertEquals(true, test.isSupported(DateTimeFieldType.dayOfYear()));
120 }
121
122 /**
123 * Test constructor
124 */
125 public void testConstructorEx1_Type_int() throws Throwable {
126 try {
127 new Partial(null, 4);
128 fail();
129 } catch (IllegalArgumentException ex) {
130 assertMessageContains(ex, "must not be null");
131 }
132 }
133
134 /**
135 * Test constructor
136 */
137 public void testConstructorEx2_Type_int() throws Throwable {
138 try {
139 new Partial(DateTimeFieldType.dayOfYear(), 0);
140 fail();
141 } catch (IllegalArgumentException ex) {
142 // expected
143 }
144 }
145
146 //-----------------------------------------------------------------------
147 /**
148 * Test constructor
149 */
150 public void testConstructor_Type_int_Chrono() throws Throwable {
151 Partial test = new Partial(DateTimeFieldType.dayOfYear(), 4, GREGORIAN_PARIS);
152 assertEquals(GREGORIAN_UTC, test.getChronology());
153 assertEquals(1, test.size());
154 assertEquals(4, test.getValue(0));
155 assertEquals(4, test.get(DateTimeFieldType.dayOfYear()));
156 assertEquals(true, test.isSupported(DateTimeFieldType.dayOfYear()));
157 }
158
159 /**
160 * Test constructor
161 */
162 public void testConstructorEx_Type_int_Chrono() throws Throwable {
163 try {
164 new Partial(null, 4, ISO_UTC);
165 fail();
166 } catch (IllegalArgumentException ex) {
167 assertMessageContains(ex, "must not be null");
168 }
169 }
170
171 /**
172 * Test constructor
173 */
174 public void testConstructorEx2_Type_int_Chrono() throws Throwable {
175 try {
176 new Partial(DateTimeFieldType.dayOfYear(), 0, ISO_UTC);
177 fail();
178 } catch (IllegalArgumentException ex) {
179 // expected
180 }
181 }
182
183 //-----------------------------------------------------------------------
184 /**
185 * Test constructor
186 */
187 public void testConstructor_TypeArray_intArray() throws Throwable {
188 DateTimeFieldType[] types = new DateTimeFieldType[] {
189 DateTimeFieldType.year(),
190 DateTimeFieldType.dayOfYear()
191 };
192 int[] values = new int[] {2005, 33};
193 Partial test = new Partial(types, values);
194 assertEquals(ISO_UTC, test.getChronology());
195 assertEquals(2, test.size());
196 assertEquals(2005, test.getValue(0));
197 assertEquals(2005, test.get(DateTimeFieldType.year()));
198 assertEquals(true, test.isSupported(DateTimeFieldType.year()));
199 assertEquals(33, test.getValue(1));
200 assertEquals(33, test.get(DateTimeFieldType.dayOfYear()));
201 assertEquals(true, test.isSupported(DateTimeFieldType.dayOfYear()));
202 assertEquals(true, Arrays.equals(test.getFieldTypes(), types));
203 assertEquals(true, Arrays.equals(test.getValues(), values));
204 }
205
206 /**
207 * Test constructor
208 */
209 public void testConstructor2_TypeArray_intArray() throws Throwable {
210 DateTimeFieldType[] types = new DateTimeFieldType[0];
211 int[] values = new int[0];
212 Partial test = new Partial(types, values);
213 assertEquals(ISO_UTC, test.getChronology());
214 assertEquals(0, test.size());
215 }
216
217 /**
218 * Test constructor
219 */
220 public void testConstructorEx1_TypeArray_intArray() throws Throwable {
221 try {
222 new Partial((DateTimeFieldType[]) null, new int[] {1});
223 fail();
224 } catch (IllegalArgumentException ex) {
225 assertMessageContains(ex, "must not be null");
226 }
227 }
228
229 /**
230 * Test constructor
231 */
232 public void testConstructorEx3_TypeArray_intArray() throws Throwable {
233 try {
234 new Partial(new DateTimeFieldType[] {DateTimeFieldType.dayOfYear()}, null);
235 fail();
236 } catch (IllegalArgumentException ex) {
237 assertMessageContains(ex, "must not be null");
238 }
239 }
240
241 /**
242 * Test constructor
243 */
244 public void testConstructorEx5_TypeArray_intArray() throws Throwable {
245 try {
246 new Partial(new DateTimeFieldType[] {DateTimeFieldType.dayOfYear()}, new int[2]);
247 fail();
248 } catch (IllegalArgumentException ex) {
249 assertMessageContains(ex, "same length");
250 }
251 }
252
253 /**
254 * Test constructor
255 */
256 public void testConstructorEx6_TypeArray_intArray() throws Throwable {
257 try {
258 new Partial(new DateTimeFieldType[] {null, DateTimeFieldType.dayOfYear()}, new int[2]);
259 fail();
260 } catch (IllegalArgumentException ex) {
261 assertMessageContains(ex, "contain null");
262 }
263 try {
264 new Partial(new DateTimeFieldType[] {DateTimeFieldType.dayOfYear(), null}, new int[2]);
265 fail();
266 } catch (IllegalArgumentException ex) {
267 assertMessageContains(ex, "contain null");
268 }
269 }
270
271 /**
272 * Test constructor
273 */
274 public void testConstructorEx7_TypeArray_intArray() throws Throwable {
275 int[] values = new int[] {1, 1, 1};
276 DateTimeFieldType[] types = new DateTimeFieldType[] {
277 DateTimeFieldType.dayOfMonth(), DateTimeFieldType.year(), DateTimeFieldType.monthOfYear() };
278 try {
279 new Partial(types, values);
280 fail();
281 } catch (IllegalArgumentException ex) {
282 assertMessageContains(ex, "must be in order", "largest-smallest");
283 }
284
285 types = new DateTimeFieldType[] {
286 DateTimeFieldType.year(), DateTimeFieldType.dayOfMonth(), DateTimeFieldType.monthOfYear() };
287 try {
288 new Partial(types, values);
289 fail();
290 } catch (IllegalArgumentException ex) {
291 assertMessageContains(ex, "must be in order", "largest-smallest");
292 }
293
294 types = new DateTimeFieldType[] {
295 DateTimeFieldType.year(), DateTimeFieldType.era(), DateTimeFieldType.monthOfYear() };
296 try {
297 new Partial(types, values);
298 fail();
299 } catch (IllegalArgumentException ex) {
300 assertMessageContains(ex, "must be in order", "largest-smallest");
301 }
302
303 types = new DateTimeFieldType[] {
304 DateTimeFieldType.year(), DateTimeFieldType.dayOfMonth(), DateTimeFieldType.era() };
305 try {
306 new Partial(types, values);
307 fail();
308 } catch (IllegalArgumentException ex) {
309 assertMessageContains(ex, "must be in order", "largest-smallest");
310 }
311
312 types = new DateTimeFieldType[] {
313 DateTimeFieldType.year(), DateTimeFieldType.dayOfMonth(), DateTimeFieldType.dayOfYear() };
314 try {
315 new Partial(types, values);
316 fail();
317 } catch (IllegalArgumentException ex) {
318 assertMessageContains(ex, "must be in order", "largest-smallest");
319 }
320
321 types = new DateTimeFieldType[] {
322 DateTimeFieldType.yearOfEra(), DateTimeFieldType.year(), DateTimeFieldType.dayOfYear() };
323 try {
324 new Partial(types, values);
325 fail();
326 } catch (IllegalArgumentException ex) {
327 assertMessageContains(ex, "must be in order", "largest-smallest");
328 }
329 }
330
331 /**
332 * Test constructor
333 */
334 public void testConstructorEx8_TypeArray_intArray() throws Throwable {
335 int[] values = new int[] {1, 1, 1};
336 DateTimeFieldType[] types = new DateTimeFieldType[] {
337 DateTimeFieldType.era(), DateTimeFieldType.year(), DateTimeFieldType.year() };
338 try {
339 new Partial(types, values);
340 fail();
341 } catch (IllegalArgumentException ex) {
342 assertMessageContains(ex, "must not", "duplicate");
343 }
344
345 types = new DateTimeFieldType[] {
346 DateTimeFieldType.era(), DateTimeFieldType.era(), DateTimeFieldType.monthOfYear() };
347 try {
348 new Partial(types, values);
349 fail();
350 } catch (IllegalArgumentException ex) {
351 assertMessageContains(ex, "must not", "duplicate");
352 }
353
354 types = new DateTimeFieldType[] {
355 DateTimeFieldType.dayOfYear(), DateTimeFieldType.dayOfMonth(), DateTimeFieldType.dayOfMonth() };
356 try {
357 new Partial(types, values);
358 fail();
359 } catch (IllegalArgumentException ex) {
360 assertMessageContains(ex, "must not", "duplicate");
361 }
362 }
363
364 /**
365 * Test constructor
366 */
367 public void testConstructorEx9_TypeArray_intArray() throws Throwable {
368 int[] values = new int[] {3, 0};
369 DateTimeFieldType[] types = new DateTimeFieldType[] {
370 DateTimeFieldType.dayOfMonth(), DateTimeFieldType.dayOfWeek()};
371 try {
372 new Partial(types, values);
373 fail();
374 } catch (IllegalArgumentException ex) {
375 // expected
376 }
377 }
378
379 //-----------------------------------------------------------------------
380 /**
381 * Test constructor
382 */
383 public void testConstructor_TypeArray_intArray_Chrono() throws Throwable {
384 DateTimeFieldType[] types = new DateTimeFieldType[] {
385 DateTimeFieldType.year(),
386 DateTimeFieldType.dayOfYear()
387 };
388 int[] values = new int[] {2005, 33};
389 Partial test = new Partial(types, values, GREGORIAN_PARIS);
390 assertEquals(GREGORIAN_UTC, test.getChronology());
391 assertEquals(2, test.size());
392 assertEquals(2005, test.getValue(0));
393 assertEquals(2005, test.get(DateTimeFieldType.year()));
394 assertEquals(true, test.isSupported(DateTimeFieldType.year()));
395 assertEquals(33, test.getValue(1));
396 assertEquals(33, test.get(DateTimeFieldType.dayOfYear()));
397 assertEquals(true, test.isSupported(DateTimeFieldType.dayOfYear()));
398 assertEquals(true, Arrays.equals(test.getFieldTypes(), types));
399 assertEquals(true, Arrays.equals(test.getValues(), values));
400 }
401
402 //-----------------------------------------------------------------------
403 /**
404 * Test constructor
405 */
406 public void testConstructor_Partial() throws Throwable {
407 YearMonthDay ymd = new YearMonthDay(2005, 6, 25, GREGORIAN_PARIS);
408 Partial test = new Partial(ymd);
409 assertEquals(GREGORIAN_UTC, test.getChronology());
410 assertEquals(3, test.size());
411 assertEquals(2005, test.getValue(0));
412 assertEquals(2005, test.get(DateTimeFieldType.year()));
413 assertEquals(true, test.isSupported(DateTimeFieldType.year()));
414 assertEquals(6, test.getValue(1));
415 assertEquals(6, test.get(DateTimeFieldType.monthOfYear()));
416 assertEquals(true, test.isSupported(DateTimeFieldType.monthOfYear()));
417 assertEquals(25, test.getValue(2));
418 assertEquals(25, test.get(DateTimeFieldType.dayOfMonth()));
419 assertEquals(true, test.isSupported(DateTimeFieldType.dayOfMonth()));
420 }
421
422 /**
423 * Test constructor
424 */
425 public void testConstructorEx_Partial() throws Throwable {
426 try {
427 new Partial((ReadablePartial) null);
428 fail();
429 } catch (IllegalArgumentException ex) {
430 assertMessageContains(ex, "must not be null");
431 }
432 }
433
434 //-----------------------------------------------------------------------
435 /**
436 * Checks if the exception message is valid.
437 *
438 * @param ex the exception to check
439 * @param str the string to check
440 */
441 private void assertMessageContains(Exception ex, String str) {
442 assertEquals(ex.getMessage() + ": " + str, true, ex.getMessage().indexOf(str) >= 0);
443 }
444
445 /**
446 * Checks if the exception message is valid.
447 *
448 * @param ex the exception to check
449 * @param str1 the string to check
450 * @param str2 the string to check
451 */
452 private void assertMessageContains(Exception ex, String str1, String str2) {
453 assertEquals(ex.getMessage() + ": " + str1 + "/" + str2, true,
454 ex.getMessage().indexOf(str1) >= 0 &&
455 ex.getMessage().indexOf(str2) >= 0 &&
456 ex.getMessage().indexOf(str1) < ex.getMessage().indexOf(str2));
457 }
458
459 }