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