View Javadoc

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.lang3.time;
18  
19  import org.junit.Test;
20  import org.junit.Before;
21  import static org.junit.Assert.*;
22  import java.util.Calendar;
23  import java.util.Date;
24  
25  public class DateUtilsFragmentTest {
26  
27      private static final int months = 7;   // second final prime before 12
28      private static final int days = 23;    // second final prime before 31 (and valid)
29      private static final int hours = 19;   // second final prime before 24
30      private static final int minutes = 53; // second final prime before 60
31      private static final int seconds = 47; // third final prime before 60
32      private static final int millis = 991; // second final prime before 1000
33  
34      private Date aDate;
35      private Calendar aCalendar;
36  
37  
38      @Before
39      public void setUp() {
40          aCalendar = Calendar.getInstance();
41          aCalendar.set(2005, months, days, hours, minutes, seconds);
42          aCalendar.set(Calendar.MILLISECOND, millis);
43          aDate = aCalendar.getTime();
44      }
45      
46      @Test
47      public void testNullDate() {
48          try {
49              DateUtils.getFragmentInMilliseconds((Date) null, Calendar.MILLISECOND);
50              fail();
51          } catch(final IllegalArgumentException iae) {}
52  
53          try {
54              DateUtils.getFragmentInSeconds((Date) null, Calendar.MILLISECOND);
55              fail();
56          } catch(final IllegalArgumentException iae) {}
57  
58          try {
59              DateUtils.getFragmentInMinutes((Date) null, Calendar.MILLISECOND);
60              fail();
61          } catch(final IllegalArgumentException iae) {}
62  
63          try {
64              DateUtils.getFragmentInHours((Date) null, Calendar.MILLISECOND);
65              fail();
66          } catch(final IllegalArgumentException iae) {}
67  
68          try {
69              DateUtils.getFragmentInDays((Date) null, Calendar.MILLISECOND);
70              fail();
71          } catch(final IllegalArgumentException iae) {}
72      }
73  
74      @Test
75      public void testNullCalendar() {
76          try {
77              DateUtils.getFragmentInMilliseconds((Calendar) null, Calendar.MILLISECOND);
78              fail();
79          } catch(final IllegalArgumentException iae) {}
80  
81          try {
82              DateUtils.getFragmentInSeconds((Calendar) null, Calendar.MILLISECOND);
83              fail();
84          } catch(final IllegalArgumentException iae) {}
85  
86          try {
87              DateUtils.getFragmentInMinutes((Calendar) null, Calendar.MILLISECOND);
88              fail();
89          } catch(final IllegalArgumentException iae) {}
90  
91          try {
92              DateUtils.getFragmentInHours((Calendar) null, Calendar.MILLISECOND);
93              fail();
94          } catch(final IllegalArgumentException iae) {}
95  
96          try {
97              DateUtils.getFragmentInDays((Calendar) null, Calendar.MILLISECOND);
98              fail();
99          } catch(final IllegalArgumentException iae) {}
100     }
101     
102     @Test
103     public void testInvalidFragmentWithDate() {
104         try {
105             DateUtils.getFragmentInMilliseconds(aDate, 0);
106             fail();
107         } catch(final IllegalArgumentException iae) {}
108 
109         try {
110             DateUtils.getFragmentInSeconds(aDate, 0);
111             fail();
112         } catch(final IllegalArgumentException iae) {}
113 
114         try {
115             DateUtils.getFragmentInMinutes(aDate, 0);
116             fail();
117         } catch(final IllegalArgumentException iae) {}
118 
119         try {
120             DateUtils.getFragmentInHours(aDate, 0);
121             fail();
122         } catch(final IllegalArgumentException iae) {}
123 
124         try {
125             DateUtils.getFragmentInDays(aDate, 0);
126             fail();
127         } catch(final IllegalArgumentException iae) {}
128     }
129 
130     @Test
131     public void testInvalidFragmentWithCalendar() {
132         try {
133             DateUtils.getFragmentInMilliseconds(aCalendar, 0);
134             fail();
135         } catch(final IllegalArgumentException iae) {}
136 
137         try {
138             DateUtils.getFragmentInSeconds(aCalendar, 0);
139             fail();
140         } catch(final IllegalArgumentException iae) {}
141 
142         try {
143             DateUtils.getFragmentInMinutes(aCalendar, 0);
144             fail();
145         } catch(final IllegalArgumentException iae) {}
146 
147         try {
148             DateUtils.getFragmentInHours(aCalendar, 0);
149             fail();
150         } catch(final IllegalArgumentException iae) {}
151 
152         try {
153             DateUtils.getFragmentInDays(aCalendar, 0);
154             fail();
155         } catch(final IllegalArgumentException iae) {}
156     }
157 
158     @Test
159     public void testMillisecondFragmentInLargerUnitWithDate() {
160         assertEquals(0, DateUtils.getFragmentInMilliseconds(aDate, Calendar.MILLISECOND));
161         assertEquals(0, DateUtils.getFragmentInSeconds(aDate, Calendar.MILLISECOND));
162         assertEquals(0, DateUtils.getFragmentInMinutes(aDate, Calendar.MILLISECOND));
163         assertEquals(0, DateUtils.getFragmentInHours(aDate, Calendar.MILLISECOND));
164         assertEquals(0, DateUtils.getFragmentInDays(aDate, Calendar.MILLISECOND));
165     }
166 
167     @Test
168     public void testMillisecondFragmentInLargerUnitWithCalendar() {
169         assertEquals(0, DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.MILLISECOND));
170         assertEquals(0, DateUtils.getFragmentInSeconds(aCalendar, Calendar.MILLISECOND));
171         assertEquals(0, DateUtils.getFragmentInMinutes(aCalendar, Calendar.MILLISECOND));
172         assertEquals(0, DateUtils.getFragmentInHours(aCalendar, Calendar.MILLISECOND));
173         assertEquals(0, DateUtils.getFragmentInDays(aCalendar, Calendar.MILLISECOND));
174     }
175     
176     @Test
177     public void testSecondFragmentInLargerUnitWithDate() {
178         assertEquals(0, DateUtils.getFragmentInSeconds(aDate, Calendar.SECOND));
179         assertEquals(0, DateUtils.getFragmentInMinutes(aDate, Calendar.SECOND));
180         assertEquals(0, DateUtils.getFragmentInHours(aDate, Calendar.SECOND));
181         assertEquals(0, DateUtils.getFragmentInDays(aDate, Calendar.SECOND));
182     }
183 
184     @Test
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     @Test
193     public void testMinuteFragmentInLargerUnitWithDate() {
194         assertEquals(0, DateUtils.getFragmentInMinutes(aDate, Calendar.MINUTE));
195         assertEquals(0, DateUtils.getFragmentInHours(aDate, Calendar.MINUTE));
196         assertEquals(0, DateUtils.getFragmentInDays(aDate, Calendar.MINUTE));
197     }
198 
199     @Test
200     public void testMinuteFragmentInLargerUnitWithCalendar() {
201         assertEquals(0, DateUtils.getFragmentInMinutes(aCalendar, Calendar.MINUTE));
202         assertEquals(0, DateUtils.getFragmentInHours(aCalendar, Calendar.MINUTE));
203         assertEquals(0, DateUtils.getFragmentInDays(aCalendar, Calendar.MINUTE));
204     }
205 
206     @Test
207     public void testHourOfDayFragmentInLargerUnitWithDate() {
208         assertEquals(0, DateUtils.getFragmentInHours(aDate, Calendar.HOUR_OF_DAY));
209         assertEquals(0, DateUtils.getFragmentInDays(aDate, Calendar.HOUR_OF_DAY));
210     }
211 
212     @Test
213     public void testHourOfDayFragmentInLargerUnitWithCalendar() {
214         assertEquals(0, DateUtils.getFragmentInHours(aCalendar, Calendar.HOUR_OF_DAY));
215         assertEquals(0, DateUtils.getFragmentInDays(aCalendar, Calendar.HOUR_OF_DAY));
216     }
217 
218     @Test
219     public void testDayOfYearFragmentInLargerUnitWithDate() {
220         assertEquals(0, DateUtils.getFragmentInDays(aDate, Calendar.DAY_OF_YEAR));
221     }
222 
223     @Test
224     public void testDayOfYearFragmentInLargerUnitWithCalendar() {
225         assertEquals(0, DateUtils.getFragmentInDays(aCalendar, Calendar.DAY_OF_YEAR));
226     }
227 
228     @Test
229     public void testDateFragmentInLargerUnitWithDate() {
230         assertEquals(0, DateUtils.getFragmentInDays(aDate, Calendar.DATE));
231     }
232 
233     @Test
234     public void testDateFragmentInLargerUnitWithCalendar() {
235         assertEquals(0, DateUtils.getFragmentInDays(aCalendar, Calendar.DATE));
236     }
237 
238     //Calendar.SECOND as useful fragment
239     
240     @Test
241     public void testMillisecondsOfSecondWithDate() {
242         final long testResult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.SECOND);
243         assertEquals(millis, testResult);
244     }
245 
246     @Test
247     public void testMillisecondsOfSecondWithCalendar() {
248         final long testResult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.SECOND);
249         assertEquals(millis, testResult);
250         assertEquals(aCalendar.get(Calendar.MILLISECOND), testResult);
251     }
252 
253     //Calendar.MINUTE as useful fragment
254 
255     @Test
256     public void testMillisecondsOfMinuteWithDate() {
257         final long testResult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.MINUTE);
258         assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND), testResult);
259     }
260 
261     @Test
262     public void testMillisecondsOfMinuteWithCalender() {
263         final long testResult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.MINUTE);
264         assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND), testResult);
265     }
266 
267     @Test
268     public void testSecondsofMinuteWithDate() {
269         final long testResult = DateUtils.getFragmentInSeconds(aDate, Calendar.MINUTE);
270         assertEquals(seconds, testResult);
271     }
272 
273     @Test
274     public void testSecondsofMinuteWithCalendar() {
275         final long testResult = DateUtils.getFragmentInSeconds(aCalendar, Calendar.MINUTE);
276         assertEquals(seconds, testResult);
277         assertEquals(aCalendar.get(Calendar.SECOND), testResult);
278     }
279 
280     //Calendar.HOUR_OF_DAY as useful fragment
281     
282     @Test
283     public void testMillisecondsOfHourWithDate() {
284         final long testResult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.HOUR_OF_DAY);
285         assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE), testResult);
286     }
287     
288     @Test
289     public void testMillisecondsOfHourWithCalendar() {
290         final long testResult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.HOUR_OF_DAY);
291         assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE), testResult);
292     }
293 
294     @Test
295     public void testSecondsofHourWithDate() {
296         final long testResult = DateUtils.getFragmentInSeconds(aDate, Calendar.HOUR_OF_DAY);
297         assertEquals(
298                 seconds
299                         + (minutes
300                                 * DateUtils.MILLIS_PER_MINUTE / DateUtils.MILLIS_PER_SECOND),
301                 testResult);
302     }
303 
304     @Test
305     public void testSecondsofHourWithCalendar() {
306         final long testResult = DateUtils.getFragmentInSeconds(aCalendar, Calendar.HOUR_OF_DAY);
307         assertEquals(
308                 seconds
309                         + (minutes
310                                 * DateUtils.MILLIS_PER_MINUTE / DateUtils.MILLIS_PER_SECOND),
311                 testResult);
312     }
313 
314     @Test
315     public void testMinutesOfHourWithDate() {
316         final long testResult = DateUtils.getFragmentInMinutes(aDate, Calendar.HOUR_OF_DAY);
317         assertEquals(minutes, testResult);
318     }
319 
320     @Test
321     public void testMinutesOfHourWithCalendar() {
322         final long testResult = DateUtils.getFragmentInMinutes(aCalendar, Calendar.HOUR_OF_DAY);
323         assertEquals(minutes, testResult);
324     }
325 
326     //Calendar.DATE and Calendar.DAY_OF_YEAR as useful fragment
327     @Test
328     public void testMillisecondsOfDayWithDate() {
329         long testresult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.DATE);
330         final long expectedValue = millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE) + (hours * DateUtils.MILLIS_PER_HOUR); 
331         assertEquals(expectedValue, testresult);
332         testresult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.DAY_OF_YEAR);
333         assertEquals(expectedValue, testresult);
334     }
335     
336     @Test
337     public void testMillisecondsOfDayWithCalendar() {
338         long testresult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.DATE);
339         final long expectedValue = millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE) + (hours * DateUtils.MILLIS_PER_HOUR); 
340         assertEquals(expectedValue, testresult);
341         testresult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.DAY_OF_YEAR);
342         assertEquals(expectedValue, testresult);
343     }
344 
345     @Test
346     public void testSecondsOfDayWithDate() {
347         long testresult = DateUtils.getFragmentInSeconds(aDate, Calendar.DATE);
348         final long expectedValue = seconds + ((minutes * DateUtils.MILLIS_PER_MINUTE) + (hours * DateUtils.MILLIS_PER_HOUR))/ DateUtils.MILLIS_PER_SECOND;
349         assertEquals(expectedValue, testresult);
350         testresult = DateUtils.getFragmentInSeconds(aDate, Calendar.DAY_OF_YEAR);
351         assertEquals(expectedValue, testresult);
352     }
353 
354     @Test
355     public void testSecondsOfDayWithCalendar() {
356         long testresult = DateUtils.getFragmentInSeconds(aCalendar, Calendar.DATE);
357         final long expectedValue = seconds + ((minutes * DateUtils.MILLIS_PER_MINUTE) + (hours * DateUtils.MILLIS_PER_HOUR))/ DateUtils.MILLIS_PER_SECOND;
358         assertEquals(expectedValue, testresult);
359         testresult = DateUtils.getFragmentInSeconds(aCalendar, Calendar.DAY_OF_YEAR);
360         assertEquals(expectedValue, testresult);
361     }
362 
363     @Test
364     public void testMinutesOfDayWithDate() {
365         long testResult = DateUtils.getFragmentInMinutes(aDate, Calendar.DATE);
366         final long expectedValue = minutes + ((hours * DateUtils.MILLIS_PER_HOUR))/ DateUtils.MILLIS_PER_MINUTE; 
367         assertEquals(expectedValue,testResult);
368         testResult = DateUtils.getFragmentInMinutes(aDate, Calendar.DAY_OF_YEAR);
369         assertEquals(expectedValue,testResult);
370     }
371 
372     @Test
373     public void testMinutesOfDayWithCalendar() {
374         long testResult = DateUtils.getFragmentInMinutes(aCalendar, Calendar.DATE);
375         final long expectedValue = minutes + ((hours * DateUtils.MILLIS_PER_HOUR))/ DateUtils.MILLIS_PER_MINUTE; 
376         assertEquals(expectedValue, testResult);
377         testResult = DateUtils.getFragmentInMinutes(aCalendar, Calendar.DAY_OF_YEAR);
378         assertEquals(expectedValue, testResult);
379     }
380     
381     @Test
382     public void testHoursOfDayWithDate() {
383         long testResult = DateUtils.getFragmentInHours(aDate, Calendar.DATE);
384         final long expectedValue = hours; 
385         assertEquals(expectedValue,testResult);
386         testResult = DateUtils.getFragmentInHours(aDate, Calendar.DAY_OF_YEAR);
387         assertEquals(expectedValue,testResult);
388     }
389 
390     @Test
391     public void testHoursOfDayWithCalendar() {
392         long testResult = DateUtils.getFragmentInHours(aCalendar, Calendar.DATE);
393         final long expectedValue = hours; 
394         assertEquals(expectedValue, testResult);
395         testResult = DateUtils.getFragmentInHours(aCalendar, Calendar.DAY_OF_YEAR);
396         assertEquals(expectedValue, testResult);
397     }
398     
399     
400     //Calendar.MONTH as useful fragment
401     @Test
402     public void testMillisecondsOfMonthWithDate() {
403         final long testResult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.MONTH);
404         assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE)
405                                 + (hours * DateUtils.MILLIS_PER_HOUR) + (days * DateUtils.MILLIS_PER_DAY),
406                 testResult);
407     }
408 
409     @Test
410     public void testMillisecondsOfMonthWithCalendar() {
411         final long testResult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.MONTH);
412         assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE)
413                 + (hours * DateUtils.MILLIS_PER_HOUR) + (days * DateUtils.MILLIS_PER_DAY),
414 testResult);
415     }
416     
417     @Test
418     public void testSecondsOfMonthWithDate() {
419         final long testResult = DateUtils.getFragmentInSeconds(aDate, Calendar.MONTH);
420         assertEquals(
421                 seconds
422                         + ((minutes * DateUtils.MILLIS_PER_MINUTE)
423                                 + (hours * DateUtils.MILLIS_PER_HOUR) + (days * DateUtils.MILLIS_PER_DAY))
424                         / DateUtils.MILLIS_PER_SECOND,
425                 testResult);
426     }
427 
428     @Test
429     public void testSecondsOfMonthWithCalendar() {
430         final long testResult = DateUtils.getFragmentInSeconds(aCalendar, Calendar.MONTH);
431         assertEquals(
432                 seconds
433                         + ((minutes * DateUtils.MILLIS_PER_MINUTE)
434                                 + (hours * DateUtils.MILLIS_PER_HOUR) + (days * DateUtils.MILLIS_PER_DAY))
435                         / DateUtils.MILLIS_PER_SECOND,
436                 testResult);
437     }
438 
439     @Test
440     public void testMinutesOfMonthWithDate() {
441         final long testResult = DateUtils.getFragmentInMinutes(aDate, Calendar.MONTH);
442         assertEquals(minutes
443                                 + ((hours * DateUtils.MILLIS_PER_HOUR) + (days * DateUtils.MILLIS_PER_DAY))
444                         / DateUtils.MILLIS_PER_MINUTE,
445                 testResult);
446     }
447 
448     @Test
449     public void testMinutesOfMonthWithCalendar() {
450         final long testResult = DateUtils.getFragmentInMinutes(aCalendar, Calendar.MONTH);
451         assertEquals( minutes  +((hours * DateUtils.MILLIS_PER_HOUR) + (days * DateUtils.MILLIS_PER_DAY))
452                         / DateUtils.MILLIS_PER_MINUTE,
453                 testResult);
454     }
455 
456     @Test
457     public void testHoursOfMonthWithDate() {
458         final long testResult = DateUtils.getFragmentInHours(aDate, Calendar.MONTH);
459         assertEquals(hours + ((days * DateUtils.MILLIS_PER_DAY))
460                         / DateUtils.MILLIS_PER_HOUR,
461                 testResult);
462     }
463 
464     @Test
465     public void testHoursOfMonthWithCalendar() {
466         final long testResult = DateUtils.getFragmentInHours(aCalendar, Calendar.MONTH);
467         assertEquals( hours +((days * DateUtils.MILLIS_PER_DAY))
468                         / DateUtils.MILLIS_PER_HOUR,
469                 testResult);
470     }
471     
472     //Calendar.YEAR as useful fragment
473     @Test
474     public void testMillisecondsOfYearWithDate() {
475         final long testResult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.YEAR);
476         final Calendar cal = Calendar.getInstance();
477         cal.setTime(aDate);
478         assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE)
479                                 + (hours * DateUtils.MILLIS_PER_HOUR) + (cal.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY),
480                 testResult);
481     }
482 
483     @Test
484     public void testMillisecondsOfYearWithCalendar() {
485         final long testResult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.YEAR);
486         assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE)
487                 + (hours * DateUtils.MILLIS_PER_HOUR) + (aCalendar.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY),
488 testResult);
489     }
490     
491     @Test
492     public void testSecondsOfYearWithDate() {
493         final long testResult = DateUtils.getFragmentInSeconds(aDate, Calendar.YEAR);
494         final Calendar cal = Calendar.getInstance();
495         cal.setTime(aDate);
496         assertEquals(
497                 seconds
498                         + ((minutes * DateUtils.MILLIS_PER_MINUTE)
499                                 + (hours * DateUtils.MILLIS_PER_HOUR) + (cal.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY))
500                         / DateUtils.MILLIS_PER_SECOND,
501                 testResult);
502     }
503 
504     @Test
505     public void testSecondsOfYearWithCalendar() {
506         final long testResult = DateUtils.getFragmentInSeconds(aCalendar, Calendar.YEAR);
507         assertEquals(
508                 seconds
509                         + ((minutes * DateUtils.MILLIS_PER_MINUTE)
510                                 + (hours * DateUtils.MILLIS_PER_HOUR) + (aCalendar.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY))
511                         / DateUtils.MILLIS_PER_SECOND,
512                 testResult);
513     }
514 
515     @Test
516     public void testMinutesOfYearWithDate() {
517         final long testResult = DateUtils.getFragmentInMinutes(aDate, Calendar.YEAR);
518         final Calendar cal = Calendar.getInstance();
519         cal.setTime(aDate);
520         assertEquals(minutes
521                                 + ((hours * DateUtils.MILLIS_PER_HOUR) + (cal.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY))
522                         / DateUtils.MILLIS_PER_MINUTE,
523                 testResult);
524     }
525 
526     @Test
527     public void testMinutesOfYearWithCalendar() {
528         final long testResult = DateUtils.getFragmentInMinutes(aCalendar, Calendar.YEAR);
529         assertEquals( minutes  +((hours * DateUtils.MILLIS_PER_HOUR) + (aCalendar.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY))
530                         / DateUtils.MILLIS_PER_MINUTE,
531                 testResult);
532     }
533 
534     @Test
535     public void testHoursOfYearWithDate() {
536         final long testResult = DateUtils.getFragmentInHours(aDate, Calendar.YEAR);
537         final Calendar cal = Calendar.getInstance();
538         cal.setTime(aDate);
539         assertEquals(hours + ((cal.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY))
540                         / DateUtils.MILLIS_PER_HOUR,
541                 testResult);
542     }
543 
544     @Test
545     public void testHoursOfYearWithCalendar() {
546         final long testResult = DateUtils.getFragmentInHours(aCalendar, Calendar.YEAR);
547         assertEquals( hours +((aCalendar.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY))
548                         / DateUtils.MILLIS_PER_HOUR,
549                 testResult);
550     }
551 }