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