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  import static org.junit.jupiter.api.Assertions.assertFalse;
23  import static org.junit.jupiter.api.Assertions.assertNotNull;
24  import static org.junit.jupiter.api.Assertions.assertNotSame;
25  import static org.junit.jupiter.api.Assertions.assertThrows;
26  import static org.junit.jupiter.api.Assertions.assertTrue;
27  
28  import java.lang.reflect.Constructor;
29  import java.lang.reflect.Modifier;
30  import java.text.DateFormat;
31  import java.text.ParseException;
32  import java.text.SimpleDateFormat;
33  import java.time.Instant;
34  import java.time.LocalDateTime;
35  import java.time.OffsetDateTime;
36  import java.time.ZoneId;
37  import java.time.ZoneOffset;
38  import java.time.ZonedDateTime;
39  import java.time.temporal.ChronoUnit;
40  import java.util.Calendar;
41  import java.util.Date;
42  import java.util.GregorianCalendar;
43  import java.util.Iterator;
44  import java.util.Locale;
45  import java.util.NoSuchElementException;
46  import java.util.TimeZone;
47  import java.util.concurrent.TimeUnit;
48  import java.util.stream.Stream;
49  
50  import org.apache.commons.lang3.AbstractLangTest;
51  import org.junit.jupiter.api.AfterEach;
52  import org.junit.jupiter.api.BeforeAll;
53  import org.junit.jupiter.api.BeforeEach;
54  import org.junit.jupiter.api.Test;
55  import org.junit.jupiter.params.ParameterizedTest;
56  import org.junit.jupiter.params.provider.Arguments;
57  import org.junit.jupiter.params.provider.MethodSource;
58  import org.junit.jupiter.params.provider.ValueSource;
59  import org.junitpioneer.jupiter.DefaultLocale;
60  import org.junitpioneer.jupiter.DefaultTimeZone;
61  import org.junitpioneer.jupiter.ReadsDefaultLocale;
62  import org.junitpioneer.jupiter.ReadsDefaultTimeZone;
63  import org.junitpioneer.jupiter.WritesDefaultLocale;
64  import org.junitpioneer.jupiter.WritesDefaultTimeZone;
65  
66  /**
67   * Tests {@link DateUtils}.
68   */
69  @ReadsDefaultLocale
70  @WritesDefaultLocale
71  @ReadsDefaultTimeZone
72  @WritesDefaultTimeZone
73  class DateUtilsTest extends AbstractLangTest {
74  
75      private static final Date MAX_DATE = new Date(Long.MAX_VALUE);
76      private static final TimeZone TIME_ZONE_NY = TimeZones.getTimeZone("America/New_York");
77      private static final TimeZone TIME_ZONE_DEFAULT = TimeZone.getDefault();
78      private static final TimeZone TIME_ZONE_MET = TimeZones.getTimeZone("MET");
79      private static Date BASE_DATE;
80  
81      /**
82       * Used to check that Calendar objects are close enough
83       * delta is in milliseconds
84       */
85      private static void assertCalendarsEquals(final String message, final Calendar cal1, final Calendar cal2, final long delta) {
86          assertFalse(Math.abs(cal1.getTime().getTime() - cal2.getTime().getTime()) > delta,
87                  message + " expected " + cal1.getTime() + " but got " + cal2.getTime());
88      }
89  
90      /**
91       * This checks that this is a 7 element iterator of Calendar objects
92       * that are dates (no time), and exactly 1 day spaced after each other.
93       */
94      private static void assertWeekIterator(final Iterator<?> it, final Calendar start) {
95          final Calendar end = (Calendar) start.clone();
96          end.add(Calendar.DATE, 6);
97  
98          assertWeekIterator(it, start, end);
99      }
100 
101     /**
102      * This checks that this is a 7 divisible iterator of Calendar objects
103      * that are dates (no time), and exactly 1 day spaced after each other
104      * (in addition to the proper start and stop dates)
105      */
106     private static void assertWeekIterator(final Iterator<?> it, final Calendar start, final Calendar end) {
107         Calendar cal = (Calendar) it.next();
108         assertCalendarsEquals("", start, cal, 0);
109         Calendar last;
110         int count = 1;
111         while (it.hasNext()) {
112             //Check this is just a date (no time component)
113             assertCalendarsEquals("", cal, DateUtils.truncate(cal, Calendar.DATE), 0);
114 
115             last = cal;
116             cal = (Calendar) it.next();
117             count++;
118 
119             //Check that this is one day more than the last date
120             last.add(Calendar.DATE, 1);
121             assertCalendarsEquals("", last, cal, 0);
122         }
123 
124         assertFalse(count % 7 != 0, "There were " + count + " days in this iterator");
125         assertCalendarsEquals("", end, cal, 0);
126     }
127 
128     /**
129      * Convenience method for when working with Date objects
130      */
131     private static void assertWeekIterator(final Iterator<?> it, final Date start, final Date end) {
132         final Calendar calStart = Calendar.getInstance();
133         calStart.setTime(start);
134         final Calendar calEnd = Calendar.getInstance();
135         calEnd.setTime(end);
136 
137         assertWeekIterator(it, calStart, calEnd);
138     }
139 
140     @BeforeAll
141     public static void classSetup() {
142         final GregorianCalendar cal = new GregorianCalendar(2000, 6, 5, 4, 3, 2);
143         cal.set(Calendar.MILLISECOND, 1);
144         BASE_DATE = cal.getTime();
145     }
146 
147     private static Stream<Arguments> testToLocalDateTimeTimeZone() {
148         // @formatter:off
149         return Stream.of(
150                 // [1]
151                 Arguments.of(
152                         // -292275055-05-16T16:47:04.192
153                         LocalDateTime.of(-292275055, 5, 16, 16, 47, 04, 192_000_000),
154                         new Date(Long.MIN_VALUE),
155                         TimeZones.GMT
156                 ),
157                 // [2]
158                 Arguments.of(
159                         // +292278994-08-17T07:12:55.807
160                         LocalDateTime.of(292278994, 8, 17, 7, 12, 55, 807_000_000),
161                         MAX_DATE,
162                         TimeZones.GMT
163                 ),
164                 // [3]
165                 Arguments.of(
166                         LocalDateTime.ofInstant(Instant.EPOCH, TimeZones.GMT.toZoneId()),
167                         Date.from(LocalDateTime.of(1970, 1, 1, 0, 0).atOffset(ZoneOffset.UTC).toInstant()),
168                         TimeZones.GMT
169                 ),
170                 // [4]
171                 Arguments.of(
172                         LocalDateTime.ofInstant(Instant.EPOCH.minus(1, ChronoUnit.DAYS), TimeZones.GMT.toZoneId()),
173                         Date.from(LocalDateTime.of(1969, 12, 31, 0, 0).atOffset(ZoneOffset.UTC).toInstant()),
174                         TimeZones.GMT
175                 ),
176                 // [5]
177                 Arguments.of(
178                         LocalDateTime.ofInstant(
179                                 java.sql.Timestamp.valueOf("2000-01-01 12:30:45").toInstant(),
180                                 TIME_ZONE_NY.toZoneId()
181                         ),
182                         java.sql.Timestamp.valueOf("2000-01-01 12:30:45"),
183                         TIME_ZONE_NY
184                 ),
185                 // [6]
186                 Arguments.of(
187                         LocalDateTime.ofInstant(
188                                 java.sql.Timestamp.valueOf("2023-03-12 02:30:00").toInstant(),
189                                 TIME_ZONE_NY.toZoneId()
190                         ),
191                         java.sql.Timestamp.valueOf("2023-03-12 02:30:00"),
192                         TIME_ZONE_NY
193                 ),
194                 // [7]
195                 Arguments.of(
196                         LocalDateTime.ofInstant(
197                                 java.sql.Timestamp.valueOf("2023-03-12 02:30:00").toInstant(),
198                                 TimeZones.GMT.toZoneId()
199                         ),
200                         java.sql.Timestamp.valueOf("2023-03-12 02:30:00"),
201                         null
202                 ),
203                 // [8]
204                 Arguments.of(
205                         LocalDateTime.of(2022, 12, 31, 19, 0),
206                         Date.from(LocalDateTime.of(2023, 1, 1, 0, 0).atOffset(ZoneOffset.UTC).toInstant()),
207                         TIME_ZONE_NY
208                 ),
209                 // [9]
210                 Arguments.of(
211                         LocalDateTime.of(2023, 3, 12, 3, 0),
212                         Date.from(LocalDateTime.of(2023, 3, 12, 7, 0).atOffset(ZoneOffset.UTC).toInstant()),
213                         TIME_ZONE_NY
214                 ),
215                 // [10]
216                 Arguments.of(
217                         LocalDateTime.of(2023, 1, 1, 14, 0),
218                         Date.from(LocalDateTime.of(2023, 1, 1, 0, 0).atOffset(ZoneOffset.UTC).toInstant()),
219                         TimeZones.getTimeZone("Pacific/Kiritimati")
220                 )
221         );
222         // @formatter:on
223     }
224 
225     private DateFormat dateParser;
226     private DateFormat dateTimeParser;
227     private Date dateAmPm1;
228     private Date dateAmPm2;
229     private Date dateAmPm3;
230     private Date dateAmPm4;
231     private Date date0;
232     private Date date1;
233     private Date date2;
234     private Date date3;
235     private Date date4;
236     private Date date5;
237     private Date date6;
238     private Date date7;
239     private Date date8;
240     private Date date9;
241     private Calendar calAmPm1;
242     private Calendar calAmPm2;
243     private Calendar calAmPm3;
244     private Calendar calAmPm4;
245     private Calendar cal1;
246     private Calendar cal2;
247     private Calendar cal3;
248     private Calendar cal4;
249     private Calendar cal5;
250     private Calendar cal6;
251     private Calendar cal7;
252     private Calendar cal8;
253 
254     @AfterEach
255     public void afterEachResetTimeZones() {
256         TimeZone.setDefault(TIME_ZONE_DEFAULT);
257         dateTimeParser.setTimeZone(TIME_ZONE_DEFAULT);
258     }
259     private void assertDate(final Date date, final int year, final int month, final int day, final int hour, final int min, final int sec, final int mil) {
260         final GregorianCalendar cal = new GregorianCalendar();
261         cal.setTime(date);
262         assertEquals(year, cal.get(Calendar.YEAR));
263         assertEquals(month, cal.get(Calendar.MONTH));
264         assertEquals(day, cal.get(Calendar.DAY_OF_MONTH));
265         assertEquals(hour, cal.get(Calendar.HOUR_OF_DAY));
266         assertEquals(min, cal.get(Calendar.MINUTE));
267         assertEquals(sec, cal.get(Calendar.SECOND));
268         assertEquals(mil, cal.get(Calendar.MILLISECOND));
269     }
270     @BeforeEach
271     public void setUp() throws Exception {
272         final TimeZone defaultZone = TimeZone.getDefault();
273         dateParser = new SimpleDateFormat("MMM dd, yyyy", Locale.ENGLISH);
274         dateTimeParser = new SimpleDateFormat("MMM dd, yyyy H:mm:ss.SSS", Locale.ENGLISH);
275         dateAmPm1 = dateTimeParser.parse("February 3, 2002 01:10:00.000");
276         dateAmPm2 = dateTimeParser.parse("February 3, 2002 11:10:00.000");
277         dateAmPm3 = dateTimeParser.parse("February 3, 2002 13:10:00.000");
278         dateAmPm4 = dateTimeParser.parse("February 3, 2002 19:10:00.000");
279         date0 = dateTimeParser.parse("February 3, 2002 12:34:56.789");
280         date1 = dateTimeParser.parse("February 12, 2002 12:34:56.789");
281         date2 = dateTimeParser.parse("November 18, 2001 1:23:11.321");
282         try {
283             TimeZone.setDefault(TIME_ZONE_MET);
284             dateTimeParser.setTimeZone(TIME_ZONE_MET);
285             date3 = dateTimeParser.parse("March 30, 2003 05:30:45.000");
286             date4 = dateTimeParser.parse("March 30, 2003 01:10:00.000");
287             date5 = dateTimeParser.parse("March 30, 2003 01:40:00.000");
288             date6 = dateTimeParser.parse("March 30, 2003 02:10:00.000");
289             date7 = dateTimeParser.parse("March 30, 2003 02:40:00.000");
290             date8 = dateTimeParser.parse("October 26, 2003 05:30:45.000");
291         } finally {
292             dateTimeParser.setTimeZone(defaultZone);
293             TimeZone.setDefault(defaultZone);
294         }
295         date9 = dateTimeParser.parse("March 30, 2003 01:10:00.000");
296         calAmPm1 = Calendar.getInstance();
297         calAmPm1.setTime(dateAmPm1);
298         calAmPm2 = Calendar.getInstance();
299         calAmPm2.setTime(dateAmPm2);
300         calAmPm3 = Calendar.getInstance();
301         calAmPm3.setTime(dateAmPm3);
302         calAmPm4 = Calendar.getInstance();
303         calAmPm4.setTime(dateAmPm4);
304         cal1 = Calendar.getInstance();
305         cal1.setTime(date1);
306         cal2 = Calendar.getInstance();
307         cal2.setTime(date2);
308         try {
309             TimeZone.setDefault(TIME_ZONE_MET);
310             cal3 = Calendar.getInstance();
311             cal3.setTime(date3);
312             cal4 = Calendar.getInstance();
313             cal4.setTime(date4);
314             cal5 = Calendar.getInstance();
315             cal5.setTime(date5);
316             cal6 = Calendar.getInstance();
317             cal6.setTime(date6);
318             cal7 = Calendar.getInstance();
319             cal7.setTime(date7);
320             cal8 = Calendar.getInstance();
321             cal8.setTime(date8);
322         } finally {
323             TimeZone.setDefault(defaultZone);
324         }
325     }
326 
327     @Test
328     void testAddDays() throws Exception {
329         Date result = DateUtils.addDays(BASE_DATE, 0);
330         assertNotSame(BASE_DATE, result);
331         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
332         assertDate(result, 2000, 6, 5, 4, 3, 2, 1);
333 
334         result = DateUtils.addDays(BASE_DATE, 1);
335         assertNotSame(BASE_DATE, result);
336         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
337         assertDate(result, 2000, 6, 6, 4, 3, 2, 1);
338 
339         result = DateUtils.addDays(BASE_DATE, -1);
340         assertNotSame(BASE_DATE, result);
341         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
342         assertDate(result, 2000, 6, 4, 4, 3, 2, 1);
343 
344         assertNullPointerException(() -> DateUtils.addDays(null, 0));
345     }
346 
347     @DefaultTimeZone("Europe/Brussels")
348     @Test
349     void testAddDaysDaylightSavingTime() {
350         final TimeZone brusselsTz = TimeZones.getTimeZone("Europe/Brussels");
351 
352         // 2012-03-25 00:00:00 CET: Brussels spring DST transition (23-hour day)
353         final Calendar calSpring = Calendar.getInstance(brusselsTz);
354         calSpring.clear();
355         calSpring.set(2012, Calendar.MARCH, 25, 0, 0, 0);
356         final Date inputSpring = calSpring.getTime();
357 
358         // In Europe/Brussels: calendar day advances to 2012-03-26 00:00:00 CEST (23 hours elapsed)
359         final Date outputSpring = DateUtils.addDays(inputSpring, 1);
360         assertEquals(TimeUnit.HOURS.toMillis(23), outputSpring.getTime() - inputSpring.getTime());
361 
362         final Calendar calSpringResult = Calendar.getInstance(brusselsTz);
363         calSpringResult.setTime(outputSpring);
364         assertEquals(2012, calSpringResult.get(Calendar.YEAR));
365         assertEquals(Calendar.MARCH, calSpringResult.get(Calendar.MONTH));
366         assertEquals(26, calSpringResult.get(Calendar.DAY_OF_MONTH));
367         assertEquals(0, calSpringResult.get(Calendar.HOUR_OF_DAY));
368         assertEquals(inputSpring, DateUtils.addDays(outputSpring, -1));
369         assertEquals(TimeUnit.HOURS.toMillis(24), DateUtils.addHours(inputSpring, 24).getTime() - inputSpring.getTime());
370 
371         // 2012-10-28 00:00:00 CEST: Brussels autumn DST transition (25-hour day)
372         final Calendar calAutumn = Calendar.getInstance(brusselsTz);
373         calAutumn.clear();
374         calAutumn.set(2012, Calendar.OCTOBER, 28, 0, 0, 0);
375         final Date inputAutumn = calAutumn.getTime();
376 
377         // In Europe/Brussels: calendar day advances to 2012-10-29 00:00:00 CET (25 hours elapsed)
378         final Date outputAutumn = DateUtils.addDays(inputAutumn, 1);
379         assertEquals(TimeUnit.HOURS.toMillis(25), outputAutumn.getTime() - inputAutumn.getTime());
380 
381         final Calendar calAutumnResult = Calendar.getInstance(brusselsTz);
382         calAutumnResult.setTime(outputAutumn);
383         assertEquals(2012, calAutumnResult.get(Calendar.YEAR));
384         assertEquals(Calendar.OCTOBER, calAutumnResult.get(Calendar.MONTH));
385         assertEquals(29, calAutumnResult.get(Calendar.DAY_OF_MONTH));
386         assertEquals(0, calAutumnResult.get(Calendar.HOUR_OF_DAY));
387         assertEquals(inputAutumn, DateUtils.addDays(outputAutumn, -1));
388         assertEquals(TimeUnit.HOURS.toMillis(24), DateUtils.addHours(inputAutumn, 24).getTime() - inputAutumn.getTime());
389     }
390 
391     @Test
392     void testAddHours() throws Exception {
393         Date result = DateUtils.addHours(BASE_DATE, 0);
394         assertNotSame(BASE_DATE, result);
395         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
396         assertDate(result, 2000, 6, 5, 4, 3, 2, 1);
397 
398         result = DateUtils.addHours(BASE_DATE, 1);
399         assertNotSame(BASE_DATE, result);
400         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
401         assertDate(result, 2000, 6, 5, 5, 3, 2, 1);
402 
403         result = DateUtils.addHours(BASE_DATE, -1);
404         assertNotSame(BASE_DATE, result);
405         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
406         assertDate(result, 2000, 6, 5, 3, 3, 2, 1);
407 
408         assertNullPointerException(() -> DateUtils.addHours(null, 0));
409     }
410 
411     @Test
412     void testAddMilliseconds() throws Exception {
413         Date result = DateUtils.addMilliseconds(BASE_DATE, 0);
414         assertNotSame(BASE_DATE, result);
415         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
416         assertDate(result, 2000, 6, 5, 4, 3, 2, 1);
417 
418         result = DateUtils.addMilliseconds(BASE_DATE, 1);
419         assertNotSame(BASE_DATE, result);
420         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
421         assertDate(result, 2000, 6, 5, 4, 3, 2, 2);
422 
423         result = DateUtils.addMilliseconds(BASE_DATE, -1);
424         assertNotSame(BASE_DATE, result);
425         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
426         assertDate(result, 2000, 6, 5, 4, 3, 2, 0);
427 
428         assertNullPointerException(() -> DateUtils.addMilliseconds(null, 0));
429     }
430 
431     @Test
432     void testAddMinutes() throws Exception {
433         Date result = DateUtils.addMinutes(BASE_DATE, 0);
434         assertNotSame(BASE_DATE, result);
435         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
436         assertDate(result, 2000, 6, 5, 4, 3, 2, 1);
437 
438         result = DateUtils.addMinutes(BASE_DATE, 1);
439         assertNotSame(BASE_DATE, result);
440         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
441         assertDate(result, 2000, 6, 5, 4, 4, 2, 1);
442 
443         result = DateUtils.addMinutes(BASE_DATE, -1);
444         assertNotSame(BASE_DATE, result);
445         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
446         assertDate(result, 2000, 6, 5, 4, 2, 2, 1);
447 
448         assertNullPointerException(() -> DateUtils.addMinutes(null, 0));
449     }
450 
451     @Test
452     void testAddMonths() throws Exception {
453         Date result = DateUtils.addMonths(BASE_DATE, 0);
454         assertNotSame(BASE_DATE, result);
455         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
456         assertDate(result, 2000, 6, 5, 4, 3, 2, 1);
457 
458         result = DateUtils.addMonths(BASE_DATE, 1);
459         assertNotSame(BASE_DATE, result);
460         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
461         assertDate(result, 2000, 7, 5, 4, 3, 2, 1);
462 
463         result = DateUtils.addMonths(BASE_DATE, -1);
464         assertNotSame(BASE_DATE, result);
465         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
466         assertDate(result, 2000, 5, 5, 4, 3, 2, 1);
467 
468         assertNullPointerException(() -> DateUtils.addMonths(null, 0));
469     }
470 
471     @Test
472     void testAddSeconds() throws Exception {
473         Date result = DateUtils.addSeconds(BASE_DATE, 0);
474         assertNotSame(BASE_DATE, result);
475         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
476         assertDate(result, 2000, 6, 5, 4, 3, 2, 1);
477 
478         result = DateUtils.addSeconds(BASE_DATE, 1);
479         assertNotSame(BASE_DATE, result);
480         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
481         assertDate(result, 2000, 6, 5, 4, 3, 3, 1);
482 
483         result = DateUtils.addSeconds(BASE_DATE, -1);
484         assertNotSame(BASE_DATE, result);
485         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
486         assertDate(result, 2000, 6, 5, 4, 3, 1, 1);
487 
488         assertNullPointerException(() -> DateUtils.addSeconds(null, 0));
489     }
490 
491     @Test
492     void testAddWeeks() throws Exception {
493         Date result = DateUtils.addWeeks(BASE_DATE, 0);
494         assertNotSame(BASE_DATE, result);
495         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
496         assertDate(result, 2000, 6, 5, 4, 3, 2, 1);
497 
498         result = DateUtils.addWeeks(BASE_DATE, 1);
499         assertNotSame(BASE_DATE, result);
500         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
501         assertDate(result, 2000, 6, 12, 4, 3, 2, 1);
502 
503         result = DateUtils.addWeeks(BASE_DATE, -1);
504         assertNotSame(BASE_DATE, result);
505         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);      // july
506         assertDate(result, 2000, 5, 28, 4, 3, 2, 1);   // june
507 
508         assertNullPointerException(() -> DateUtils.addMonths(null, 0));
509     }
510 
511     @Test
512     void testAddYears() throws Exception {
513         Date result = DateUtils.addYears(BASE_DATE, 0);
514         assertNotSame(BASE_DATE, result);
515         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
516         assertDate(result, 2000, 6, 5, 4, 3, 2, 1);
517 
518         result = DateUtils.addYears(BASE_DATE, 1);
519         assertNotSame(BASE_DATE, result);
520         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
521         assertDate(result, 2001, 6, 5, 4, 3, 2, 1);
522 
523         result = DateUtils.addYears(BASE_DATE, -1);
524         assertNotSame(BASE_DATE, result);
525         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
526         assertDate(result, 1999, 6, 5, 4, 3, 2, 1);
527 
528         assertNullPointerException(() -> DateUtils.addYears(null, 0));
529     }
530 
531     /**
532      * Tests various values with the ceiling method
533      *
534      * @throws Exception Thrown if an operation in the test fails.
535      */
536     @Test
537     void testCeiling() throws Exception {
538         // test javadoc
539         assertEquals(dateTimeParser.parse("March 28, 2002 14:00:00.000"),
540                 DateUtils.ceiling(
541                             dateTimeParser.parse("March 28, 2002 13:45:01.231"),
542                         Calendar.HOUR),
543                 "ceiling javadoc-1 failed");
544         assertEquals(dateTimeParser.parse("April 1, 2002 00:00:00.000"),
545                 DateUtils.ceiling(
546                             dateTimeParser.parse("March 28, 2002 13:45:01.231"),
547                         Calendar.MONTH),
548                 "ceiling javadoc-2 failed");
549 
550         // tests public static Date ceiling(Date date, int field)
551         assertEquals(dateParser.parse("January 1, 2003"),
552                 DateUtils.ceiling(date1, Calendar.YEAR),
553                 "ceiling year-1 failed");
554         assertEquals(dateParser.parse("January 1, 2002"),
555                 DateUtils.ceiling(date2, Calendar.YEAR),
556                 "ceiling year-2 failed");
557         assertEquals(dateParser.parse("March 1, 2002"),
558                 DateUtils.ceiling(date1, Calendar.MONTH),
559                 "ceiling month-1 failed");
560         assertEquals(dateParser.parse("December 1, 2001"),
561                 DateUtils.ceiling(date2, Calendar.MONTH),
562                 "ceiling month-2 failed");
563         assertEquals(dateParser.parse("February 16, 2002"),
564                 DateUtils.ceiling(date1, DateUtils.SEMI_MONTH),
565                 "ceiling semimonth-1 failed");
566         assertEquals(dateParser.parse("December 1, 2001"),
567                 DateUtils.ceiling(date2, DateUtils.SEMI_MONTH),
568                 "ceiling semimonth-2 failed");
569         assertEquals(dateParser.parse("February 13, 2002"),
570                 DateUtils.ceiling(date1, Calendar.DATE),
571                 "ceiling date-1 failed");
572         assertEquals(dateParser.parse("November 19, 2001"),
573                 DateUtils.ceiling(date2, Calendar.DATE),
574                 "ceiling date-2 failed");
575         assertEquals(dateTimeParser.parse("February 12, 2002 13:00:00.000"),
576                 DateUtils.ceiling(date1, Calendar.HOUR),
577                 "ceiling hour-1 failed");
578         assertEquals(dateTimeParser.parse("November 18, 2001 2:00:00.000"),
579                 DateUtils.ceiling(date2, Calendar.HOUR),
580                 "ceiling hour-2 failed");
581         assertEquals(dateTimeParser.parse("February 12, 2002 12:35:00.000"),
582                 DateUtils.ceiling(date1, Calendar.MINUTE),
583                 "ceiling minute-1 failed");
584         assertEquals(dateTimeParser.parse("November 18, 2001 1:24:00.000"),
585                 DateUtils.ceiling(date2, Calendar.MINUTE),
586                 "ceiling minute-2 failed");
587         // Edge cases (LANG-771)
588         assertEquals(dateTimeParser.parse("March 30, 2003 01:10:00.000"),
589                 DateUtils.ceiling(date9, Calendar.MINUTE),
590                 "ceiling minute boundary failed");
591         final Date epoch = new Date(0);
592         assertEquals(epoch,
593                 DateUtils.ceiling(epoch, Calendar.MINUTE),
594                 "ceiling minute epoch failed");
595         final Date negative = new Date(-1);
596         assertEquals(new Date(0),
597                 DateUtils.ceiling(negative, Calendar.MINUTE),
598                 "ceiling minute negative failed");
599         assertThrows(ArithmeticException.class,
600                 () -> DateUtils.ceiling(new Date(Long.MIN_VALUE), Calendar.MINUTE),
601                 "ceiling minute Long.MIN_VALUE failed");
602         assertThrows(ArithmeticException.class,
603                 () -> DateUtils.ceiling(new Date(Long.MAX_VALUE), Calendar.MINUTE),
604                 "ceiling minute Long.MAX_VALUE failed");
605         assertEquals(dateTimeParser.parse("February 12, 2002 12:34:57.000"),
606                 DateUtils.ceiling(date1, Calendar.SECOND),
607                 "ceiling second-1 failed");
608         assertEquals(dateTimeParser.parse("November 18, 2001 1:23:12.000"),
609                 DateUtils.ceiling(date2, Calendar.SECOND),
610                 "ceiling second-2 failed");
611         assertEquals(dateTimeParser.parse("February 3, 2002 12:00:00.000"),
612                 DateUtils.ceiling(dateAmPm1, Calendar.AM_PM),
613                 "ceiling ampm-1 failed");
614         assertEquals(dateTimeParser.parse("February 3, 2002 12:00:00.000"),
615                 DateUtils.ceiling(dateAmPm2, Calendar.AM_PM),
616                 "ceiling ampm-2 failed");
617         assertEquals(dateTimeParser.parse("February 4, 2002 00:00:00.000"),
618                 DateUtils.ceiling(dateAmPm3, Calendar.AM_PM),
619                 "ceiling ampm-3 failed");
620         assertEquals(dateTimeParser.parse("February 4, 2002 00:00:00.000"),
621                 DateUtils.ceiling(dateAmPm4, Calendar.AM_PM),
622                 "ceiling ampm-4 failed");
623 
624      // tests public static Date ceiling(Object date, int field)
625         assertEquals(dateParser.parse("January 1, 2003"),
626                 DateUtils.ceiling((Object) date1, Calendar.YEAR),
627                 "ceiling year-1 failed");
628         assertEquals(dateParser.parse("January 1, 2002"),
629                 DateUtils.ceiling((Object) date2, Calendar.YEAR),
630                 "ceiling year-2 failed");
631         assertEquals(dateParser.parse("March 1, 2002"),
632                 DateUtils.ceiling((Object) date1, Calendar.MONTH),
633                 "ceiling month-1 failed");
634         assertEquals(dateParser.parse("December 1, 2001"),
635                 DateUtils.ceiling((Object) date2, Calendar.MONTH),
636                 "ceiling month-2 failed");
637         assertEquals(dateParser.parse("February 16, 2002"),
638                 DateUtils.ceiling((Object) date1, DateUtils.SEMI_MONTH),
639                 "ceiling semimonth-1 failed");
640         assertEquals(dateParser.parse("December 1, 2001"),
641                 DateUtils.ceiling((Object) date2, DateUtils.SEMI_MONTH),
642                 "ceiling semimonth-2 failed");
643         assertEquals(dateParser.parse("February 13, 2002"),
644                 DateUtils.ceiling((Object) date1, Calendar.DATE),
645                 "ceiling date-1 failed");
646         assertEquals(dateParser.parse("November 19, 2001"),
647                 DateUtils.ceiling((Object) date2, Calendar.DATE),
648                 "ceiling date-2 failed");
649         assertEquals(dateTimeParser.parse("February 12, 2002 13:00:00.000"),
650                 DateUtils.ceiling((Object) date1, Calendar.HOUR),
651                 "ceiling hour-1 failed");
652         assertEquals(dateTimeParser.parse("November 18, 2001 2:00:00.000"),
653                 DateUtils.ceiling((Object) date2, Calendar.HOUR),
654                 "ceiling hour-2 failed");
655         assertEquals(dateTimeParser.parse("February 12, 2002 12:35:00.000"),
656                 DateUtils.ceiling((Object) date1, Calendar.MINUTE),
657                 "ceiling minute-1 failed");
658         assertEquals(dateTimeParser.parse("November 18, 2001 1:24:00.000"),
659                 DateUtils.ceiling((Object) date2, Calendar.MINUTE),
660                 "ceiling minute-2 failed");
661         assertEquals(dateTimeParser.parse("February 12, 2002 12:34:57.000"),
662                 DateUtils.ceiling((Object) date1, Calendar.SECOND),
663                 "ceiling second-1 failed");
664         assertEquals(dateTimeParser.parse("November 18, 2001 1:23:12.000"),
665                 DateUtils.ceiling((Object) date2, Calendar.SECOND),
666                 "ceiling second-2 failed");
667         assertEquals(dateTimeParser.parse("February 3, 2002 12:00:00.000"),
668                 DateUtils.ceiling((Object) dateAmPm1, Calendar.AM_PM),
669                 "ceiling ampm-1 failed");
670         assertEquals(dateTimeParser.parse("February 3, 2002 12:00:00.000"),
671                 DateUtils.ceiling((Object) dateAmPm2, Calendar.AM_PM),
672                 "ceiling ampm-2 failed");
673         assertEquals(dateTimeParser.parse("February 4, 2002 00:00:00.000"),
674                 DateUtils.ceiling((Object) dateAmPm3, Calendar.AM_PM),
675                 "ceiling ampm-3 failed");
676         assertEquals(dateTimeParser.parse("February 4, 2002 00:00:00.000"),
677                 DateUtils.ceiling((Object) dateAmPm4, Calendar.AM_PM),
678                 "ceiling ampm-4 failed");
679 
680         assertEquals(dateTimeParser.parse("February 12, 2002 12:34:57.000"),
681                 DateUtils.ceiling((Object) cal1, Calendar.SECOND),
682                 "ceiling calendar second-1 failed");
683         assertEquals(dateTimeParser.parse("November 18, 2001 1:23:12.000"),
684                 DateUtils.ceiling((Object) cal2, Calendar.SECOND),
685                 "ceiling calendar second-2 failed");
686 
687         assertEquals(dateTimeParser.parse("February 3, 2002 12:00:00.000"),
688                 DateUtils.ceiling((Object) calAmPm1, Calendar.AM_PM),
689                 "ceiling ampm-1 failed");
690         assertEquals(dateTimeParser.parse("February 3, 2002 12:00:00.000"),
691                 DateUtils.ceiling((Object) calAmPm2, Calendar.AM_PM),
692                 "ceiling ampm-2 failed");
693         assertEquals(dateTimeParser.parse("February 4, 2002 00:00:00.000"),
694                 DateUtils.ceiling((Object) calAmPm3, Calendar.AM_PM),
695                 "ceiling ampm-3 failed");
696         assertEquals(dateTimeParser.parse("February 4, 2002 00:00:00.000"),
697                 DateUtils.ceiling((Object) calAmPm4, Calendar.AM_PM),
698                 "ceiling ampm-4 failed");
699 
700         assertNullPointerException(() -> DateUtils.ceiling((Date) null, Calendar.SECOND));
701         assertNullPointerException(() -> DateUtils.ceiling((Calendar) null, Calendar.SECOND));
702         assertNullPointerException(() -> DateUtils.ceiling((Object) null, Calendar.SECOND));
703         assertThrows(ClassCastException.class, () -> DateUtils.ceiling("", Calendar.SECOND));
704         assertIllegalArgumentException(() -> DateUtils.ceiling(date1, -9999));
705 
706     }
707 
708     /**
709      * Tests various values with the ceiling method
710      *
711      * @throws Exception Thrown if an operation in the test fails.
712      */
713     @Test
714     void testCeiling_Bugzilla_31395() throws Exception {
715         // Bug 31395, large dates
716         final Date endOfTime = MAX_DATE; // fyi: Sun Aug 17 07:12:55 CET 292278994 -- 807 millis
717         final GregorianCalendar endCal = new GregorianCalendar();
718         endCal.setTime(endOfTime);
719         assertThrows(ArithmeticException.class, () -> DateUtils.ceiling(endCal, Calendar.DATE));
720         endCal.set(Calendar.YEAR, 280000001);
721         assertThrows(ArithmeticException.class, () -> DateUtils.ceiling(endCal, Calendar.DATE));
722         endCal.set(Calendar.YEAR, 280000000);
723         final Calendar cal = DateUtils.ceiling(endCal, Calendar.DATE);
724         assertEquals(0, cal.get(Calendar.HOUR));
725     }
726 
727     /**
728      * Tests various values with the ceiling method
729      *
730      * @throws Exception Thrown if an operation in the test fails.
731      */
732     @Test
733     void testCeiling_MET() throws Exception {
734         // Fix for https://issues.apache.org/bugzilla/show_bug.cgi?id=25560
735         // Test ceiling across the beginning of daylight saving time
736         TimeZone.setDefault(TIME_ZONE_MET);
737         dateTimeParser.setTimeZone(TIME_ZONE_MET);
738 
739         assertEquals(dateTimeParser.parse("March 31, 2003 00:00:00.000"), DateUtils.ceiling(date4, Calendar.DATE), "ceiling MET date across DST change-over");
740         assertEquals(dateTimeParser.parse("March 31, 2003 00:00:00.000"), DateUtils.ceiling((Object) cal4, Calendar.DATE),
741                 "ceiling MET date across DST change-over");
742         assertEquals(dateTimeParser.parse("March 31, 2003 00:00:00.000"), DateUtils.ceiling(date5, Calendar.DATE), "ceiling MET date across DST change-over");
743         assertEquals(dateTimeParser.parse("March 31, 2003 00:00:00.000"), DateUtils.ceiling((Object) cal5, Calendar.DATE),
744                 "ceiling MET date across DST change-over");
745         assertEquals(dateTimeParser.parse("March 31, 2003 00:00:00.000"), DateUtils.ceiling(date6, Calendar.DATE), "ceiling MET date across DST change-over");
746         assertEquals(dateTimeParser.parse("March 31, 2003 00:00:00.000"), DateUtils.ceiling((Object) cal6, Calendar.DATE),
747                 "ceiling MET date across DST change-over");
748         assertEquals(dateTimeParser.parse("March 31, 2003 00:00:00.000"), DateUtils.ceiling(date7, Calendar.DATE), "ceiling MET date across DST change-over");
749         assertEquals(dateTimeParser.parse("March 31, 2003 00:00:00.000"), DateUtils.ceiling((Object) cal7, Calendar.DATE),
750                 "ceiling MET date across DST change-over");
751 
752         assertEquals(dateTimeParser.parse("March 30, 2003 03:00:00.000"), DateUtils.ceiling(date4, Calendar.HOUR_OF_DAY),
753                 "ceiling MET date across DST change-over");
754         assertEquals(dateTimeParser.parse("March 30, 2003 03:00:00.000"), DateUtils.ceiling((Object) cal4, Calendar.HOUR_OF_DAY),
755                 "ceiling MET date across DST change-over");
756         assertEquals(dateTimeParser.parse("March 30, 2003 03:00:00.000"), DateUtils.ceiling(date5, Calendar.HOUR_OF_DAY),
757                 "ceiling MET date across DST change-over");
758         assertEquals(dateTimeParser.parse("March 30, 2003 03:00:00.000"), DateUtils.ceiling((Object) cal5, Calendar.HOUR_OF_DAY),
759                 "ceiling MET date across DST change-over");
760         assertEquals(dateTimeParser.parse("March 30, 2003 04:00:00.000"), DateUtils.ceiling(date6, Calendar.HOUR_OF_DAY),
761                 "ceiling MET date across DST change-over");
762         assertEquals(dateTimeParser.parse("March 30, 2003 04:00:00.000"), DateUtils.ceiling((Object) cal6, Calendar.HOUR_OF_DAY),
763                 "ceiling MET date across DST change-over");
764         assertEquals(dateTimeParser.parse("March 30, 2003 04:00:00.000"), DateUtils.ceiling(date7, Calendar.HOUR_OF_DAY),
765                 "ceiling MET date across DST change-over");
766         assertEquals(dateTimeParser.parse("March 30, 2003 04:00:00.000"), DateUtils.ceiling((Object) cal7, Calendar.HOUR_OF_DAY),
767                 "ceiling MET date across DST change-over");
768     }
769 
770     /**
771      * Tests that clearing sub-hour fields does not spuriously select the later occurrence of an overlapping local time.
772      *
773      * @param milliseconds the millisecond value below, at, or above the rounding threshold.
774      */
775     @DefaultTimeZone("Europe/London")
776     @ParameterizedTest
777     @ValueSource(ints = { 245, 499, 500, 999 })
778     void testCeilingAndRoundDstOverlap(final int milliseconds) {
779         // 2024-10-27 01:00-02:00 BST repeats as 01:00-02:00 GMT; ZonedDateTime.of() picks the earlier offset, BST.
780         final ZonedDateTime bst = ZonedDateTime.of(2024, 10, 27, 1, 8, 58, milliseconds * 1_000_000, ZoneId.of("Europe/London"));
781         assertEquals(ZoneOffset.ofHours(1), bst.getOffset());
782         final ZonedDateTime gmt = bst.withLaterOffsetAtOverlap();
783         assertEquals(ZoneOffset.UTC, gmt.getOffset());
784         for (final ZonedDateTime zdt : new ZonedDateTime[] { bst, gmt }) {
785             final Date date = Date.from(zdt.toInstant());
786             final ZonedDateTime second = zdt.truncatedTo(ChronoUnit.SECONDS);
787             final ZonedDateTime minute = zdt.truncatedTo(ChronoUnit.MINUTES);
788             final ZonedDateTime hour = zdt.truncatedTo(ChronoUnit.HOURS);
789             assertEquals(Date.from(zdt.truncatedTo(ChronoUnit.SECONDS).plusSeconds(1).toInstant()), DateUtils.ceiling(date, Calendar.SECOND), "Ceiling Calendar.SECOND " + zdt);
790             assertEquals(Date.from(second.plusSeconds(milliseconds >= 500 ? 1 : 0).toInstant()), DateUtils.round(date, Calendar.SECOND),
791                     "Round Calendar.SECOND " + zdt);
792             assertEquals(Date.from(minute.plusMinutes(1).toInstant()), DateUtils.ceiling(date, Calendar.MINUTE), "Ceiling Calendar.MINUTE " + zdt);
793             assertEquals(Date.from(minute.plusMinutes(1).toInstant()), DateUtils.round(date, Calendar.MINUTE), "Round Calendar.MINUTE " + zdt);
794             assertEquals(Date.from(hour.plusHours(1).toInstant()), DateUtils.ceiling(date, Calendar.HOUR_OF_DAY), "Ceiling Calendar.HOUR_OF_DAY " + zdt);
795             assertEquals(Date.from(hour.plusHours(1).toInstant()), DateUtils.ceiling(date, Calendar.HOUR), "Ceiling Calendar.HOUR " + zdt);
796             assertEquals(Date.from(hour.toInstant()), DateUtils.round(date, Calendar.HOUR_OF_DAY), "Round Calendar.HOUR_OF_DAY " + zdt);
797             // 38 minutes past rounds up to the next hour
798             final Date late = Date.from(zdt.withMinute(38).toInstant());
799             assertEquals(Date.from(hour.plusHours(1).toInstant()), DateUtils.round(late, Calendar.HOUR_OF_DAY), "Round up Calendar.HOUR_OF_DAY " + zdt);
800             assertEquals(Date.from(hour.plusHours(1).toInstant()), DateUtils.round(late, Calendar.HOUR), "Round up Calendar.HOUR " + zdt);
801         }
802     }
803 
804     /**
805      * Tests that clearing sub-hour fields does not spuriously select the later occurrence of an overlapping local time.
806      *
807      * @param milliseconds the millisecond value below, at, or above the rounding threshold.
808      */
809     @DefaultTimeZone("UTC")
810     @ParameterizedTest
811     @ValueSource(ints = { 245, 499, 500, 999 })
812     void testCeilingAndRoundDstOverlapCalendar(final int milliseconds) {
813         // 2024-10-27 01:00-02:00 BST repeats as 01:00-02:00 GMT; ZonedDateTime.of() picks the earlier offset, BST.
814         final ZonedDateTime bst = ZonedDateTime.of(2024, 10, 27, 1, 8, 58, milliseconds * 1_000_000, ZoneId.of("Europe/London"));
815         assertEquals(ZoneOffset.ofHours(1), bst.getOffset());
816         final ZonedDateTime gmt = bst.withLaterOffsetAtOverlap();
817         assertEquals(ZoneOffset.UTC, gmt.getOffset());
818         for (final ZonedDateTime zdt : new ZonedDateTime[] { bst, gmt }) {
819             final Calendar date = GregorianCalendar.from(zdt);
820             final Calendar original = (Calendar) date.clone();
821             final ZonedDateTime second = zdt.truncatedTo(ChronoUnit.SECONDS);
822             final ZonedDateTime minute = zdt.truncatedTo(ChronoUnit.MINUTES);
823             final ZonedDateTime hour = zdt.truncatedTo(ChronoUnit.HOURS);
824             assertEquals(Date.from(zdt.truncatedTo(ChronoUnit.SECONDS).plusSeconds(1).toInstant()), DateUtils.ceiling(date, Calendar.SECOND).getTime(), "Ceiling Calendar.SECOND " + zdt);
825             assertEquals(Date.from(second.plusSeconds(milliseconds >= 500 ? 1 : 0).toInstant()), DateUtils.round(date, Calendar.SECOND).getTime(),
826                     "Round Calendar.SECOND " + zdt);
827             assertEquals(Date.from(minute.plusMinutes(1).toInstant()), DateUtils.ceiling(date, Calendar.MINUTE).getTime(), "Ceiling Calendar.MINUTE " + zdt);
828             assertEquals(Date.from(minute.plusMinutes(1).toInstant()), DateUtils.round(date, Calendar.MINUTE).getTime(), "Round Calendar.MINUTE " + zdt);
829             assertEquals(Date.from(hour.plusHours(1).toInstant()), DateUtils.ceiling(date, Calendar.HOUR_OF_DAY).getTime(), "Ceiling Calendar.HOUR_OF_DAY " + zdt);
830             assertEquals(Date.from(hour.plusHours(1).toInstant()), DateUtils.ceiling(date, Calendar.HOUR).getTime(), "Ceiling Calendar.HOUR " + zdt);
831             assertEquals(Date.from(hour.toInstant()), DateUtils.round(date, Calendar.HOUR_OF_DAY).getTime(), "Round Calendar.HOUR_OF_DAY " + zdt);
832             // 38 minutes past rounds up to the next hour
833             final Calendar late = GregorianCalendar.from(zdt.withMinute(38));
834             assertEquals(Date.from(hour.plusHours(1).toInstant()), DateUtils.round(late, Calendar.HOUR_OF_DAY).getTime(), "Round up Calendar.HOUR_OF_DAY " + zdt);
835             assertEquals(Date.from(hour.plusHours(1).toInstant()), DateUtils.round(late, Calendar.HOUR).getTime(), "Round up Calendar.HOUR " + zdt);
836             assertEquals(zdt.getZone().getId(), DateUtils.ceiling(date, Calendar.HOUR_OF_DAY).getTimeZone().getID());
837             assertEquals(original, date, "Input calendar must remain unchanged");
838         }
839     }
840 
841     @Test
842     void testConstructor() {
843         assertNotNull(new DateUtils());
844         final Constructor<?>[] cons = DateUtils.class.getDeclaredConstructors();
845         assertEquals(1, cons.length);
846         assertTrue(Modifier.isPublic(cons[0].getModifiers()));
847         assertTrue(Modifier.isPublic(DateUtils.class.getModifiers()));
848         assertFalse(Modifier.isFinal(DateUtils.class.getModifiers()));
849     }
850 
851     /**
852      * Failed date parse can poison the calendar's time zone for the next pattern.
853      *
854      * <p>
855      * {@link DateUtils#parseDateWithLeniency} reuses a single {@link Calendar} across pattern attempts. The reset between iterations is
856      * {@link Calendar#clear()}, which does NOT reset the calendar's time zone. A TZ-aware pattern (e.g. starts with {@code "X"}, {@code "Z"}, {@code "z"}) that
857      * successfully consumes its TZ token (mutating the calendar via {@link Calendar#setTimeZone}) before failing on later tokens leaves the calendar carrying
858      * the parsed (foreign) zone. The next pattern in the list then interprets its date fields against that zone, producing a wrong instant.
859      * </p>
860      *
861      * <p>
862      * <b>Construction:</b> input {@code "+0500 01/01/2024"} is parsed against two patterns:
863      * </p>
864      * <ol>
865      * <li>{@code "Z 'X' MM/dd/yyyy"}: the {@code Z} strategy consumes {@code "+0500"} and calls {@code calendar.setTimeZone(GMT+05:00)}; the next literal
866      * {@code 'X'} fails to match {@code " 01"}, so the overall parse returns false. The leaked TZ remains on the shared calendar.</li>
867      * <li>{@code "'+0500 'MM/dd/yyyy"}: a TZ-less pattern that absorbs the literal prefix and parses the date. With the bug, the calendar still carries
868      * GMT+05:00, so the date is interpreted as midnight in GMT+05:00 (5 hours earlier as an instant) than the same date interpreted in the system default
869      * zone.</li>
870      * </ol>
871      *
872      * <p>
873      * The assertion compares {@link Date#getTime()} against a baseline parse using only the second pattern. A naive PoC that only checked calendar fields
874      * (year/month/day) would not detect the bug because those equal in both runs.
875      * </p>
876      *
877      * <p>
878      * Pre-patch: the bug shifts the resulting instant by 5 hours.<br>
879      * Post-patch: {@code parseDateWithLeniency} restores {@code calendar.setTimeZone(TimeZone.getDefault())} before each iteration, so the leaked zone never
880      * reaches the second attempt and both instants match.
881      * </p>
882      */
883     @Test
884     public void testFailedTimeZonePatternDoesNotPoisonNextPatternInstant() throws Exception {
885         final String input = "+0500 01/01/2024";
886         // Baseline: a single TZ-less pattern; no leak source. The calendar uses
887         // TimeZone.getDefault(), so the result is midnight 2024-01-01 in the default zone.
888         final Date baseline = DateUtils.parseDate(input, "'+0500 'MM/dd/yyyy");
889         assertNotNull(baseline, "baseline parse must succeed");
890         // Poisoning sequence:
891         //   pattern 1 = "Z 'X' MM/dd/yyyy"  -> Z consumes "+0500" then setTimeZone(GMT+05:00),
892         //                                       'X' literal mismatches " 01", returns false.
893         //   pattern 2 = "'+0500 'MM/dd/yyyy"-> matches the whole input via literal prefix +
894         //                                       MM/dd/yyyy. With the bug, calendar still has
895         //                                       GMT+05:00 leaked from pattern 1, so the date
896         //                                       is interpreted in GMT+05:00 instead of default.
897         final Date poisoned = DateUtils.parseDate(input, "Z 'X' MM/dd/yyyy", "'+0500 'MM/dd/yyyy");
898         assertNotNull(poisoned, "poisoning sequence parse must succeed via the second pattern");
899         // Compare INSTANTS, not Y/M/D. Calendar fields equal in both runs by coincidence
900         // even when the bug shifts the underlying instant.
901         assertEquals(baseline.getTime(), poisoned.getTime(),
902                 "Calendar TZ leaked from a failed prior pattern must not affect the instant produced by a subsequent TZ-less pattern");
903     }
904 
905     @Test
906     void testIsSameDay_Cal() {
907         final GregorianCalendar cala = new GregorianCalendar(2004, 6, 9, 13, 45);
908         final GregorianCalendar calb = new GregorianCalendar(2004, 6, 9, 13, 45);
909         assertTrue(DateUtils.isSameDay(cala, calb));
910         calb.add(Calendar.DAY_OF_YEAR, 1);
911         assertFalse(DateUtils.isSameDay(cala, calb));
912         cala.add(Calendar.DAY_OF_YEAR, 1);
913         assertTrue(DateUtils.isSameDay(cala, calb));
914         calb.add(Calendar.YEAR, 1);
915         assertFalse(DateUtils.isSameDay(cala, calb));
916     }
917 
918     @Test
919     void testIsSameDay_CalNotNullNull() {
920         assertNullPointerException(() -> DateUtils.isSameDay(Calendar.getInstance(), null));
921     }
922 
923     @Test
924     void testIsSameDay_CalNullNotNull() {
925         assertNullPointerException(() -> DateUtils.isSameDay(null, Calendar.getInstance()));
926     }
927 
928     @Test
929     void testIsSameDay_CalNullNull() {
930         assertNullPointerException(() -> DateUtils.isSameDay((Calendar) null, null));
931     }
932 
933     @Test
934     void testIsSameDay_Date() {
935         Date dateA = new GregorianCalendar(2004, 6, 9, 13, 45).getTime();
936         Date dateB = new GregorianCalendar(2004, 6, 9, 13, 45).getTime();
937         assertTrue(DateUtils.isSameDay(dateA, dateB));
938         dateB = new GregorianCalendar(2004, 6, 10, 13, 45).getTime();
939         assertFalse(DateUtils.isSameDay(dateA, dateB));
940         dateA = new GregorianCalendar(2004, 6, 10, 13, 45).getTime();
941         assertTrue(DateUtils.isSameDay(dateA, dateB));
942         dateB = new GregorianCalendar(2005, 6, 10, 13, 45).getTime();
943         assertFalse(DateUtils.isSameDay(dateA, dateB));
944         assertTrue(DateUtils.isSameDay(dateA, dateA));
945         assertTrue(DateUtils.isSameDay(dateA, (Date) dateA.clone()));
946         assertTrue(DateUtils.isSameDay(MAX_DATE, MAX_DATE));
947         assertTrue(DateUtils.isSameDay(MAX_DATE, (Date) MAX_DATE.clone()));
948     }
949 
950     @Test
951     void testIsSameDay_DateNotNullNull() {
952         assertNullPointerException(() -> DateUtils.isSameDay(new Date(), null));
953     }
954 
955     @Test
956     void testIsSameDay_DateNullNotNull() {
957         assertNullPointerException(() -> DateUtils.isSameDay(null, new Date()));
958     }
959 
960     @Test
961     void testIsSameDay_DateNullNull() {
962         assertNullPointerException(() -> DateUtils.isSameDay((Date) null, null));
963     }
964 
965     @Test
966     void testIsSameInstant_Cal() {
967         final GregorianCalendar cala = new GregorianCalendar(TimeZones.getTimeZone("GMT+1"));
968         final GregorianCalendar calb = new GregorianCalendar(TimeZones.getTimeZone("GMT-1"));
969         cala.set(2004, Calendar.JULY, 9, 13, 45, 0);
970         cala.set(Calendar.MILLISECOND, 0);
971         calb.set(2004, Calendar.JULY, 9, 13, 45, 0);
972         calb.set(Calendar.MILLISECOND, 0);
973         assertFalse(DateUtils.isSameInstant(cala, calb));
974 
975         calb.set(2004, Calendar.JULY, 9, 11, 45, 0);
976         assertTrue(DateUtils.isSameInstant(cala, calb));
977     }
978 
979     @Test
980     void testIsSameInstant_CalNotNullNull() {
981         assertNullPointerException(() -> DateUtils.isSameInstant(Calendar.getInstance(), null));
982     }
983 
984     @Test
985     void testIsSameInstant_CalNullNotNull() {
986         assertNullPointerException(() -> DateUtils.isSameInstant(null, Calendar.getInstance()));
987     }
988 
989     @Test
990     void testIsSameInstant_CalNullNull() {
991         assertNullPointerException(() -> DateUtils.isSameInstant((Calendar) null, null));
992     }
993 
994     @Test
995     void testIsSameInstant_Date() {
996         Date datea = new GregorianCalendar(2004, 6, 9, 13, 45).getTime();
997         Date dateb = new GregorianCalendar(2004, 6, 9, 13, 45).getTime();
998         assertTrue(DateUtils.isSameInstant(datea, dateb));
999         dateb = new GregorianCalendar(2004, 6, 10, 13, 45).getTime();
1000         assertFalse(DateUtils.isSameInstant(datea, dateb));
1001         datea = new GregorianCalendar(2004, 6, 10, 13, 45).getTime();
1002         assertTrue(DateUtils.isSameInstant(datea, dateb));
1003         dateb = new GregorianCalendar(2005, 6, 10, 13, 45).getTime();
1004         assertFalse(DateUtils.isSameInstant(datea, dateb));
1005     }
1006 
1007     @Test
1008     void testIsSameInstant_DateNotNullNull() {
1009         assertNullPointerException(() -> DateUtils.isSameInstant(new Date(), null));
1010     }
1011 
1012     @Test
1013     void testIsSameInstant_DateNullNotNull() {
1014         assertNullPointerException(() -> DateUtils.isSameInstant(null, new Date()));
1015     }
1016 
1017     @Test
1018     void testIsSameInstant_DateNullNull() {
1019         assertNullPointerException(() -> DateUtils.isSameInstant((Date) null, null));
1020     }
1021 
1022     @Test
1023     void testIsSameLocalTime_Cal() {
1024         final GregorianCalendar cala = new GregorianCalendar(TimeZones.getTimeZone("GMT+1"));
1025         final GregorianCalendar calb = new GregorianCalendar(TimeZones.getTimeZone("GMT-1"));
1026         cala.set(2004, Calendar.JULY, 9, 13, 45, 0);
1027         cala.set(Calendar.MILLISECOND, 0);
1028         calb.set(2004, Calendar.JULY, 9, 13, 45, 0);
1029         calb.set(Calendar.MILLISECOND, 0);
1030         assertTrue(DateUtils.isSameLocalTime(cala, calb));
1031 
1032         final Calendar calc = Calendar.getInstance();
1033         final Calendar cald = Calendar.getInstance();
1034         calc.set(2004, Calendar.JULY, 9, 4,  0, 0);
1035         cald.set(2004, Calendar.JULY, 9, 16, 0, 0);
1036         calc.set(Calendar.MILLISECOND, 0);
1037         cald.set(Calendar.MILLISECOND, 0);
1038         assertFalse(DateUtils.isSameLocalTime(calc, cald), "LANG-677");
1039 
1040         calb.set(2004, Calendar.JULY, 9, 11, 45, 0);
1041         assertFalse(DateUtils.isSameLocalTime(cala, calb));
1042     }
1043 
1044     @Test
1045     void testIsSameLocalTime_CalNotNullNull() {
1046         assertNullPointerException(() -> DateUtils.isSameLocalTime(Calendar.getInstance(), null));
1047     }
1048 
1049     @Test
1050     void testIsSameLocalTime_CalNullNotNull() {
1051         assertNullPointerException(() -> DateUtils.isSameLocalTime(null, Calendar.getInstance()));
1052     }
1053 
1054     @Test
1055     void testIsSameLocalTime_CalNullNull() {
1056         assertNullPointerException(() -> DateUtils.isSameLocalTime(null, null));
1057     }
1058 
1059     /**
1060      * Tests the iterator exceptions
1061      */
1062     @Test
1063     void testIteratorEx() {
1064         assertIllegalArgumentException(() -> DateUtils.iterator(Calendar.getInstance(), -9999));
1065         assertNullPointerException(() -> DateUtils.iterator((Date) null, DateUtils.RANGE_WEEK_CENTER));
1066         assertNullPointerException(() -> DateUtils.iterator((Calendar) null, DateUtils.RANGE_WEEK_CENTER));
1067         assertNullPointerException(() -> DateUtils.iterator((Object) null, DateUtils.RANGE_WEEK_CENTER));
1068         assertThrows(ClassCastException.class, () -> DateUtils.iterator("", DateUtils.RANGE_WEEK_CENTER));
1069     }
1070 
1071     /** See https://issues.apache.org/jira/browse/LANG-530 */
1072     @SuppressWarnings("deprecation")
1073     @Test
1074     void testLang530() throws ParseException {
1075         final Date d = new Date();
1076         final String isoDateStr = DateFormatUtils.ISO_DATETIME_TIME_ZONE_FORMAT.format(d);
1077         final Date d2 = DateUtils.parseDate(isoDateStr, DateFormatUtils.ISO_DATETIME_TIME_ZONE_FORMAT.getPattern());
1078         // the format loses milliseconds so have to reintroduce them
1079         assertEquals(d.getTime(), d2.getTime() + d.getTime() % 1000, "Date not equal to itself ISO formatted and parsed");
1080     }
1081 
1082     @Test
1083     void testLANG799() throws ParseException {
1084         DateUtils.parseDateStrictly("09 abril 2008 23:55:38 GMT", new Locale("es"), "dd MMM yyyy HH:mm:ss zzz");
1085     }
1086 
1087     /** Parse English date with German Locale. */
1088     @DefaultLocale(language = "de")
1089     @Test
1090     void testLANG799_DE_FAIL() {
1091         assertThrows(ParseException.class, () -> DateUtils.parseDate("Wed, 09 Apr 2008 23:55:38 GMT", "EEE, dd MMM yyyy HH:mm:ss zzz"));
1092     }
1093 
1094     @DefaultLocale(language = "de")
1095     @Test
1096     void testLANG799_DE_OK() throws ParseException {
1097         DateUtils.parseDate("Mi, 09 Apr 2008 23:55:38 GMT", "EEE, dd MMM yyyy HH:mm:ss zzz");
1098         DateUtils.parseDateStrictly("Mi, 09 Apr 2008 23:55:38 GMT", "EEE, dd MMM yyyy HH:mm:ss zzz");
1099     }
1100 
1101     // Parse German date with English Locale
1102     @DefaultLocale(language = "en")
1103     @Test
1104     void testLANG799_EN_FAIL() {
1105         assertThrows(ParseException.class, () -> DateUtils.parseDate("Mi, 09 Apr 2008 23:55:38 GMT", "EEE, dd MMM yyyy HH:mm:ss zzz"));
1106     }
1107 
1108     @DefaultLocale(language = "en")
1109     @Test
1110     void testLANG799_EN_OK() throws ParseException {
1111         DateUtils.parseDate("Wed, 09 Apr 2008 23:55:38 GMT", "EEE, dd MMM yyyy HH:mm:ss zzz");
1112         DateUtils.parseDateStrictly("Wed, 09 Apr 2008 23:55:38 GMT", "EEE, dd MMM yyyy HH:mm:ss zzz");
1113     }
1114 
1115     /** Parse German date with English Locale, specifying German Locale override. */
1116     @DefaultLocale(language = "en")
1117     @Test
1118     void testLANG799_EN_WITH_DE_LOCALE() throws ParseException {
1119         DateUtils.parseDate("Mi, 09 Apr 2008 23:55:38 GMT", Locale.GERMAN, "EEE, dd MMM yyyy HH:mm:ss zzz");
1120     }
1121 
1122     /**
1123      * Tests the calendar iterator for month-based ranges
1124      *
1125      * @throws Exception Thrown if an operation in the test fails.
1126      */
1127     @Test
1128     void testMonthIterator() throws Exception {
1129         Iterator<?> it = DateUtils.iterator(date1, DateUtils.RANGE_MONTH_SUNDAY);
1130         assertWeekIterator(it,
1131                 dateParser.parse("January 27, 2002"),
1132                 dateParser.parse("March 2, 2002"));
1133 
1134         it = DateUtils.iterator(date1, DateUtils.RANGE_MONTH_MONDAY);
1135         assertWeekIterator(it,
1136                 dateParser.parse("January 28, 2002"),
1137                 dateParser.parse("March 3, 2002"));
1138 
1139         it = DateUtils.iterator(date2, DateUtils.RANGE_MONTH_SUNDAY);
1140         assertWeekIterator(it,
1141                 dateParser.parse("October 28, 2001"),
1142                 dateParser.parse("December 1, 2001"));
1143 
1144         it = DateUtils.iterator(date2, DateUtils.RANGE_MONTH_MONDAY);
1145         assertWeekIterator(it,
1146                 dateParser.parse("October 29, 2001"),
1147                 dateParser.parse("December 2, 2001"));
1148     }
1149 
1150     @Test
1151     void testParse_EmptyParsers() {
1152         assertThrows(ParseException.class, () -> DateUtils.parseDate("19721203"));
1153     }
1154 
1155     @Test
1156     void testParse_NullParsers() {
1157         assertNullPointerException(() -> DateUtils.parseDate("19721203", (String[]) null));
1158     }
1159 
1160     @Test
1161     void testParseDate() throws Exception {
1162         final GregorianCalendar cal = new GregorianCalendar(1972, 11, 3);
1163         String dateStr = "1972-12-03";
1164         final String[] parsers = {"yyyy'-'DDD", "yyyy'-'MM'-'dd", "yyyyMMdd"};
1165         Date date = DateUtils.parseDate(dateStr, parsers);
1166         assertEquals(cal.getTime(), date);
1167 
1168         dateStr = "1972-338";
1169         date = DateUtils.parseDate(dateStr, parsers);
1170         assertEquals(cal.getTime(), date);
1171 
1172         dateStr = "19721203";
1173         date = DateUtils.parseDate(dateStr, parsers);
1174         assertEquals(cal.getTime(), date);
1175     }
1176 
1177     @Test
1178     void testParseDate_InvalidDateString() {
1179         final String[] parsers = {"yyyy'-'DDD", "yyyy'-'MM'-'dd", "yyyyMMdd"};
1180         assertThrows(ParseException.class, () -> DateUtils.parseDate("197212AB", parsers));
1181     }
1182 
1183     @Test
1184     void testParseDate_NoDateString() {
1185         final String[] parsers = {"yyyy'-'DDD", "yyyy'-'MM'-'dd", "yyyyMMdd"};
1186         assertThrows(ParseException.class, () -> DateUtils.parseDate("PURPLE", parsers));
1187     }
1188 
1189     @Test
1190     void testParseDate_Null() {
1191         final String[] parsers = {"yyyy'-'DDD", "yyyy'-'MM'-'dd", "yyyyMMdd"};
1192         assertNullPointerException(() -> DateUtils.parseDate(null, parsers));
1193     }
1194 
1195     /** LANG-486 */
1196     @Test
1197     void testParseDateWithLeniency() throws ParseException {
1198         final GregorianCalendar cal = new GregorianCalendar(1998, 6, 30);
1199         final String dateStr = "02 942, 1996";
1200         final String[] parsers = {"MM DDD, yyyy"};
1201 
1202         final Date date = DateUtils.parseDate(dateStr, parsers);
1203         assertEquals(cal.getTime(), date);
1204 
1205         assertThrows(ParseException.class, () -> DateUtils.parseDateStrictly(dateStr, parsers));
1206     }
1207 
1208     /**
1209      * Tests various values with the round method
1210      *
1211      * @throws Exception Thrown if an operation in the test fails.
1212      */
1213     @Test
1214     void testRound() throws Exception {
1215         // tests for public static Date round(Date date, int field)
1216         assertEquals(dateParser.parse("January 1, 2002"), DateUtils.round(date1, Calendar.YEAR), "round year-1 failed");
1217         assertEquals(dateParser.parse("January 1, 2002"), DateUtils.round(date2, Calendar.YEAR), "round year-2 failed");
1218         assertEquals(dateParser.parse("February 1, 2002"), DateUtils.round(date1, Calendar.MONTH), "round month-1 failed");
1219         assertEquals(dateParser.parse("December 1, 2001"), DateUtils.round(date2, Calendar.MONTH), "round month-2 failed");
1220         assertEquals(dateParser.parse("February 1, 2002"), DateUtils.round(date0, DateUtils.SEMI_MONTH), "round semimonth-0 failed");
1221         assertEquals(dateParser.parse("February 16, 2002"), DateUtils.round(date1, DateUtils.SEMI_MONTH), "round semimonth-1 failed");
1222         assertEquals(dateParser.parse("November 16, 2001"), DateUtils.round(date2, DateUtils.SEMI_MONTH), "round semimonth-2 failed");
1223 
1224         assertEquals(dateParser.parse("February 13, 2002"), DateUtils.round(date1, Calendar.DATE), "round date-1 failed");
1225         assertEquals(dateParser.parse("November 18, 2001"), DateUtils.round(date2, Calendar.DATE), "round date-2 failed");
1226         assertEquals(dateTimeParser.parse("February 12, 2002 13:00:00.000"), DateUtils.round(date1, Calendar.HOUR), "round hour-1 failed");
1227         assertEquals(dateTimeParser.parse("November 18, 2001 1:00:00.000"), DateUtils.round(date2, Calendar.HOUR), "round hour-2 failed");
1228         assertEquals(dateTimeParser.parse("February 12, 2002 12:35:00.000"), DateUtils.round(date1, Calendar.MINUTE), "round minute-1 failed");
1229         assertEquals(dateTimeParser.parse("November 18, 2001 1:23:00.000"), DateUtils.round(date2, Calendar.MINUTE), "round minute-2 failed");
1230         assertEquals(dateTimeParser.parse("February 12, 2002 12:34:57.000"), DateUtils.round(date1, Calendar.SECOND), "round second-1 failed");
1231         assertEquals(dateTimeParser.parse("November 18, 2001 1:23:11.000"), DateUtils.round(date2, Calendar.SECOND), "round second-2 failed");
1232         assertEquals(dateTimeParser.parse("February 3, 2002 00:00:00.000"), DateUtils.round(dateAmPm1, Calendar.AM_PM), "round ampm-1 failed");
1233         assertEquals(dateTimeParser.parse("February 3, 2002 12:00:00.000"), DateUtils.round(dateAmPm2, Calendar.AM_PM), "round ampm-2 failed");
1234         assertEquals(dateTimeParser.parse("February 3, 2002 12:00:00.000"), DateUtils.round(dateAmPm3, Calendar.AM_PM), "round ampm-3 failed");
1235         assertEquals(dateTimeParser.parse("February 4, 2002 00:00:00.000"), DateUtils.round(dateAmPm4, Calendar.AM_PM), "round ampm-4 failed");
1236 
1237         // tests for public static Date round(Object date, int field)
1238         assertEquals(dateParser.parse("January 1, 2002"), DateUtils.round((Object) date1, Calendar.YEAR), "round year-1 failed");
1239         assertEquals(dateParser.parse("January 1, 2002"), DateUtils.round((Object) date2, Calendar.YEAR), "round year-2 failed");
1240         assertEquals(dateParser.parse("February 1, 2002"), DateUtils.round((Object) date1, Calendar.MONTH), "round month-1 failed");
1241         assertEquals(dateParser.parse("December 1, 2001"), DateUtils.round((Object) date2, Calendar.MONTH), "round month-2 failed");
1242         assertEquals(dateParser.parse("February 16, 2002"), DateUtils.round((Object) date1, DateUtils.SEMI_MONTH), "round semimonth-1 failed");
1243         assertEquals(dateParser.parse("November 16, 2001"), DateUtils.round((Object) date2, DateUtils.SEMI_MONTH), "round semimonth-2 failed");
1244         assertEquals(dateParser.parse("February 13, 2002"), DateUtils.round((Object) date1, Calendar.DATE), "round date-1 failed");
1245         assertEquals(dateParser.parse("November 18, 2001"), DateUtils.round((Object) date2, Calendar.DATE), "round date-2 failed");
1246         assertEquals(dateTimeParser.parse("February 12, 2002 13:00:00.000"), DateUtils.round((Object) date1, Calendar.HOUR), "round hour-1 failed");
1247         assertEquals(dateTimeParser.parse("November 18, 2001 1:00:00.000"), DateUtils.round((Object) date2, Calendar.HOUR), "round hour-2 failed");
1248         assertEquals(dateTimeParser.parse("February 12, 2002 12:35:00.000"), DateUtils.round((Object) date1, Calendar.MINUTE), "round minute-1 failed");
1249         assertEquals(dateTimeParser.parse("November 18, 2001 1:23:00.000"), DateUtils.round((Object) date2, Calendar.MINUTE), "round minute-2 failed");
1250         assertEquals(dateTimeParser.parse("February 12, 2002 12:34:57.000"), DateUtils.round((Object) date1, Calendar.SECOND), "round second-1 failed");
1251         assertEquals(dateTimeParser.parse("November 18, 2001 1:23:11.000"), DateUtils.round((Object) date2, Calendar.SECOND), "round second-2 failed");
1252         assertEquals(dateTimeParser.parse("February 12, 2002 12:34:57.000"), DateUtils.round((Object) cal1, Calendar.SECOND), "round calendar second-1 failed");
1253         assertEquals(dateTimeParser.parse("November 18, 2001 1:23:11.000"), DateUtils.round((Object) cal2, Calendar.SECOND), "round calendar second-2 failed");
1254         assertEquals(dateTimeParser.parse("February 3, 2002 00:00:00.000"), DateUtils.round((Object) dateAmPm1, Calendar.AM_PM), "round ampm-1 failed");
1255         assertEquals(dateTimeParser.parse("February 3, 2002 12:00:00.000"), DateUtils.round((Object) dateAmPm2, Calendar.AM_PM), "round ampm-2 failed");
1256         assertEquals(dateTimeParser.parse("February 3, 2002 12:00:00.000"), DateUtils.round((Object) dateAmPm3, Calendar.AM_PM), "round ampm-3 failed");
1257         assertEquals(dateTimeParser.parse("February 4, 2002 00:00:00.000"), DateUtils.round((Object) dateAmPm4, Calendar.AM_PM), "round ampm-4 failed");
1258 
1259         assertNullPointerException(() -> DateUtils.round((Date) null, Calendar.SECOND));
1260         assertNullPointerException(() -> DateUtils.round((Calendar) null, Calendar.SECOND));
1261         assertNullPointerException(() -> DateUtils.round((Object) null, Calendar.SECOND));
1262         assertThrows(ClassCastException.class, () -> DateUtils.round("", Calendar.SECOND));
1263         assertIllegalArgumentException(() -> DateUtils.round(date1, -9999));
1264 
1265         assertEquals(dateTimeParser.parse("February 3, 2002 00:00:00.000"), DateUtils.round((Object) calAmPm1, Calendar.AM_PM), "round ampm-1 failed");
1266         assertEquals(dateTimeParser.parse("February 3, 2002 12:00:00.000"), DateUtils.round((Object) calAmPm2, Calendar.AM_PM), "round ampm-2 failed");
1267         assertEquals(dateTimeParser.parse("February 3, 2002 12:00:00.000"), DateUtils.round((Object) calAmPm3, Calendar.AM_PM), "round ampm-3 failed");
1268         assertEquals(dateTimeParser.parse("February 4, 2002 00:00:00.000"), DateUtils.round((Object) calAmPm4, Calendar.AM_PM), "round ampm-4 failed");
1269     }
1270 
1271     /**
1272      * Tests various values with the round method
1273      *
1274      * @throws Exception Thrown if an operation in the test fails.
1275      */
1276     @Test
1277     void testRound_MET() throws Exception {
1278         // Fix for https://issues.apache.org/bugzilla/show_bug.cgi?id=25560 / LANG-13
1279         // Test rounding across the beginning of daylight saving time
1280         TimeZone.setDefault(TIME_ZONE_MET);
1281         dateTimeParser.setTimeZone(TIME_ZONE_MET);
1282         assertEquals(dateTimeParser.parse("March 30, 2003 00:00:00.000"), DateUtils.round(date4, Calendar.DATE), "round MET date across DST change-over");
1283         assertEquals(dateTimeParser.parse("March 30, 2003 00:00:00.000"), DateUtils.round((Object) cal4, Calendar.DATE),
1284                 "round MET date across DST change-over");
1285         assertEquals(dateTimeParser.parse("March 30, 2003 00:00:00.000"), DateUtils.round(date5, Calendar.DATE), "round MET date across DST change-over");
1286         assertEquals(dateTimeParser.parse("March 30, 2003 00:00:00.000"), DateUtils.round((Object) cal5, Calendar.DATE),
1287                 "round MET date across DST change-over");
1288         assertEquals(dateTimeParser.parse("March 30, 2003 00:00:00.000"), DateUtils.round(date6, Calendar.DATE), "round MET date across DST change-over");
1289         assertEquals(dateTimeParser.parse("March 30, 2003 00:00:00.000"), DateUtils.round((Object) cal6, Calendar.DATE),
1290                 "round MET date across DST change-over");
1291         assertEquals(dateTimeParser.parse("March 30, 2003 00:00:00.000"), DateUtils.round(date7, Calendar.DATE), "round MET date across DST change-over");
1292         assertEquals(dateTimeParser.parse("March 30, 2003 00:00:00.000"), DateUtils.round((Object) cal7, Calendar.DATE),
1293                 "round MET date across DST change-over");
1294 
1295         assertEquals(dateTimeParser.parse("March 30, 2003 01:00:00.000"), DateUtils.round(date4, Calendar.HOUR_OF_DAY),
1296                 "round MET date across DST change-over");
1297         assertEquals(dateTimeParser.parse("March 30, 2003 01:00:00.000"), DateUtils.round((Object) cal4, Calendar.HOUR_OF_DAY),
1298                 "round MET date across DST change-over");
1299         assertEquals(dateTimeParser.parse("March 30, 2003 03:00:00.000"), DateUtils.round(date5, Calendar.HOUR_OF_DAY),
1300                 "round MET date across DST change-over");
1301         assertEquals(dateTimeParser.parse("March 30, 2003 03:00:00.000"), DateUtils.round((Object) cal5, Calendar.HOUR_OF_DAY),
1302                 "round MET date across DST change-over");
1303         assertEquals(dateTimeParser.parse("March 30, 2003 03:00:00.000"), DateUtils.round(date6, Calendar.HOUR_OF_DAY),
1304                 "round MET date across DST change-over");
1305         assertEquals(dateTimeParser.parse("March 30, 2003 03:00:00.000"), DateUtils.round((Object) cal6, Calendar.HOUR_OF_DAY),
1306                 "round MET date across DST change-over");
1307         assertEquals(dateTimeParser.parse("March 30, 2003 04:00:00.000"), DateUtils.round(date7, Calendar.HOUR_OF_DAY),
1308                 "round MET date across DST change-over");
1309         assertEquals(dateTimeParser.parse("March 30, 2003 04:00:00.000"), DateUtils.round((Object) cal7, Calendar.HOUR_OF_DAY),
1310                 "round MET date across DST change-over");
1311     }
1312 
1313     /**
1314      * Tests the Changes Made by LANG-346 to the DateUtils.modify() private method invoked
1315      * by DateUtils.round().
1316      *
1317      * @throws Exception Thrown if an operation in the test fails.
1318      */
1319     @Test
1320     void testRoundLang346() throws Exception {
1321         final Calendar testCalendar = Calendar.getInstance();
1322         testCalendar.set(2007, Calendar.JULY, 2, 8, 8, 50);
1323         Date date = testCalendar.getTime();
1324         assertEquals(dateTimeParser.parse("July 2, 2007 08:09:00.000"),
1325                 DateUtils.round(date, Calendar.MINUTE),
1326                 "Minute Round Up Failed");
1327 
1328         testCalendar.set(2007, Calendar.JULY, 2, 8, 8, 20);
1329         date = testCalendar.getTime();
1330         assertEquals(dateTimeParser.parse("July 2, 2007 08:08:00.000"),
1331                 DateUtils.round(date, Calendar.MINUTE),
1332                 "Minute No Round Failed");
1333 
1334         testCalendar.set(2007, Calendar.JULY, 2, 8, 8, 50);
1335         testCalendar.set(Calendar.MILLISECOND, 600);
1336         date = testCalendar.getTime();
1337 
1338         assertEquals(dateTimeParser.parse("July 2, 2007 08:08:51.000"),
1339                 DateUtils.round(date, Calendar.SECOND),
1340                 "Second Round Up with 600 Milli Seconds Failed");
1341 
1342         testCalendar.set(2007, Calendar.JULY, 2, 8, 8, 50);
1343         testCalendar.set(Calendar.MILLISECOND, 200);
1344         date = testCalendar.getTime();
1345         assertEquals(dateTimeParser.parse("July 2, 2007 08:08:50.000"),
1346                 DateUtils.round(date, Calendar.SECOND),
1347                 "Second Round Down with 200 Milli Seconds Failed");
1348 
1349         testCalendar.set(2007, Calendar.JULY, 2, 8, 8, 20);
1350         testCalendar.set(Calendar.MILLISECOND, 600);
1351         date = testCalendar.getTime();
1352         assertEquals(dateTimeParser.parse("July 2, 2007 08:08:21.000"),
1353                 DateUtils.round(date, Calendar.SECOND),
1354                 "Second Round Up with 200 Milli Seconds Failed");
1355 
1356         testCalendar.set(2007, Calendar.JULY, 2, 8, 8, 20);
1357         testCalendar.set(Calendar.MILLISECOND, 200);
1358         date = testCalendar.getTime();
1359         assertEquals(dateTimeParser.parse("July 2, 2007 08:08:20.000"),
1360                 DateUtils.round(date, Calendar.SECOND),
1361                 "Second Round Down with 200 Milli Seconds Failed");
1362 
1363         testCalendar.set(2007, Calendar.JULY, 2, 8, 8, 50);
1364         date = testCalendar.getTime();
1365         assertEquals(dateTimeParser.parse("July 2, 2007 08:00:00.000"),
1366                 DateUtils.round(date, Calendar.HOUR),
1367                 "Hour Round Down Failed");
1368 
1369         testCalendar.set(2007, Calendar.JULY, 2, 8, 31, 50);
1370         date = testCalendar.getTime();
1371         assertEquals(dateTimeParser.parse("July 2, 2007 09:00:00.000"),
1372                 DateUtils.round(date, Calendar.HOUR),
1373                 "Hour Round Up Failed");
1374     }
1375 
1376     @Test
1377     void testSetDays() throws Exception {
1378         Date result = DateUtils.setDays(BASE_DATE, 1);
1379         assertNotSame(BASE_DATE, result);
1380         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
1381         assertDate(result, 2000, 6, 1, 4, 3, 2, 1);
1382         result = DateUtils.setDays(BASE_DATE, 29);
1383         assertNotSame(BASE_DATE, result);
1384         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
1385         assertDate(result, 2000, 6, 29, 4, 3, 2, 1);
1386         final String outsideOfRangeAssertionMessage = "DateUtils.setDays did not throw an expected IllegalArgumentException for amount outside of range 1 to 31.";
1387         assertIllegalArgumentException(() -> DateUtils.setDays(BASE_DATE, 32), outsideOfRangeAssertionMessage);
1388         assertIllegalArgumentException(() -> DateUtils.setDays(BASE_DATE, 0), outsideOfRangeAssertionMessage);
1389         assertNullPointerException(() -> DateUtils.setDays(null, 1));
1390     }
1391 
1392     @Test
1393     void testSetHours() throws Exception {
1394         Date result = DateUtils.setHours(BASE_DATE, 0);
1395         assertNotSame(BASE_DATE, result);
1396         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
1397         assertDate(result, 2000, 6, 5, 0, 3, 2, 1);
1398         result = DateUtils.setHours(BASE_DATE, 23);
1399         assertNotSame(BASE_DATE, result);
1400         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
1401         assertDate(result, 2000, 6, 5, 23, 3, 2, 1);
1402         final String outsideOfRangeAssertionMessage = "DateUtils.setHours did not throw an expected IllegalArgumentException for amount outside of range 0 to 23.";
1403         assertIllegalArgumentException(() -> DateUtils.setHours(BASE_DATE, 24), outsideOfRangeAssertionMessage);
1404         assertIllegalArgumentException(() -> DateUtils.setHours(BASE_DATE, -1), outsideOfRangeAssertionMessage);
1405         assertNullPointerException(() -> DateUtils.setHours(null, 0));
1406     }
1407 
1408     @Test
1409     void testSetMilliseconds() throws Exception {
1410         Date result = DateUtils.setMilliseconds(BASE_DATE, 0);
1411         assertNotSame(BASE_DATE, result);
1412         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
1413         assertDate(result, 2000, 6, 5, 4, 3, 2, 0);
1414         result = DateUtils.setMilliseconds(BASE_DATE, 999);
1415         assertNotSame(BASE_DATE, result);
1416         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
1417         assertDate(result, 2000, 6, 5, 4, 3, 2, 999);
1418         final String outsideOfRangeAssertionMessage = "DateUtils.setMilliseconds did not throw an expected IllegalArgumentException for range outside of 0 to 999.";
1419         assertIllegalArgumentException(() -> DateUtils.setMilliseconds(BASE_DATE, 1000), outsideOfRangeAssertionMessage);
1420         assertIllegalArgumentException(() -> DateUtils.setMilliseconds(BASE_DATE, -1), outsideOfRangeAssertionMessage);
1421         assertNullPointerException(() -> DateUtils.setMilliseconds(null, 0));
1422     }
1423 
1424     @Test
1425     void testSetMinutes() throws Exception {
1426         Date result = DateUtils.setMinutes(BASE_DATE, 0);
1427         assertNotSame(BASE_DATE, result);
1428         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
1429         assertDate(result, 2000, 6, 5, 4, 0, 2, 1);
1430         result = DateUtils.setMinutes(BASE_DATE, 59);
1431         assertNotSame(BASE_DATE, result);
1432         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
1433         assertDate(result, 2000, 6, 5, 4, 59, 2, 1);
1434         final String outsideOfRangeAssertionMessage = "DateUtils.setMinutes did not throw an expected IllegalArgumentException for amount outside of range 0 to 59.";
1435         assertIllegalArgumentException(() -> DateUtils.setMinutes(BASE_DATE, 60), outsideOfRangeAssertionMessage);
1436         assertIllegalArgumentException(() -> DateUtils.setMinutes(BASE_DATE, -1), outsideOfRangeAssertionMessage);
1437         assertNullPointerException(() -> DateUtils.setMinutes(null, 0));
1438     }
1439 
1440     @Test
1441     void testSetMonths() throws Exception {
1442         Date result = DateUtils.setMonths(BASE_DATE, 5);
1443         assertNotSame(BASE_DATE, result);
1444         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
1445         assertDate(result, 2000, 5, 5, 4, 3, 2, 1);
1446         result = DateUtils.setMonths(BASE_DATE, 1);
1447         assertNotSame(BASE_DATE, result);
1448         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
1449         assertDate(result, 2000, 1, 5, 4, 3, 2, 1);
1450         result = DateUtils.setMonths(BASE_DATE, 0);
1451         assertNotSame(BASE_DATE, result);
1452         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
1453         assertDate(result, 2000, 0, 5, 4, 3, 2, 1);
1454         final String outsideOfRangeAssertionMessage = "DateUtils.setMonths did not throw an expected IllegalArgumentException for amount outside of range 0 to 11.";
1455         assertIllegalArgumentException(() -> DateUtils.setMonths(BASE_DATE, 12), outsideOfRangeAssertionMessage);
1456         assertIllegalArgumentException(() -> DateUtils.setMonths(BASE_DATE, -1), outsideOfRangeAssertionMessage);
1457         assertNullPointerException(() -> DateUtils.setMonths(null, 0));
1458     }
1459 
1460     @Test
1461     void testSetSeconds() throws Exception {
1462         Date result = DateUtils.setSeconds(BASE_DATE, 0);
1463         assertNotSame(BASE_DATE, result);
1464         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
1465         assertDate(result, 2000, 6, 5, 4, 3, 0, 1);
1466         result = DateUtils.setSeconds(BASE_DATE, 59);
1467         assertNotSame(BASE_DATE, result);
1468         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
1469         assertDate(result, 2000, 6, 5, 4, 3, 59, 1);
1470         final String outsideOfRangeAssertionMessage = "DateUtils.setSeconds did not throw an expected IllegalArgumentException for amount outside of range 0 to 59.";
1471         assertIllegalArgumentException(() -> DateUtils.setSeconds(BASE_DATE, 60), outsideOfRangeAssertionMessage);
1472         assertIllegalArgumentException(() -> DateUtils.setSeconds(BASE_DATE, -1), outsideOfRangeAssertionMessage);
1473         assertNullPointerException(() -> DateUtils.setSeconds(null, 0));
1474     }
1475 
1476     @Test
1477     void testSetYears() throws Exception {
1478         Date result = DateUtils.setYears(BASE_DATE, 2000);
1479         assertNotSame(BASE_DATE, result);
1480         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
1481         assertDate(result, 2000, 6, 5, 4, 3, 2, 1);
1482 
1483         result = DateUtils.setYears(BASE_DATE, 2008);
1484         assertNotSame(BASE_DATE, result);
1485         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
1486         assertDate(result, 2008, 6, 5, 4, 3, 2, 1);
1487 
1488         result = DateUtils.setYears(BASE_DATE, 2005);
1489         assertNotSame(BASE_DATE, result);
1490         assertDate(BASE_DATE, 2000, 6, 5, 4, 3, 2, 1);
1491         assertDate(result, 2005, 6, 5, 4, 3, 2, 1);
1492 
1493         assertNullPointerException(() -> DateUtils.setYears(null, 0));
1494     }
1495 
1496     @Test
1497     void testToCalendar() {
1498         assertEquals(date1, DateUtils.toCalendar(date1).getTime(), "Failed to convert to a Calendar and back");
1499         assertEquals(MAX_DATE, DateUtils.toCalendar(MAX_DATE).getTime(), "Failed to convert to a Calendar and back");
1500         assertNullPointerException(() -> DateUtils.toCalendar(null));
1501     }
1502 
1503     @Test
1504     void testToCalendarWithDateAndTimeZoneNotNull() {
1505         final Calendar c = DateUtils.toCalendar(date2, TIME_ZONE_DEFAULT);
1506         assertEquals(date2, c.getTime(), "Convert Date and TimeZone to a Calendar, but failed to get the Date back");
1507         assertEquals(TIME_ZONE_DEFAULT, c.getTimeZone(), "Convert Date and TimeZone to a Calendar, but failed to get the TimeZone back");
1508     }
1509 
1510     @Test
1511     void testToCalendarWithDateAndTimeZoneNull() {
1512         assertNullPointerException(() -> DateUtils.toCalendar(null, null));
1513     }
1514 
1515     @Test
1516     void testToCalendarWithDateNull() {
1517         assertNullPointerException(() -> DateUtils.toCalendar(null, TIME_ZONE_MET));
1518     }
1519 
1520     @Test
1521     void testToCalendarWithTimeZoneNull() {
1522         assertNullPointerException(() -> DateUtils.toCalendar(date1, null));
1523     }
1524 
1525     @ParameterizedTest
1526     @MethodSource("testToLocalDateTimeTimeZone")
1527     @DefaultLocale(language = "en", country = "US")
1528     @DefaultTimeZone(TimeZones.GMT_ID)
1529     void testToLocalDateTime(final LocalDateTime expected, final Date date, final TimeZone timeZone) {
1530         assertEquals(LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault()), DateUtils.toLocalDateTime(date),
1531                 () -> String.format("expected = %s, date = %s, timeZone = %s, TimeZone.getDefault() = %s", expected, date, timeZone, TimeZone.getDefault()));
1532     }
1533 
1534     @ParameterizedTest
1535     @MethodSource("testToLocalDateTimeTimeZone")
1536     @DefaultLocale(language = "en", country = "US")
1537     @DefaultTimeZone(TimeZones.GMT_ID)
1538     void testToLocalDateTimeTimeZone(final LocalDateTime expected, final Date date, final TimeZone timeZone) {
1539         assertEquals(expected, DateUtils.toLocalDateTime(date, timeZone),
1540                 () -> String.format("expected = %s, date = %s, timeZone = %s, TimeZone.getDefault() = %s", expected, date, timeZone, TimeZone.getDefault()));
1541     }
1542 
1543     @ParameterizedTest
1544     @MethodSource("testToLocalDateTimeTimeZone")
1545     @DefaultLocale(language = "en", country = "US")
1546     @DefaultTimeZone(TimeZones.GMT_ID)
1547     void testToOffsetDateTime(final LocalDateTime expected, final Date date, final TimeZone timeZone) {
1548         final OffsetDateTime offsetDateTime = DateUtils.toOffsetDateTime(date);
1549         assertEquals(OffsetDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault()), offsetDateTime,
1550                 () -> String.format("expected = %s, date = %s, timeZone = %s, TimeZone.getDefault() = %s", expected, date, timeZone, TimeZone.getDefault()));
1551     }
1552 
1553     @ParameterizedTest
1554     @MethodSource("testToLocalDateTimeTimeZone")
1555     @DefaultLocale(language = "en", country = "US")
1556     @DefaultTimeZone(TimeZones.GMT_ID)
1557     void testToOffsetDateTimeTimeZone(final LocalDateTime expected, final Date date, final TimeZone timeZone) {
1558         assertEquals(expected, DateUtils.toOffsetDateTime(date, timeZone).toLocalDateTime(),
1559                 () -> String.format("expected = %s, date = %s, timeZone = %s, TimeZone.getDefault() = %s", expected, date, timeZone, TimeZone.getDefault()));
1560     }
1561 
1562     @ParameterizedTest
1563     @MethodSource("testToLocalDateTimeTimeZone")
1564     @DefaultLocale(language = "en", country = "US")
1565     @DefaultTimeZone(TimeZones.GMT_ID)
1566     void testToZonedDateTime(final LocalDateTime expected, final Date date, final TimeZone timeZone) {
1567         final ZonedDateTime zonedDateTime = DateUtils.toZonedDateTime(date);
1568         assertEquals(ZonedDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault()), zonedDateTime,
1569                 () -> String.format("expected = %s, date = %s, timeZone = %s, TimeZone.getDefault() = %s", expected, date, timeZone, TimeZone.getDefault()));
1570         // Using atZone()
1571         assertEquals(date.toInstant().atZone(ZoneId.systemDefault()), zonedDateTime,
1572                 () -> String.format("expected = %s, date = %s, timeZone = %s, TimeZone.getDefault() = %s", expected, date, timeZone, TimeZone.getDefault()));
1573     }
1574 
1575     @ParameterizedTest
1576     @MethodSource("testToLocalDateTimeTimeZone")
1577     @DefaultLocale(language = "en", country = "US")
1578     @DefaultTimeZone(TimeZones.GMT_ID)
1579     void testToZonedDateTimeTimeZone(final LocalDateTime expected, final Date date, final TimeZone timeZone) {
1580         final ZonedDateTime zonedDateTime = DateUtils.toZonedDateTime(date, timeZone);
1581         assertEquals(expected, zonedDateTime.toOffsetDateTime().toLocalDateTime(),
1582                 () -> String.format("expected = %s, date = %s, timeZone = %s, TimeZone.getDefault() = %s", expected, date, timeZone, TimeZone.getDefault()));
1583         // Using atZone()
1584         assertEquals(date.toInstant().atZone(TimeZones.toTimeZone(timeZone).toZoneId()), zonedDateTime,
1585                 () -> String.format("expected = %s, date = %s, timeZone = %s, TimeZone.getDefault() = %s", expected, date, timeZone, TimeZone.getDefault()));
1586     }
1587 
1588     /**
1589      * Tests various values with the trunc method.
1590      *
1591      * @throws Exception Thrown if an operation in the test fails.
1592      */
1593     @Test
1594     void testTruncate() throws Exception {
1595         // tests public static Date truncate(Date date, int field)
1596         assertEquals(dateParser.parse("January 1, 2002"),
1597                 DateUtils.truncate(date1, Calendar.YEAR),
1598                 "truncate year-1 failed");
1599         assertEquals(dateParser.parse("January 1, 2001"),
1600                 DateUtils.truncate(date2, Calendar.YEAR),
1601                 "truncate year-2 failed");
1602         assertEquals(dateParser.parse("February 1, 2002"),
1603                 DateUtils.truncate(date1, Calendar.MONTH),
1604                 "truncate month-1 failed");
1605         assertEquals(dateParser.parse("November 1, 2001"),
1606                 DateUtils.truncate(date2, Calendar.MONTH),
1607                 "truncate month-2 failed");
1608         assertEquals(dateParser.parse("February 1, 2002"),
1609                 DateUtils.truncate(date1, DateUtils.SEMI_MONTH),
1610                 "truncate semimonth-1 failed");
1611         assertEquals(dateParser.parse("November 16, 2001"),
1612                 DateUtils.truncate(date2, DateUtils.SEMI_MONTH),
1613                 "truncate semimonth-2 failed");
1614         assertEquals(dateParser.parse("February 12, 2002"),
1615                 DateUtils.truncate(date1, Calendar.DATE),
1616                 "truncate date-1 failed");
1617         assertEquals(dateParser.parse("November 18, 2001"),
1618                 DateUtils.truncate(date2, Calendar.DATE),
1619                 "truncate date-2 failed");
1620         assertEquals(dateTimeParser.parse("February 12, 2002 12:00:00.000"),
1621                 DateUtils.truncate(date1, Calendar.HOUR),
1622                 "truncate hour-1 failed");
1623         assertEquals(dateTimeParser.parse("November 18, 2001 1:00:00.000"),
1624                 DateUtils.truncate(date2, Calendar.HOUR),
1625                 "truncate hour-2 failed");
1626         assertEquals(dateTimeParser.parse("February 12, 2002 12:34:00.000"),
1627                 DateUtils.truncate(date1, Calendar.MINUTE),
1628                 "truncate minute-1 failed");
1629         assertEquals(dateTimeParser.parse("November 18, 2001 1:23:00.000"),
1630                 DateUtils.truncate(date2, Calendar.MINUTE),
1631                 "truncate minute-2 failed");
1632         assertEquals(dateTimeParser.parse("February 12, 2002 12:34:56.000"),
1633                 DateUtils.truncate(date1, Calendar.SECOND),
1634                 "truncate second-1 failed");
1635         assertEquals(dateTimeParser.parse("November 18, 2001 1:23:11.000"),
1636                 DateUtils.truncate(date2, Calendar.SECOND),
1637                 "truncate second-2 failed");
1638         assertEquals(dateTimeParser.parse("February 3, 2002 00:00:00.000"),
1639                 DateUtils.truncate(dateAmPm1, Calendar.AM_PM),
1640                 "truncate ampm-1 failed");
1641         assertEquals(dateTimeParser.parse("February 3, 2002 00:00:00.000"),
1642                 DateUtils.truncate(dateAmPm2, Calendar.AM_PM),
1643                 "truncate ampm-2 failed");
1644         assertEquals(dateTimeParser.parse("February 3, 2002 12:00:00.000"),
1645                 DateUtils.truncate(dateAmPm3, Calendar.AM_PM),
1646                 "truncate ampm-3 failed");
1647         assertEquals(dateTimeParser.parse("February 3, 2002 12:00:00.000"),
1648                 DateUtils.truncate(dateAmPm4, Calendar.AM_PM),
1649                 "truncate ampm-4 failed");
1650 
1651         // tests public static Date truncate(Object date, int field)
1652         assertEquals(dateParser.parse("January 1, 2002"),
1653                 DateUtils.truncate((Object) date1, Calendar.YEAR),
1654                 "truncate year-1 failed");
1655         assertEquals(dateParser.parse("January 1, 2001"),
1656                 DateUtils.truncate((Object) date2, Calendar.YEAR),
1657                 "truncate year-2 failed");
1658         assertEquals(dateParser.parse("February 1, 2002"),
1659                 DateUtils.truncate((Object) date1, Calendar.MONTH),
1660                 "truncate month-1 failed");
1661         assertEquals(dateParser.parse("November 1, 2001"),
1662                 DateUtils.truncate((Object) date2, Calendar.MONTH),
1663                 "truncate month-2 failed");
1664         assertEquals(dateParser.parse("February 1, 2002"),
1665                 DateUtils.truncate((Object) date1, DateUtils.SEMI_MONTH),
1666                 "truncate semimonth-1 failed");
1667         assertEquals(dateParser.parse("November 16, 2001"),
1668                 DateUtils.truncate((Object) date2, DateUtils.SEMI_MONTH),
1669                 "truncate semimonth-2 failed");
1670         assertEquals(dateParser.parse("February 12, 2002"),
1671                 DateUtils.truncate((Object) date1, Calendar.DATE),
1672                 "truncate date-1 failed");
1673         assertEquals(dateParser.parse("November 18, 2001"),
1674                 DateUtils.truncate((Object) date2, Calendar.DATE),
1675                 "truncate date-2 failed");
1676         assertEquals(dateTimeParser.parse("February 12, 2002 12:00:00.000"),
1677                 DateUtils.truncate((Object) date1, Calendar.HOUR),
1678                 "truncate hour-1 failed");
1679         assertEquals(dateTimeParser.parse("November 18, 2001 1:00:00.000"),
1680                 DateUtils.truncate((Object) date2, Calendar.HOUR),
1681                 "truncate hour-2 failed");
1682         assertEquals(dateTimeParser.parse("February 12, 2002 12:34:00.000"),
1683                 DateUtils.truncate((Object) date1, Calendar.MINUTE),
1684                 "truncate minute-1 failed");
1685         assertEquals(dateTimeParser.parse("November 18, 2001 1:23:00.000"),
1686                 DateUtils.truncate((Object) date2, Calendar.MINUTE),
1687                 "truncate minute-2 failed");
1688         assertEquals(dateTimeParser.parse("February 12, 2002 12:34:56.000"),
1689                 DateUtils.truncate((Object) date1, Calendar.SECOND),
1690                 "truncate second-1 failed");
1691         assertEquals(dateTimeParser.parse("November 18, 2001 1:23:11.000"),
1692                 DateUtils.truncate((Object) date2, Calendar.SECOND),
1693                 "truncate second-2 failed");
1694         assertEquals(dateTimeParser.parse("February 3, 2002 00:00:00.000"),
1695                 DateUtils.truncate((Object) dateAmPm1, Calendar.AM_PM),
1696                 "truncate ampm-1 failed");
1697         assertEquals(dateTimeParser.parse("February 3, 2002 00:00:00.000"),
1698                 DateUtils.truncate((Object) dateAmPm2, Calendar.AM_PM),
1699                 "truncate ampm-2 failed");
1700         assertEquals(dateTimeParser.parse("February 3, 2002 12:00:00.000"),
1701                 DateUtils.truncate((Object) dateAmPm3, Calendar.AM_PM),
1702                 "truncate ampm-3 failed");
1703         assertEquals(dateTimeParser.parse("February 3, 2002 12:00:00.000"),
1704                 DateUtils.truncate((Object) dateAmPm4, Calendar.AM_PM),
1705                 "truncate ampm-4 failed");
1706 
1707         assertEquals(dateTimeParser.parse("February 12, 2002 12:34:56.000"),
1708                 DateUtils.truncate((Object) cal1, Calendar.SECOND),
1709                 "truncate calendar second-1 failed");
1710         assertEquals(dateTimeParser.parse("November 18, 2001 1:23:11.000"),
1711                 DateUtils.truncate((Object) cal2, Calendar.SECOND),
1712                 "truncate calendar second-2 failed");
1713 
1714         assertEquals(dateTimeParser.parse("February 3, 2002 00:00:00.000"),
1715                 DateUtils.truncate((Object) calAmPm1, Calendar.AM_PM),
1716                 "truncate ampm-1 failed");
1717         assertEquals(dateTimeParser.parse("February 3, 2002 00:00:00.000"),
1718                 DateUtils.truncate((Object) calAmPm2, Calendar.AM_PM),
1719                 "truncate ampm-2 failed");
1720         assertEquals(dateTimeParser.parse("February 3, 2002 12:00:00.000"),
1721                 DateUtils.truncate((Object) calAmPm3, Calendar.AM_PM),
1722                 "truncate ampm-3 failed");
1723         assertEquals(dateTimeParser.parse("February 3, 2002 12:00:00.000"),
1724                 DateUtils.truncate((Object) calAmPm4, Calendar.AM_PM),
1725                 "truncate ampm-4 failed");
1726 
1727         assertNullPointerException(() -> DateUtils.truncate((Date) null, Calendar.SECOND));
1728         assertNullPointerException(() -> DateUtils.truncate((Calendar) null, Calendar.SECOND));
1729         assertNullPointerException(() -> DateUtils.truncate((Object) null, Calendar.SECOND));
1730         assertThrows(ClassCastException.class, () -> DateUtils.truncate("", Calendar.SECOND));
1731 
1732     }
1733 
1734     /**
1735      * Tests various values with the trunc method
1736      *
1737      * @throws Exception Thrown if an operation in the test fails.
1738      */
1739     @Test
1740     void testTruncate_Bugzilla_25560() throws Exception {
1741         // Fix for https://issues.apache.org/bugzilla/show_bug.cgi?id=25560
1742         // Test truncate across beginning of daylight saving time
1743         TimeZone.setDefault(TIME_ZONE_MET);
1744         dateTimeParser.setTimeZone(TIME_ZONE_MET);
1745         assertEquals(dateTimeParser.parse("March 30, 2003 00:00:00.000"), DateUtils.truncate(date3, Calendar.DATE), "truncate MET date across DST change-over");
1746         assertEquals(dateTimeParser.parse("March 30, 2003 00:00:00.000"), DateUtils.truncate((Object) cal3, Calendar.DATE),
1747                 "truncate MET date across DST change-over");
1748         // Test truncate across end of daylight saving time
1749         assertEquals(dateTimeParser.parse("October 26, 2003 00:00:00.000"), DateUtils.truncate(date8, Calendar.DATE),
1750                 "truncate MET date across DST change-over");
1751         assertEquals(dateTimeParser.parse("October 26, 2003 00:00:00.000"), DateUtils.truncate((Object) cal8, Calendar.DATE),
1752                 "truncate MET date across DST change-over");
1753     }
1754 
1755     /**
1756      * Tests various values with the trunc method
1757      *
1758      * @throws Exception Thrown if an operation in the test fails.
1759      */
1760     @Test
1761     void testTruncate_Bugzilla_31395() throws Exception {
1762         // Bug 31395, large dates
1763         final Date endOfTime = MAX_DATE; // fyi: Sun Aug 17 07:12:55 CET 292278994 -- 807 millis
1764         final GregorianCalendar endCal = new GregorianCalendar();
1765         endCal.setTime(endOfTime);
1766         assertThrows(ArithmeticException.class, () -> DateUtils.truncate(endCal, Calendar.DATE));
1767         endCal.set(Calendar.YEAR, 280000001);
1768         assertThrows(ArithmeticException.class, () -> DateUtils.truncate(endCal, Calendar.DATE));
1769         endCal.set(Calendar.YEAR, 280000000);
1770         final Calendar cal = DateUtils.truncate(endCal, Calendar.DATE);
1771         assertEquals(0, cal.get(Calendar.HOUR));
1772     }
1773 
1774     @Test
1775     public void testTruncatedCompareToCalendar() {
1776         final Calendar cal1 = Calendar.getInstance();
1777         cal1.set(2026, Calendar.JULY, 26, 10, 0, 0);
1778         final Calendar cal2 = Calendar.getInstance();
1779         cal2.set(2026, Calendar.JULY, 26, 14, 0, 0);
1780 
1781         assertEquals(0, DateUtils.truncatedCompareTo(cal1, cal2, Calendar.DAY_OF_MONTH));
1782         assertTrue(DateUtils.truncatedCompareTo(cal1, cal2, Calendar.HOUR_OF_DAY) < 0);
1783         assertTrue(DateUtils.truncatedCompareTo(cal2, cal1, Calendar.HOUR_OF_DAY) > 0);
1784 
1785         assertThrows(NullPointerException.class, () -> DateUtils.truncatedCompareTo(null, cal2, Calendar.DAY_OF_MONTH));
1786         assertThrows(NullPointerException.class, () -> DateUtils.truncatedCompareTo(cal1, null, Calendar.DAY_OF_MONTH));
1787     }
1788 
1789     @Test
1790     public void testTruncatedCompareToDate() {
1791         final Calendar cal1 = Calendar.getInstance();
1792         cal1.set(2026, Calendar.JULY, 26, 10, 0, 0);
1793         final Calendar cal2 = Calendar.getInstance();
1794         cal2.set(2026, Calendar.JULY, 26, 14, 0, 0);
1795 
1796         final Date date1 = cal1.getTime();
1797         final Date date2 = cal2.getTime();
1798 
1799         assertEquals(0, DateUtils.truncatedCompareTo(date1, date2, Calendar.DAY_OF_MONTH));
1800 
1801         assertTrue(DateUtils.truncatedCompareTo(date1, date2, Calendar.HOUR_OF_DAY) < 0);
1802         assertTrue(DateUtils.truncatedCompareTo(date2, date1, Calendar.HOUR_OF_DAY) > 0);
1803 
1804         assertThrows(NullPointerException.class, () -> DateUtils.truncatedCompareTo(null, date2, Calendar.DAY_OF_MONTH));
1805         assertThrows(NullPointerException.class, () -> DateUtils.truncatedCompareTo(date1, null, Calendar.DAY_OF_MONTH));
1806     }
1807 
1808     @Test
1809     public void testTruncatedEqualCalendar() {
1810         final Calendar cal1 = Calendar.getInstance();
1811         cal1.set(2026, Calendar.JULY, 26, 10, 0, 0);
1812         final Calendar cal2 = Calendar.getInstance();
1813         cal2.set(2026, Calendar.JULY, 26, 14, 0, 0);
1814 
1815         assertTrue(DateUtils.truncatedEquals(cal1, cal2, Calendar.DAY_OF_MONTH));
1816         assertFalse(DateUtils.truncatedEquals(cal1, cal2, Calendar.HOUR_OF_DAY));
1817 
1818         assertThrows(NullPointerException.class, () -> DateUtils.truncatedEquals(null, cal2, Calendar.DAY_OF_MONTH));
1819         assertThrows(NullPointerException.class, () -> DateUtils.truncatedEquals(cal1, null, Calendar.DAY_OF_MONTH));
1820     }
1821 
1822     @Test
1823     public void testTruncatedEqualDate() {
1824         final Calendar cal1 = Calendar.getInstance();
1825         cal1.set(2026, Calendar.JULY, 26, 10, 0, 0);
1826         final Calendar cal2 = Calendar.getInstance();
1827         cal2.set(2026, Calendar.JULY, 26, 14, 0, 0);
1828 
1829         final Date date1 = cal1.getTime();
1830         final Date date2 = cal2.getTime();
1831 
1832         assertTrue(DateUtils.truncatedEquals(date1, date2, Calendar.DAY_OF_MONTH));
1833         assertFalse(DateUtils.truncatedEquals(date1, date2, Calendar.HOUR_OF_DAY));
1834 
1835         assertThrows(NullPointerException.class, () -> DateUtils.truncatedEquals(null, date2, Calendar.DAY_OF_MONTH));
1836         assertThrows(NullPointerException.class, () -> DateUtils.truncatedEquals(date1, null, Calendar.DAY_OF_MONTH));
1837     }
1838 
1839     /**
1840      * Tests for LANG-59
1841      *
1842      * see https://issues.apache.org/jira/browse/LANG-59
1843      */
1844     @Test
1845     void testTruncateLang59() {
1846         // Set TimeZone to Mountain Time
1847         final TimeZone denverZone = TimeZones.getTimeZone("America/Denver");
1848         TimeZone.setDefault(denverZone);
1849         final DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS XXX");
1850         format.setTimeZone(denverZone);
1851         final Date oct31_01MDT = new Date(1099206000000L);
1852         final Date oct31MDT = new Date(oct31_01MDT.getTime() - 3600000L); // - 1 hour
1853         final Date oct31_01_02MDT = new Date(oct31_01MDT.getTime() + 120000L); // + 2 minutes
1854         final Date oct31_01_02_03MDT = new Date(oct31_01_02MDT.getTime() + 3000L); // + 3 seconds
1855         final Date oct31_01_02_03_04MDT = new Date(oct31_01_02_03MDT.getTime() + 4L); // + 4 milliseconds
1856         assertEquals("2004-10-31 00:00:00.000 -06:00", format.format(oct31MDT), "Check 00:00:00.000");
1857         assertEquals("2004-10-31 01:00:00.000 -06:00", format.format(oct31_01MDT), "Check 01:00:00.000");
1858         assertEquals("2004-10-31 01:02:00.000 -06:00", format.format(oct31_01_02MDT), "Check 01:02:00.000");
1859         assertEquals("2004-10-31 01:02:03.000 -06:00", format.format(oct31_01_02_03MDT), "Check 01:02:03.000");
1860         assertEquals("2004-10-31 01:02:03.004 -06:00", format.format(oct31_01_02_03_04MDT), "Check 01:02:03.004");
1861         // Demonstrate Problem
1862         final Calendar gval = Calendar.getInstance();
1863         gval.setTime(new Date(oct31_01MDT.getTime()));
1864         gval.set(Calendar.MINUTE, gval.get(Calendar.MINUTE)); // set minutes to the same value
1865         assertEquals(gval.getTime().getTime(), oct31_01MDT.getTime() + 3600000L, "Demonstrate Problem");
1866         // Test Truncate
1867         assertEquals(oct31_01_02_03_04MDT, DateUtils.truncate(oct31_01_02_03_04MDT, Calendar.MILLISECOND), "Truncate Calendar.MILLISECOND");
1868         assertEquals(oct31_01_02_03MDT, DateUtils.truncate(oct31_01_02_03_04MDT, Calendar.SECOND), "Truncate Calendar.SECOND");
1869         assertEquals(oct31_01_02MDT, DateUtils.truncate(oct31_01_02_03_04MDT, Calendar.MINUTE), "Truncate Calendar.MINUTE");
1870         assertEquals(oct31_01MDT, DateUtils.truncate(oct31_01_02_03_04MDT, Calendar.HOUR_OF_DAY), "Truncate Calendar.HOUR_OF_DAY");
1871         assertEquals(oct31_01MDT, DateUtils.truncate(oct31_01_02_03_04MDT, Calendar.HOUR), "Truncate Calendar.HOUR");
1872         assertEquals(oct31MDT, DateUtils.truncate(oct31_01_02_03_04MDT, Calendar.DATE), "Truncate Calendar.DATE");
1873         // Test Round (down)
1874         assertEquals(oct31_01_02_03_04MDT, DateUtils.round(oct31_01_02_03_04MDT, Calendar.MILLISECOND), "Round Calendar.MILLISECOND");
1875         assertEquals(oct31_01_02_03MDT, DateUtils.round(oct31_01_02_03_04MDT, Calendar.SECOND), "Round Calendar.SECOND");
1876         assertEquals(oct31_01_02MDT, DateUtils.round(oct31_01_02_03_04MDT, Calendar.MINUTE), "Round Calendar.MINUTE");
1877         assertEquals(oct31_01MDT, DateUtils.round(oct31_01_02_03_04MDT, Calendar.HOUR_OF_DAY), "Round Calendar.HOUR_OF_DAY");
1878         assertEquals(oct31_01MDT, DateUtils.round(oct31_01_02_03_04MDT, Calendar.HOUR), "Round Calendar.HOUR");
1879         assertEquals(oct31MDT, DateUtils.round(oct31_01_02_03_04MDT, Calendar.DATE), "Round Calendar.DATE");
1880     }
1881 
1882     /**
1883      * Tests the calendar iterator for week ranges
1884      */
1885     @Test
1886     void testWeekIterator() {
1887         final Calendar now = Calendar.getInstance();
1888         for (int i = 0; i < 7; i++) {
1889             final Calendar today = DateUtils.truncate(now, Calendar.DATE);
1890             final Calendar sunday = DateUtils.truncate(now, Calendar.DATE);
1891             sunday.add(Calendar.DATE, 1 - sunday.get(Calendar.DAY_OF_WEEK));
1892             final Calendar monday = DateUtils.truncate(now, Calendar.DATE);
1893             if (monday.get(Calendar.DAY_OF_WEEK) == 1) {
1894                 // This is sunday... roll back 6 days
1895                 monday.add(Calendar.DATE, -6);
1896             } else {
1897                 monday.add(Calendar.DATE, 2 - monday.get(Calendar.DAY_OF_WEEK));
1898             }
1899             final Calendar centered = DateUtils.truncate(now, Calendar.DATE);
1900             centered.add(Calendar.DATE, -3);
1901 
1902             Iterator<?> it = DateUtils.iterator(now, DateUtils.RANGE_WEEK_SUNDAY);
1903             assertWeekIterator(it, sunday);
1904             it = DateUtils.iterator(now, DateUtils.RANGE_WEEK_MONDAY);
1905             assertWeekIterator(it, monday);
1906             it = DateUtils.iterator(now, DateUtils.RANGE_WEEK_RELATIVE);
1907             assertWeekIterator(it, today);
1908             it = DateUtils.iterator(now, DateUtils.RANGE_WEEK_CENTER);
1909             assertWeekIterator(it, centered);
1910 
1911             it = DateUtils.iterator((Object) now, DateUtils.RANGE_WEEK_CENTER);
1912             assertWeekIterator(it, centered);
1913             final Iterator<?> it2 = DateUtils.iterator((Object) now.getTime(), DateUtils.RANGE_WEEK_CENTER);
1914             assertWeekIterator(it2, centered);
1915             assertThrows(NoSuchElementException.class, it2::next);
1916             final Iterator<?> it3 = DateUtils.iterator(now, DateUtils.RANGE_WEEK_CENTER);
1917             it3.next();
1918             assertThrows(UnsupportedOperationException.class, it3::remove);
1919 
1920             now.add(Calendar.DATE, 1);
1921         }
1922     }
1923 }
1924