DateUtilsFragmentTest xref


1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    * 
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   * 
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.apache.commons.lang.time;
18  
19  import java.util.Calendar;
20  import java.util.Date;
21  
22  import junit.framework.TestCase;
23  import junit.framework.Test;
24  import junit.framework.TestSuite;
25  
26  import org.apache.commons.lang.StringUtils;
27  import org.apache.commons.lang.time.DateFormatUtils;
28  
29  public class DateUtilsFragmentTest extends TestCase {
30  
31      public static Test suite() {
32          TestSuite suite = new TestSuite(DateUtilsFragmentTest.class);
33          suite.setName("DateUtils Fragment Tests");
34          return suite;
35      }
36  
37  	private static final int months = 7;   // second final prime before 12
38  	private static final int days = 23;    // second final prime before 31 (and valid)
39  	private static final int hours = 19;   // second final prime before 24
40  	private static final int minutes = 53; // second final prime before 60
41  	private static final int seconds = 47; // third final prime before 60
42  	private static final int millis = 991; // second final prime before 1000
43  
44  	private Date aDate;
45  	private Calendar aCalendar;
46  
47  	protected void setUp() {
48  		aCalendar = Calendar.getInstance();
49  		aCalendar.set(2005, months, days, hours, minutes, seconds);
50  		aCalendar.set(Calendar.MILLISECOND, millis);
51  		aDate = aCalendar.getTime();
52  	}
53  	
54  	public void testNullDate() {
55  		try {
56  			DateUtils.getFragmentInMilliseconds((Date) null, Calendar.MILLISECOND);
57  			fail();
58  		} catch(IllegalArgumentException iae) {}
59  
60  		try {
61  			DateUtils.getFragmentInSeconds((Date) null, Calendar.MILLISECOND);
62  			fail();
63  		} catch(IllegalArgumentException iae) {}
64  
65  		try {
66  			DateUtils.getFragmentInMinutes((Date) null, Calendar.MILLISECOND);
67  			fail();
68  		} catch(IllegalArgumentException iae) {}
69  
70  		try {
71  			DateUtils.getFragmentInHours((Date) null, Calendar.MILLISECOND);
72  			fail();
73  		} catch(IllegalArgumentException iae) {}
74  
75  		try {
76  			DateUtils.getFragmentInDays((Date) null, Calendar.MILLISECOND);
77  			fail();
78  		} catch(IllegalArgumentException iae) {}
79  	}
80  
81  	public void testNullCalendar() {
82  		try {
83  			DateUtils.getFragmentInMilliseconds((Calendar) null, Calendar.MILLISECOND);
84  			fail();
85  		} catch(IllegalArgumentException iae) {}
86  
87  		try {
88  			DateUtils.getFragmentInSeconds((Calendar) null, Calendar.MILLISECOND);
89  			fail();
90  		} catch(IllegalArgumentException iae) {}
91  
92  		try {
93  			DateUtils.getFragmentInMinutes((Calendar) null, Calendar.MILLISECOND);
94  			fail();
95  		} catch(IllegalArgumentException iae) {}
96  
97  		try {
98  			DateUtils.getFragmentInHours((Calendar) null, Calendar.MILLISECOND);
99  			fail();
100 		} catch(IllegalArgumentException iae) {}
101 
102 		try {
103 			DateUtils.getFragmentInDays((Calendar) null, Calendar.MILLISECOND);
104 			fail();
105 		} catch(IllegalArgumentException iae) {}
106 	}
107 	
108 	public void testInvalidFragmentWithDate() {
109 		try {
110 			DateUtils.getFragmentInMilliseconds(aDate, 0);
111 			fail();
112 		} catch(IllegalArgumentException iae) {}
113 
114 		try {
115 			DateUtils.getFragmentInSeconds(aDate, 0);
116 			fail();
117 		} catch(IllegalArgumentException iae) {}
118 
119 		try {
120 			DateUtils.getFragmentInMinutes(aDate, 0);
121 			fail();
122 		} catch(IllegalArgumentException iae) {}
123 
124 		try {
125 			DateUtils.getFragmentInHours(aDate, 0);
126 			fail();
127 		} catch(IllegalArgumentException iae) {}
128 
129 		try {
130 			DateUtils.getFragmentInDays(aDate, 0);
131 			fail();
132 		} catch(IllegalArgumentException iae) {}
133 	}
134 
135 	public void testInvalidFragmentWithCalendar() {
136 		try {
137 			DateUtils.getFragmentInMilliseconds(aCalendar, 0);
138 			fail();
139 		} catch(IllegalArgumentException iae) {}
140 
141 		try {
142 			DateUtils.getFragmentInSeconds(aCalendar, 0);
143 			fail();
144 		} catch(IllegalArgumentException iae) {}
145 
146 		try {
147 			DateUtils.getFragmentInMinutes(aCalendar, 0);
148 			fail();
149 		} catch(IllegalArgumentException iae) {}
150 
151 		try {
152 			DateUtils.getFragmentInHours(aCalendar, 0);
153 			fail();
154 		} catch(IllegalArgumentException iae) {}
155 
156 		try {
157 			DateUtils.getFragmentInDays(aCalendar, 0);
158 			fail();
159 		} catch(IllegalArgumentException iae) {}
160 	}
161 
162 	public void testMillisecondFragmentInLargerUnitWithDate() {
163 		assertEquals(0, DateUtils.getFragmentInMilliseconds(aDate, Calendar.MILLISECOND));
164 		assertEquals(0, DateUtils.getFragmentInSeconds(aDate, Calendar.MILLISECOND));
165 		assertEquals(0, DateUtils.getFragmentInMinutes(aDate, Calendar.MILLISECOND));
166 		assertEquals(0, DateUtils.getFragmentInHours(aDate, Calendar.MILLISECOND));
167 		assertEquals(0, DateUtils.getFragmentInDays(aDate, Calendar.MILLISECOND));
168 	}
169 
170 	public void testMillisecondFragmentInLargerUnitWithCalendar() {
171 		assertEquals(0, DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.MILLISECOND));
172 		assertEquals(0, DateUtils.getFragmentInSeconds(aCalendar, Calendar.MILLISECOND));
173 		assertEquals(0, DateUtils.getFragmentInMinutes(aCalendar, Calendar.MILLISECOND));
174 		assertEquals(0, DateUtils.getFragmentInHours(aCalendar, Calendar.MILLISECOND));
175 		assertEquals(0, DateUtils.getFragmentInDays(aCalendar, Calendar.MILLISECOND));
176 	}
177 	
178 	public void testSecondFragmentInLargerUnitWithDate() {
179 		assertEquals(0, DateUtils.getFragmentInSeconds(aDate, Calendar.SECOND));
180 		assertEquals(0, DateUtils.getFragmentInMinutes(aDate, Calendar.SECOND));
181 		assertEquals(0, DateUtils.getFragmentInHours(aDate, Calendar.SECOND));
182 		assertEquals(0, DateUtils.getFragmentInDays(aDate, Calendar.SECOND));
183 	}
184 
185 	public void testSecondFragmentInLargerUnitWithCalendar() {
186 		assertEquals(0, DateUtils.getFragmentInSeconds(aCalendar, Calendar.SECOND));
187 		assertEquals(0, DateUtils.getFragmentInMinutes(aCalendar, Calendar.SECOND));
188 		assertEquals(0, DateUtils.getFragmentInHours(aCalendar, Calendar.SECOND));
189 		assertEquals(0, DateUtils.getFragmentInDays(aCalendar, Calendar.SECOND));
190 	}
191 	
192 	public void testMinuteFragmentInLargerUnitWithDate() {
193 		assertEquals(0, DateUtils.getFragmentInMinutes(aDate, Calendar.MINUTE));
194 		assertEquals(0, DateUtils.getFragmentInHours(aDate, Calendar.MINUTE));
195 		assertEquals(0, DateUtils.getFragmentInDays(aDate, Calendar.MINUTE));
196 	}
197 
198 	public void testMinuteFragmentInLargerUnitWithCalendar() {
199 		assertEquals(0, DateUtils.getFragmentInMinutes(aCalendar, Calendar.MINUTE));
200 		assertEquals(0, DateUtils.getFragmentInHours(aCalendar, Calendar.MINUTE));
201 		assertEquals(0, DateUtils.getFragmentInDays(aCalendar, Calendar.MINUTE));
202 	}
203 
204 	public void testHourOfDayFragmentInLargerUnitWithDate() {
205 		assertEquals(0, DateUtils.getFragmentInHours(aDate, Calendar.HOUR_OF_DAY));
206 		assertEquals(0, DateUtils.getFragmentInDays(aDate, Calendar.HOUR_OF_DAY));
207 	}
208 
209 	public void testHourOfDayFragmentInLargerUnitWithCalendar() {
210 		assertEquals(0, DateUtils.getFragmentInHours(aCalendar, Calendar.HOUR_OF_DAY));
211 		assertEquals(0, DateUtils.getFragmentInDays(aCalendar, Calendar.HOUR_OF_DAY));
212 	}
213 
214 	public void testDayOfYearFragmentInLargerUnitWithDate() {
215 		assertEquals(0, DateUtils.getFragmentInDays(aDate, Calendar.DAY_OF_YEAR));
216 	}
217 
218 	public void testDayOfYearFragmentInLargerUnitWithCalendar() {
219 		assertEquals(0, DateUtils.getFragmentInDays(aCalendar, Calendar.DAY_OF_YEAR));
220 	}
221 
222 	public void testDateFragmentInLargerUnitWithDate() {
223 		assertEquals(0, DateUtils.getFragmentInDays(aDate, Calendar.DATE));
224 	}
225 
226 	public void testDateFragmentInLargerUnitWithCalendar() {
227 		assertEquals(0, DateUtils.getFragmentInDays(aCalendar, Calendar.DATE));
228 	}
229 
230 	//Calendar.SECOND as useful fragment
231 	
232 	public void testMillisecondsOfSecondWithDate() {
233 		long testResult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.SECOND);
234 		assertEquals(millis, testResult);
235 	}
236 
237 	public void testMillisecondsOfSecondWithCalendar() {
238 		long testResult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.SECOND);
239 		assertEquals(millis, testResult);
240 		assertEquals(aCalendar.get(Calendar.MILLISECOND), testResult);
241 	}
242 
243 	//Calendar.MINUTE as useful fragment
244 
245 	public void testMillisecondsOfMinuteWithDate() {
246 		long testResult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.MINUTE);
247 		assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND), testResult);
248 	}
249 
250 	public void testMillisecondsOfMinuteWithCalender() {
251 		long testResult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.MINUTE);
252 		assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND), testResult);
253 	}
254 
255 	public void testSecondsofMinuteWithDate() {
256 		long testResult = DateUtils.getFragmentInSeconds(aDate, Calendar.MINUTE);
257 		assertEquals(seconds, testResult);
258 	}
259 
260 	public void testSecondsofMinuteWithCalendar() {
261 		long testResult = DateUtils.getFragmentInSeconds(aCalendar, Calendar.MINUTE);
262 		assertEquals(seconds, testResult);
263 		assertEquals(aCalendar.get(Calendar.SECOND), testResult);
264 	}
265 
266 	//Calendar.HOUR_OF_DAY as useful fragment
267 	
268 	public void testMillisecondsOfHourWithDate() {
269 		long testResult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.HOUR_OF_DAY);
270 		assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE), testResult);
271 	}
272 	
273 	public void testMillisecondsOfHourWithCalendar() {
274 		long testResult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.HOUR_OF_DAY);
275 		assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE), testResult);
276 	}
277 
278 	public void testSecondsofHourWithDate() {
279 		long testResult = DateUtils.getFragmentInSeconds(aDate, Calendar.HOUR_OF_DAY);
280 		assertEquals(
281 				seconds
282 						+ (minutes
283 								* DateUtils.MILLIS_PER_MINUTE / DateUtils.MILLIS_PER_SECOND),
284 				testResult);
285 	}
286 
287 	public void testSecondsofHourWithCalendar() {
288 		long testResult = DateUtils.getFragmentInSeconds(aCalendar, Calendar.HOUR_OF_DAY);
289 		assertEquals(
290 				seconds
291 						+ (minutes
292 								* DateUtils.MILLIS_PER_MINUTE / DateUtils.MILLIS_PER_SECOND),
293 				testResult);
294 	}
295 
296 	public void testMinutesOfHourWithDate() {
297 		long testResult = DateUtils.getFragmentInMinutes(aDate, Calendar.HOUR_OF_DAY);
298 		assertEquals(minutes, testResult);
299 	}
300 
301 	public void testMinutesOfHourWithCalendar() {
302 		long testResult = DateUtils.getFragmentInMinutes(aCalendar, Calendar.HOUR_OF_DAY);
303 		assertEquals(minutes, testResult);
304 	}
305 
306 	//Calendar.DATE and Calendar.DAY_OF_YEAR as useful fragment
307 	public void testMillisecondsOfDayWithDate() {
308 		long testresult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.DATE);
309 		long expectedValue = millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE) + (hours * DateUtils.MILLIS_PER_HOUR); 
310 		assertEquals(expectedValue, testresult);
311 		testresult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.DAY_OF_YEAR);
312 		assertEquals(expectedValue, testresult);
313 	}
314 	
315 	public void testMillisecondsOfDayWithCalendar() {
316 		long testresult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.DATE);
317 		long expectedValue = millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE) + (hours * DateUtils.MILLIS_PER_HOUR); 
318 		assertEquals(expectedValue, testresult);
319 		testresult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.DAY_OF_YEAR);
320 		assertEquals(expectedValue, testresult);
321 	}
322 
323 	public void testSecondsOfDayWithDate() {
324 		long testresult = DateUtils.getFragmentInSeconds(aDate, Calendar.DATE);
325 		long expectedValue = seconds + ((minutes * DateUtils.MILLIS_PER_MINUTE) + (hours * DateUtils.MILLIS_PER_HOUR))/ DateUtils.MILLIS_PER_SECOND;
326 		assertEquals(expectedValue, testresult);
327 		testresult = DateUtils.getFragmentInSeconds(aDate, Calendar.DAY_OF_YEAR);
328 		assertEquals(expectedValue, testresult);
329 	}
330 
331 	public void testSecondsOfDayWithCalendar() {
332 		long testresult = DateUtils.getFragmentInSeconds(aCalendar, Calendar.DATE);
333 		long expectedValue = seconds + ((minutes * DateUtils.MILLIS_PER_MINUTE) + (hours * DateUtils.MILLIS_PER_HOUR))/ DateUtils.MILLIS_PER_SECOND;
334 		assertEquals(expectedValue, testresult);
335 		testresult = DateUtils.getFragmentInSeconds(aCalendar, Calendar.DAY_OF_YEAR);
336 		assertEquals(expectedValue, testresult);
337 	}
338 
339 	public void testMinutesOfDayWithDate() {
340 		long testResult = DateUtils.getFragmentInMinutes(aDate, Calendar.DATE);
341 		long expectedValue = minutes + ((hours * DateUtils.MILLIS_PER_HOUR))/ DateUtils.MILLIS_PER_MINUTE; 
342 		assertEquals(expectedValue,testResult);
343 		testResult = DateUtils.getFragmentInMinutes(aDate, Calendar.DAY_OF_YEAR);
344 		assertEquals(expectedValue,testResult);
345 	}
346 
347 	public void testMinutesOfDayWithCalendar() {
348 		long testResult = DateUtils.getFragmentInMinutes(aCalendar, Calendar.DATE);
349 		long expectedValue = minutes + ((hours * DateUtils.MILLIS_PER_HOUR))/ DateUtils.MILLIS_PER_MINUTE; 
350 		assertEquals(expectedValue, testResult);
351 		testResult = DateUtils.getFragmentInMinutes(aCalendar, Calendar.DAY_OF_YEAR);
352 		assertEquals(expectedValue, testResult);
353 	}
354 	
355 	public void testHoursOfDayWithDate() {
356 		long testResult = DateUtils.getFragmentInHours(aDate, Calendar.DATE);
357 		long expectedValue = hours; 
358 		assertEquals(expectedValue,testResult);
359 		testResult = DateUtils.getFragmentInHours(aDate, Calendar.DAY_OF_YEAR);
360 		assertEquals(expectedValue,testResult);
361 	}
362 
363 	public void testHoursOfDayWithCalendar() {
364 		long testResult = DateUtils.getFragmentInHours(aCalendar, Calendar.DATE);
365 		long expectedValue = hours; 
366 		assertEquals(expectedValue, testResult);
367 		testResult = DateUtils.getFragmentInHours(aCalendar, Calendar.DAY_OF_YEAR);
368 		assertEquals(expectedValue, testResult);
369 	}
370 	
371 	
372 	//Calendar.MONTH as useful fragment
373 	public void testMillisecondsOfMonthWithDate() {
374 		long testResult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.MONTH);
375 		assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE)
376 								+ (hours * DateUtils.MILLIS_PER_HOUR) + (days * DateUtils.MILLIS_PER_DAY),
377 				testResult);
378 	}
379 
380 	public void testMillisecondsOfMonthWithCalendar() {
381 		long testResult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.MONTH);
382 		assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE)
383 				+ (hours * DateUtils.MILLIS_PER_HOUR) + (days * DateUtils.MILLIS_PER_DAY),
384 testResult);
385 	}
386 	
387 	public void testSecondsOfMonthWithDate() {
388 		long testResult = DateUtils.getFragmentInSeconds(aDate, Calendar.MONTH);
389 		assertEquals(
390 				seconds
391 						+ ((minutes * DateUtils.MILLIS_PER_MINUTE)
392 								+ (hours * DateUtils.MILLIS_PER_HOUR) + (days * DateUtils.MILLIS_PER_DAY))
393 						/ DateUtils.MILLIS_PER_SECOND,
394 				testResult);
395 	}
396 
397 	public void testSecondsOfMonthWithCalendar() {
398 		long testResult = DateUtils.getFragmentInSeconds(aCalendar, Calendar.MONTH);
399 		assertEquals(
400 				seconds
401 						+ ((minutes * DateUtils.MILLIS_PER_MINUTE)
402 								+ (hours * DateUtils.MILLIS_PER_HOUR) + (days * DateUtils.MILLIS_PER_DAY))
403 						/ DateUtils.MILLIS_PER_SECOND,
404 				testResult);
405 	}
406 
407 	public void testMinutesOfMonthWithDate() {
408 		long testResult = DateUtils.getFragmentInMinutes(aDate, Calendar.MONTH);
409 		assertEquals(minutes
410 								+ ((hours * DateUtils.MILLIS_PER_HOUR) + (days * DateUtils.MILLIS_PER_DAY))
411 						/ DateUtils.MILLIS_PER_MINUTE,
412 				testResult);
413 	}
414 
415 	public void testMinutesOfMonthWithCalendar() {
416 		long testResult = DateUtils.getFragmentInMinutes(aCalendar, Calendar.MONTH);
417 		assertEquals( minutes  +((hours * DateUtils.MILLIS_PER_HOUR) + (days * DateUtils.MILLIS_PER_DAY))
418 						/ DateUtils.MILLIS_PER_MINUTE,
419 				testResult);
420 	}
421 
422 	public void testHoursOfMonthWithDate() {
423 		long testResult = DateUtils.getFragmentInHours(aDate, Calendar.MONTH);
424 		assertEquals(hours + ((days * DateUtils.MILLIS_PER_DAY))
425 						/ DateUtils.MILLIS_PER_HOUR,
426 				testResult);
427 	}
428 
429 	public void testHoursOfMonthWithCalendar() {
430 		long testResult = DateUtils.getFragmentInHours(aCalendar, Calendar.MONTH);
431 		assertEquals( hours +((days * DateUtils.MILLIS_PER_DAY))
432 						/ DateUtils.MILLIS_PER_HOUR,
433 				testResult);
434 	}
435 	
436 	//Calendar.YEAR as useful fragment
437 	public void testMillisecondsOfYearWithDate() {
438 		long testResult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.YEAR);
439 		Calendar cal = Calendar.getInstance();
440 		cal.setTime(aDate);
441 		assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE)
442 								+ (hours * DateUtils.MILLIS_PER_HOUR) + (cal.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY),
443 				testResult);
444 	}
445 
446 	public void testMillisecondsOfYearWithCalendar() {
447 		long testResult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.YEAR);
448 		assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE)
449 				+ (hours * DateUtils.MILLIS_PER_HOUR) + (aCalendar.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY),
450 testResult);
451 	}
452 	
453 	public void testSecondsOfYearWithDate() {
454 		long testResult = DateUtils.getFragmentInSeconds(aDate, Calendar.YEAR);
455 		Calendar cal = Calendar.getInstance();
456 		cal.setTime(aDate);
457 		assertEquals(
458 				seconds
459 						+ ((minutes * DateUtils.MILLIS_PER_MINUTE)
460 								+ (hours * DateUtils.MILLIS_PER_HOUR) + (cal.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY))
461 						/ DateUtils.MILLIS_PER_SECOND,
462 				testResult);
463 	}
464 
465 	public void testSecondsOfYearWithCalendar() {
466 		long testResult = DateUtils.getFragmentInSeconds(aCalendar, Calendar.YEAR);
467 		assertEquals(
468 				seconds
469 						+ ((minutes * DateUtils.MILLIS_PER_MINUTE)
470 								+ (hours * DateUtils.MILLIS_PER_HOUR) + (aCalendar.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY))
471 						/ DateUtils.MILLIS_PER_SECOND,
472 				testResult);
473 	}
474 
475 	public void testMinutesOfYearWithDate() {
476 		long testResult = DateUtils.getFragmentInMinutes(aDate, Calendar.YEAR);
477 		Calendar cal = Calendar.getInstance();
478 		cal.setTime(aDate);
479 		assertEquals(minutes
480 								+ ((hours * DateUtils.MILLIS_PER_HOUR) + (cal.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY))
481 						/ DateUtils.MILLIS_PER_MINUTE,
482 				testResult);
483 	}
484 
485 	public void testMinutesOfYearWithCalendar() {
486 		long testResult = DateUtils.getFragmentInMinutes(aCalendar, Calendar.YEAR);
487 		assertEquals( minutes  +((hours * DateUtils.MILLIS_PER_HOUR) + (aCalendar.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY))
488 						/ DateUtils.MILLIS_PER_MINUTE,
489 				testResult);
490 	}
491 
492 	public void testHoursOfYearWithDate() {
493 		long testResult = DateUtils.getFragmentInHours(aDate, Calendar.YEAR);
494 		Calendar cal = Calendar.getInstance();
495 		cal.setTime(aDate);
496 		assertEquals(hours + ((cal.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY))
497 						/ DateUtils.MILLIS_PER_HOUR,
498 				testResult);
499 	}
500 
501 	public void testHoursOfYearWithCalendar() {
502 		long testResult = DateUtils.getFragmentInHours(aCalendar, Calendar.YEAR);
503 		assertEquals( hours +((aCalendar.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY))
504 						/ DateUtils.MILLIS_PER_HOUR,
505 				testResult);
506 	}
507 }