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  
18  package org.apache.commons.lang3.time;
19  
20  import static org.apache.commons.lang3.LangAssertions.assertIllegalArgumentException;
21  import static org.junit.jupiter.api.Assertions.assertArrayEquals;
22  import static org.junit.jupiter.api.Assertions.assertEquals;
23  import static org.junit.jupiter.api.Assertions.assertFalse;
24  import static org.junit.jupiter.api.Assertions.assertNotEquals;
25  import static org.junit.jupiter.api.Assertions.assertNotNull;
26  import static org.junit.jupiter.api.Assertions.assertTimeoutPreemptively;
27  import static org.junit.jupiter.api.Assertions.assertTrue;
28  
29  import java.lang.reflect.Constructor;
30  import java.lang.reflect.Modifier;
31  import java.time.Duration;
32  import java.util.Calendar;
33  import java.util.TimeZone;
34  
35  import org.apache.commons.lang3.AbstractLangTest;
36  import org.apache.commons.lang3.time.DurationFormatUtils.Token;
37  import org.apache.commons.lang3.time.DurationFormatUtils.Unit;
38  import org.junit.jupiter.api.Test;
39  import org.junit.jupiter.params.ParameterizedTest;
40  import org.junit.jupiter.params.provider.Arguments;
41  import org.junit.jupiter.params.provider.MethodSource;
42  import org.junitpioneer.jupiter.DefaultTimeZone;
43  
44  /**
45   * Tests {@link DurationFormatUtils}.
46   * <p>
47   * NOT THREAD-SAFE.
48   * </p>
49   */
50  class DurationFormatUtilsTest extends AbstractLangTest {
51  
52      private static final int FOUR_YEARS = 365 * 3 + 366;
53  
54      private static Arguments[] testFractionalSecondsPadding() {
55          return new Arguments[] {
56                  Arguments.of("s.S", false, "1.007"),
57                  Arguments.of("s.S", true, "1.007"),
58                  Arguments.of("s.SSSS", false, "1.007"),
59                  Arguments.of("s.SSSS", true, "1.0007"),
60                  Arguments.of("s' seconds 'S", false, "1 seconds 007"),
61                  Arguments.of("s.S.S", false, "1.007.7"),
62                  Arguments.of("s:m:S", false, "1:0:7"),
63                  Arguments.of("s[m':'H]S", false, "17"),
64                  Arguments.of("[s'.']SSS", false, "1.007"),
65                  Arguments.of("S", false, "1007")
66          };
67      }
68  
69      private static Arguments[] testLANG1827() {
70          final long twoHours = Duration.ofHours(2).toMillis();
71          final long twoHoursThirtyMin = Duration.ofHours(2).plusMinutes(30).toMillis();
72          final long oneDayTwoHours = Duration.ofDays(1).plusHours(2).toMillis();
73          return new Arguments[] {
74                  Arguments.of("escaped quote inside literal", "2 o'clock", twoHours, "H' o''clock'"),
75                  Arguments.of("escaped quote at start of literal", "it's 2 hours", twoHours, "'it''s 'H' hours'"),
76                  Arguments.of("escaped quote outside literal", "2'30", twoHoursThirtyMin, "H''m"),
77                  Arguments.of("multiple escaped quotes", "it's been 1 day's and 2 hour's", oneDayTwoHours,
78                          "'it''s been 'd' day''s and 'H' hour''s'"),
79                  Arguments.of("standalone escaped quote", "2h'30m", twoHoursThirtyMin, "H'h'''m'm'"),
80                  Arguments.of("escaped quote inside optional block", "2 hour's", twoHours, "[d' day''s ']H' hour''s'"),
81                  Arguments.of("existing literal behavior", "2 hours 30 minutes", twoHoursThirtyMin, "H' hours 'm' minutes'")
82          };
83      }
84  
85      private void assertEqualDuration(final String expected, final int[] start, final int[] end, final String format) {
86          assertEqualDuration(null, expected, start, end, format);
87      }
88  
89      private void assertEqualDuration(final String message, final String expected, final int[] start, final int[] end, final String format) {
90          final Calendar cal1 = Calendar.getInstance();
91          cal1.set(start[0], start[1], start[2], start[3], start[4], start[5]);
92          cal1.set(Calendar.MILLISECOND, 0);
93          final Calendar cal2 = Calendar.getInstance();
94          cal2.set(end[0], end[1], end[2], end[3], end[4], end[5]);
95          cal2.set(Calendar.MILLISECOND, 0);
96          final long milli1 = cal1.getTime().getTime();
97          final long milli2 = cal2.getTime().getTime();
98          final String result = DurationFormatUtils.formatPeriod(milli1, milli2, format);
99          if (message == null) {
100             assertEquals(expected, result);
101         } else {
102             assertEquals(expected, result, message);
103         }
104     }
105 
106     private void assertFormatPeriodOneMilli(final long startMillis, final long endMillis) {
107         final TimeZone gmt = TimeZones.getTimeZone("GMT");
108         assertEquals("1", DurationFormatUtils.formatPeriod(startMillis, endMillis, "S", true, gmt));
109         assertEquals("0/0/0/0/0/0.001",
110                 DurationFormatUtils.formatPeriod(startMillis, endMillis, "y/M/d/H/m/s.S", true, gmt));
111         // formatPeriod must agree with formatDuration over the full range, not just spans near the epoch.
112         assertEquals(DurationFormatUtils.formatDuration(endMillis - startMillis, "S"),
113                 DurationFormatUtils.formatPeriod(startMillis, endMillis, "S", true, gmt));
114     }
115 
116     private void bruteForce(final int year, final int month, final int day, final String format, final int calendarType) {
117         final String msg = year + "-" + month + "-" + day + " to ";
118         final Calendar c = Calendar.getInstance();
119         c.set(year, month, day, 0, 0, 0);
120         final int[] array1 = { year, month, day, 0, 0, 0 };
121         final int[] array2 = { year, month, day, 0, 0, 0 };
122         for (int i = 0; i < FOUR_YEARS; i++) {
123             array2[0] = c.get(Calendar.YEAR);
124             array2[1] = c.get(Calendar.MONTH);
125             array2[2] = c.get(Calendar.DAY_OF_MONTH);
126             final String tmpMsg = msg + array2[0] + "-" + array2[1] + "-" + array2[2] + " at ";
127             assertEqualDuration(tmpMsg + i, Integer.toString(i), array1, array2, format);
128             c.add(calendarType, 1);
129         }
130     }
131 
132     private DurationFormatUtils.Token createTokenWithCount(final Unit value, final int count) {
133         final DurationFormatUtils.Token token = new DurationFormatUtils.Token(value, false, -1);
134         // To help debugging, toString() on a Token should never blow up.
135         assertNotNull(token.toString());
136         for (int i = 1; i < count; i++) {
137             token.increment();
138             assertNotNull(token.toString());
139         }
140         return token;
141     }
142 
143     @Test
144     void testAlternatingLiteralOptionals() {
145         final String format = "['d'dH'h'][m'm']['s's]['ms'S]";
146         assertEquals("d1", DurationFormatUtils.formatDuration(Duration.ofDays(1).toMillis(), format));
147         assertEquals("1h", DurationFormatUtils.formatDuration(Duration.ofHours(1).toMillis(), format));
148         assertEquals("1m", DurationFormatUtils.formatDuration(Duration.ofMinutes(1).toMillis(), format));
149         assertEquals("s1", DurationFormatUtils.formatDuration(Duration.ofSeconds(1).toMillis(), format));
150         assertEquals("ms001", DurationFormatUtils.formatDuration(Duration.ofMillis(1).toMillis(), format));
151         assertEquals("d1s1", DurationFormatUtils.formatDuration(Duration.ofDays(1).plusSeconds(1).toMillis(), format));
152         assertEquals("d11h", DurationFormatUtils.formatDuration(Duration.ofDays(1).plusHours(1).toMillis(), format));
153         assertEquals("d11h1m", DurationFormatUtils.formatDuration(Duration.ofDays(1).plusHours(1).plusMinutes(1).toMillis(), format));
154         assertEquals("d11h1ms1", DurationFormatUtils.formatDuration(Duration.ofDays(1).plusHours(1).plusMinutes(1).plusSeconds(1).toMillis(), format));
155         assertEquals("d11h1ms1ms001",
156                 DurationFormatUtils.formatDuration(Duration.ofDays(1).plusHours(1).plusMinutes(1).plusSeconds(1).plusMillis(1).toMillis(), format));
157     }
158 
159     /** See https://issues.apache.org/bugzilla/show_bug.cgi?id=38401 */
160     @Test
161     void testBugzilla38401() {
162         assertEqualDuration("0000/00/30 16:00:00 000", new int[] { 2006, 0, 26, 18, 47, 34 },
163                              new int[] { 2006, 1, 26, 10, 47, 34 }, "yyyy/MM/dd HH:mm:ss SSS");
164     }
165 
166     @SuppressWarnings("deprecation")
167     @Test
168     void testConstructor() {
169         assertNotNull(new DurationFormatUtils());
170         final Constructor<?>[] cons = DurationFormatUtils.class.getDeclaredConstructors();
171         assertEquals(1, cons.length);
172         assertTrue(Modifier.isPublic(cons[0].getModifiers()));
173         assertTrue(Modifier.isPublic(DurationFormatUtils.class.getModifiers()));
174         assertFalse(Modifier.isFinal(DurationFormatUtils.class.getModifiers()));
175     }
176 
177     @Test
178     void testDurationsByBruteForce() {
179         bruteForce(2006, 0, 1, "d", Calendar.DAY_OF_MONTH);
180         bruteForce(2006, 0, 2, "d", Calendar.DAY_OF_MONTH);
181         bruteForce(2007, 1, 2, "d", Calendar.DAY_OF_MONTH);
182         bruteForce(2004, 1, 29, "d", Calendar.DAY_OF_MONTH);
183         bruteForce(1996, 1, 29, "d", Calendar.DAY_OF_MONTH);
184 
185         bruteForce(1969, 1, 28, "M", Calendar.MONTH);  // tests for 48 years
186         //bruteForce(1996, 1, 29, "M", Calendar.MONTH);  // this will fail
187     }
188 
189     /** Attempting to test edge cases in DurationFormatUtils.formatPeriod. */
190     @Test
191     @DefaultTimeZone(TimeZones.GMT_ID)
192     void testEdgeDurations() {
193         // This test case must use a time zone without DST
194         TimeZone.setDefault(FastTimeZone.getGmtTimeZone());
195         assertEqualDuration("01", new int[] { 2006, 0, 15, 0, 0, 0 }, new int[] { 2006, 2, 10, 0, 0, 0 }, "MM");
196         assertEqualDuration("12", new int[] { 2005, 0, 15, 0, 0, 0 }, new int[] { 2006, 0, 15, 0, 0, 0 }, "MM");
197         assertEqualDuration("12", new int[] { 2005, 0, 15, 0, 0, 0 }, new int[] { 2006, 0, 16, 0, 0, 0 }, "MM");
198         assertEqualDuration("11", new int[] { 2005, 0, 15, 0, 0, 0 }, new int[] { 2006, 0, 14, 0, 0, 0 }, "MM");
199         assertEqualDuration("01 26", new int[] { 2006, 0, 15, 0, 0, 0 }, new int[] { 2006, 2, 10, 0, 0, 0 }, "MM dd");
200         assertEqualDuration("54", new int[] { 2006, 0, 15, 0, 0, 0 }, new int[] { 2006, 2, 10, 0, 0, 0 }, "dd");
201         assertEqualDuration("09 12", new int[] { 2006, 1, 20, 0, 0, 0 }, new int[] { 2006, 11, 4, 0, 0, 0 }, "MM dd");
202         assertEqualDuration("287", new int[] { 2006, 1, 20, 0, 0, 0 }, new int[] { 2006, 11, 4, 0, 0, 0 }, "dd");
203         assertEqualDuration("11 30", new int[] { 2006, 0, 2, 0, 0, 0 }, new int[] { 2007, 0, 1, 0, 0, 0 }, "MM dd");
204         assertEqualDuration("364", new int[] { 2006, 0, 2, 0, 0, 0 }, new int[] { 2007, 0, 1, 0, 0, 0 }, "dd");
205         assertEqualDuration("12 00", new int[] { 2006, 0, 1, 0, 0, 0 }, new int[] { 2007, 0, 1, 0, 0, 0 }, "MM dd");
206         assertEqualDuration("365", new int[] { 2006, 0, 1, 0, 0, 0 }, new int[] { 2007, 0, 1, 0, 0, 0 }, "dd");
207         assertEqualDuration("31", new int[] { 2006, 0, 1, 0, 0, 0 }, new int[] { 2006, 1, 1, 0, 0, 0 }, "dd");
208         assertEqualDuration("92", new int[] { 2005, 9, 1, 0, 0, 0 }, new int[] { 2006, 0, 1, 0, 0, 0 }, "dd");
209         assertEqualDuration("77", new int[] { 2005, 9, 16, 0, 0, 0 }, new int[] { 2006, 0, 1, 0, 0, 0 }, "dd");
210         // test month larger in start than end
211         assertEqualDuration("136", new int[] { 2005, 9, 16, 0, 0, 0 }, new int[] { 2006, 2, 1, 0, 0, 0 }, "dd");
212         // test when start in leap year
213         assertEqualDuration("136", new int[] { 2004, 9, 16, 0, 0, 0 }, new int[] { 2005, 2, 1, 0, 0, 0 }, "dd");
214         // test when end in leap year
215         assertEqualDuration("137", new int[] { 2003, 9, 16, 0, 0, 0 }, new int[] { 2004, 2, 1, 0, 0, 0 }, "dd");
216         // test when end in leap year but less than end of feb
217         assertEqualDuration("135", new int[] { 2003, 9, 16, 0, 0, 0 }, new int[] { 2004, 1, 28, 0, 0, 0 }, "dd");
218         assertEqualDuration("364", new int[] { 2007, 0, 2, 0, 0, 0 }, new int[] { 2008, 0, 1, 0, 0, 0 }, "dd");
219         assertEqualDuration("729", new int[] { 2006, 0, 2, 0, 0, 0 }, new int[] { 2008, 0, 1, 0, 0, 0 }, "dd");
220         assertEqualDuration("365", new int[] { 2007, 2, 2, 0, 0, 0 }, new int[] { 2008, 2, 1, 0, 0, 0 }, "dd");
221         assertEqualDuration("333", new int[] { 2007, 1, 2, 0, 0, 0 }, new int[] { 2008, 0, 1, 0, 0, 0 }, "dd");
222         assertEqualDuration("28", new int[] { 2008, 1, 2, 0, 0, 0 }, new int[] { 2008, 2, 1, 0, 0, 0 }, "dd");
223         assertEqualDuration("393", new int[] { 2007, 1, 2, 0, 0, 0 }, new int[] { 2008, 2, 1, 0, 0, 0 }, "dd");
224         assertEqualDuration("369", new int[] { 2004, 0, 29, 0, 0, 0 }, new int[] { 2005, 1, 1, 0, 0, 0 }, "dd");
225         assertEqualDuration("338", new int[] { 2004, 1, 29, 0, 0, 0 }, new int[] { 2005, 1, 1, 0, 0, 0 }, "dd");
226         assertEqualDuration("28", new int[] { 2004, 2, 8, 0, 0, 0 }, new int[] { 2004, 3, 5, 0, 0, 0 }, "dd");
227         assertEqualDuration("48", new int[] { 1992, 1, 29, 0, 0, 0 }, new int[] { 1996, 1, 29, 0, 0, 0 }, "M");
228         // this seems odd - and will fail if I throw it in as a brute force
229         // below as it expects the answer to be 12. It's a tricky edge case
230         assertEqualDuration("11", new int[] { 1996, 1, 29, 0, 0, 0 }, new int[] { 1997, 1, 28, 0, 0, 0 }, "M");
231         // again - this seems odd
232         assertEqualDuration("11 28", new int[] { 1996, 1, 29, 0, 0, 0 }, new int[] { 1997, 1, 28, 0, 0, 0 }, "M d");
233     }
234 
235     @Test
236     void testEmptyOptionals() {
237         assertEquals("", DurationFormatUtils.formatDuration(0L, "[d'd'][H'h'][m'm'][s's']"));
238         assertEquals("", DurationFormatUtils.formatDuration(0L, "['d''h''m''s's]"));
239     }
240 
241     @Test
242     void testFormatDuration() {
243         long duration = 0;
244         assertEquals("0", DurationFormatUtils.formatDuration(duration, "y"));
245         assertEquals("0", DurationFormatUtils.formatDuration(duration, "M"));
246         assertEquals("0", DurationFormatUtils.formatDuration(duration, "d"));
247         assertEquals("0", DurationFormatUtils.formatDuration(duration, "H"));
248         assertEquals("0", DurationFormatUtils.formatDuration(duration, "m"));
249         assertEquals("0", DurationFormatUtils.formatDuration(duration, "s"));
250         assertEquals("0", DurationFormatUtils.formatDuration(duration, "S"));
251         assertEquals("0000", DurationFormatUtils.formatDuration(duration, "SSSS"));
252         assertEquals("0000", DurationFormatUtils.formatDuration(duration, "yyyy"));
253         assertEquals("0000", DurationFormatUtils.formatDuration(duration, "yyMM"));
254 
255         duration = 60 * 1000;
256         assertEquals("0", DurationFormatUtils.formatDuration(duration, "y"));
257         assertEquals("0", DurationFormatUtils.formatDuration(duration, "M"));
258         assertEquals("0", DurationFormatUtils.formatDuration(duration, "d"));
259         assertEquals("0", DurationFormatUtils.formatDuration(duration, "H"));
260         assertEquals("1", DurationFormatUtils.formatDuration(duration, "m"));
261         assertEquals("60", DurationFormatUtils.formatDuration(duration, "s"));
262         assertEquals("60000", DurationFormatUtils.formatDuration(duration, "S"));
263         assertEquals("01:00", DurationFormatUtils.formatDuration(duration, "mm:ss"));
264 
265         final Calendar base = Calendar.getInstance();
266         base.set(2000, Calendar.JANUARY, 1, 0, 0, 0);
267         base.set(Calendar.MILLISECOND, 0);
268 
269         final Calendar cal = Calendar.getInstance();
270         cal.set(2003, Calendar.FEBRUARY, 1, 0, 0, 0);
271         cal.set(Calendar.MILLISECOND, 0);
272         duration = cal.getTime().getTime() - base.getTime().getTime(); // duration from 2000-01-01 to cal
273         // don't use 1970 in test as time zones were less reliable in 1970 than now
274         // remember that duration formatting ignores time zones, working on strict hour lengths
275         final int days = 366 + 365 + 365 + 31;
276         assertEquals("0 0 " + days, DurationFormatUtils.formatDuration(duration, "y M d"));
277     }
278 
279     @Test
280     void testFormatDurationHMS() {
281         long time = 0;
282         assertEquals("00:00:00.000", DurationFormatUtils.formatDurationHMS(time));
283         time = 1;
284         assertEquals("00:00:00.001", DurationFormatUtils.formatDurationHMS(time));
285         time = 15;
286         assertEquals("00:00:00.015", DurationFormatUtils.formatDurationHMS(time));
287         time = 165;
288         assertEquals("00:00:00.165", DurationFormatUtils.formatDurationHMS(time));
289         time = 1675;
290         assertEquals("00:00:01.675", DurationFormatUtils.formatDurationHMS(time));
291         time = 13465;
292         assertEquals("00:00:13.465", DurationFormatUtils.formatDurationHMS(time));
293         time = 72789;
294         assertEquals("00:01:12.789", DurationFormatUtils.formatDurationHMS(time));
295         time = 12789 + 32 * 60000;
296         assertEquals("00:32:12.789", DurationFormatUtils.formatDurationHMS(time));
297         time = 12789 + 62 * 60000;
298         assertEquals("01:02:12.789", DurationFormatUtils.formatDurationHMS(time));
299     }
300 
301     @Test
302     void testFormatDurationISO() {
303         assertEquals("P0Y0M0DT0H0M0.000S", DurationFormatUtils.formatDurationISO(0L));
304         assertEquals("P0Y0M0DT0H0M0.001S", DurationFormatUtils.formatDurationISO(1L));
305         assertEquals("P0Y0M0DT0H0M0.010S", DurationFormatUtils.formatDurationISO(10L));
306         assertEquals("P0Y0M0DT0H0M0.100S", DurationFormatUtils.formatDurationISO(100L));
307         assertEquals("P0Y0M0DT0H1M15.321S", DurationFormatUtils.formatDurationISO(75321L));
308     }
309 
310     /**
311      * Tests that "1 &lt;unit&gt;s" gets converted to "1 &lt;unit&gt;" but that "11 &lt;unit&gt;s" is left alone.
312      */
313     @Test
314     void testFormatDurationPluralWords() {
315         final long oneSecond = 1000;
316         final long oneMinute = oneSecond * 60;
317         final long oneHour = oneMinute * 60;
318         final long oneDay = oneHour * 24;
319         String text;
320 
321         text = DurationFormatUtils.formatDurationWords(oneSecond, false, false);
322         assertEquals("0 days 0 hours 0 minutes 1 second", text);
323         text = DurationFormatUtils.formatDurationWords(oneSecond * 2, false, false);
324         assertEquals("0 days 0 hours 0 minutes 2 seconds", text);
325         text = DurationFormatUtils.formatDurationWords(oneSecond * 11, false, false);
326         assertEquals("0 days 0 hours 0 minutes 11 seconds", text);
327 
328         text = DurationFormatUtils.formatDurationWords(oneMinute, false, false);
329         assertEquals("0 days 0 hours 1 minute 0 seconds", text);
330         text = DurationFormatUtils.formatDurationWords(oneMinute * 2, false, false);
331         assertEquals("0 days 0 hours 2 minutes 0 seconds", text);
332         text = DurationFormatUtils.formatDurationWords(oneMinute * 11, false, false);
333         assertEquals("0 days 0 hours 11 minutes 0 seconds", text);
334         text = DurationFormatUtils.formatDurationWords(oneMinute + oneSecond, false, false);
335         assertEquals("0 days 0 hours 1 minute 1 second", text);
336 
337         text = DurationFormatUtils.formatDurationWords(oneHour, false, false);
338         assertEquals("0 days 1 hour 0 minutes 0 seconds", text);
339         text = DurationFormatUtils.formatDurationWords(oneHour * 2, false, false);
340         assertEquals("0 days 2 hours 0 minutes 0 seconds", text);
341         text = DurationFormatUtils.formatDurationWords(oneHour * 11, false, false);
342         assertEquals("0 days 11 hours 0 minutes 0 seconds", text);
343         text = DurationFormatUtils.formatDurationWords(oneHour + oneMinute + oneSecond, false, false);
344         assertEquals("0 days 1 hour 1 minute 1 second", text);
345 
346         text = DurationFormatUtils.formatDurationWords(oneDay, false, false);
347         assertEquals("1 day 0 hours 0 minutes 0 seconds", text);
348         text = DurationFormatUtils.formatDurationWords(oneDay * 2, false, false);
349         assertEquals("2 days 0 hours 0 minutes 0 seconds", text);
350         text = DurationFormatUtils.formatDurationWords(oneDay * 11, false, false);
351         assertEquals("11 days 0 hours 0 minutes 0 seconds", text);
352         text = DurationFormatUtils.formatDurationWords(oneDay + oneHour + oneMinute + oneSecond, false, false);
353         assertEquals("1 day 1 hour 1 minute 1 second", text);
354     }
355 
356     @Test
357     void testFormatDurationWords() {
358         String text;
359 
360         text = DurationFormatUtils.formatDurationWords(50 * 1000, true, false);
361         assertEquals("50 seconds", text);
362         text = DurationFormatUtils.formatDurationWords(65 * 1000, true, false);
363         assertEquals("1 minute 5 seconds", text);
364         text = DurationFormatUtils.formatDurationWords(120 * 1000, true, false);
365         assertEquals("2 minutes 0 seconds", text);
366         text = DurationFormatUtils.formatDurationWords(121 * 1000, true, false);
367         assertEquals("2 minutes 1 second", text);
368         text = DurationFormatUtils.formatDurationWords(72 * 60 * 1000, true, false);
369         assertEquals("1 hour 12 minutes 0 seconds", text);
370         text = DurationFormatUtils.formatDurationWords(24 * 60 * 60 * 1000, true, false);
371         assertEquals("1 day 0 hours 0 minutes 0 seconds", text);
372 
373         text = DurationFormatUtils.formatDurationWords(50 * 1000, true, true);
374         assertEquals("50 seconds", text);
375         text = DurationFormatUtils.formatDurationWords(65 * 1000, true, true);
376         assertEquals("1 minute 5 seconds", text);
377         text = DurationFormatUtils.formatDurationWords(120 * 1000, true, true);
378         assertEquals("2 minutes", text);
379         text = DurationFormatUtils.formatDurationWords(121 * 1000, true, true);
380         assertEquals("2 minutes 1 second", text);
381         text = DurationFormatUtils.formatDurationWords(72 * 60 * 1000, true, true);
382         assertEquals("1 hour 12 minutes", text);
383         text = DurationFormatUtils.formatDurationWords(24 * 60 * 60 * 1000, true, true);
384         assertEquals("1 day", text);
385 
386         text = DurationFormatUtils.formatDurationWords(50 * 1000, false, true);
387         assertEquals("0 days 0 hours 0 minutes 50 seconds", text);
388         text = DurationFormatUtils.formatDurationWords(65 * 1000, false, true);
389         assertEquals("0 days 0 hours 1 minute 5 seconds", text);
390         text = DurationFormatUtils.formatDurationWords(120 * 1000, false, true);
391         assertEquals("0 days 0 hours 2 minutes", text);
392         text = DurationFormatUtils.formatDurationWords(121 * 1000, false, true);
393         assertEquals("0 days 0 hours 2 minutes 1 second", text);
394         text = DurationFormatUtils.formatDurationWords(72 * 60 * 1000, false, true);
395         assertEquals("0 days 1 hour 12 minutes", text);
396         text = DurationFormatUtils.formatDurationWords(24 * 60 * 60 * 1000, false, true);
397         assertEquals("1 day", text);
398 
399         text = DurationFormatUtils.formatDurationWords(50 * 1000, false, false);
400         assertEquals("0 days 0 hours 0 minutes 50 seconds", text);
401         text = DurationFormatUtils.formatDurationWords(65 * 1000, false, false);
402         assertEquals("0 days 0 hours 1 minute 5 seconds", text);
403         text = DurationFormatUtils.formatDurationWords(120 * 1000, false, false);
404         assertEquals("0 days 0 hours 2 minutes 0 seconds", text);
405         text = DurationFormatUtils.formatDurationWords(121 * 1000, false, false);
406         assertEquals("0 days 0 hours 2 minutes 1 second", text);
407         text = DurationFormatUtils.formatDurationWords(72 * 60 * 1000, false, false);
408         assertEquals("0 days 1 hour 12 minutes 0 seconds", text);
409         text = DurationFormatUtils.formatDurationWords(24 * 60 * 60 * 1000 + 72 * 60 * 1000, false, false);
410         assertEquals("1 day 1 hour 12 minutes 0 seconds", text);
411         text = DurationFormatUtils.formatDurationWords(2 * 24 * 60 * 60 * 1000 + 72 * 60 * 1000, false, false);
412         assertEquals("2 days 1 hour 12 minutes 0 seconds", text);
413         for (int i = 2; i < 31; i++) {
414             text = DurationFormatUtils.formatDurationWords(i * 24 * 60 * 60 * 1000L, false, false);
415             assertEquals(i + " days 0 hours 0 minutes 0 seconds", text);
416         }
417     }
418 
419     @Test
420     void testFormatNegativeDuration() {
421         assertIllegalArgumentException(() -> DurationFormatUtils.formatDuration(-5000, "S", true));
422     }
423 
424     @Test
425     void testFormatNegativeDurationHMS() {
426         assertIllegalArgumentException(() -> DurationFormatUtils.formatDurationHMS(-5000));
427     }
428 
429     @Test
430     void testFormatNegativeDurationISO() {
431         assertIllegalArgumentException(() -> DurationFormatUtils.formatDurationISO(-5000));
432     }
433 
434     @Test
435     void testFormatNegativeDurationWords() {
436         assertIllegalArgumentException(() -> DurationFormatUtils.formatDurationWords(-5000, true, true));
437     }
438 
439     @Test
440     void testFormatPeriod() {
441         final Calendar cal1970 = Calendar.getInstance();
442         cal1970.set(1970, Calendar.JANUARY, 1, 0, 0, 0);
443         cal1970.set(Calendar.MILLISECOND, 0);
444         final long time1970 = cal1970.getTime().getTime();
445 
446         assertEquals("0", DurationFormatUtils.formatPeriod(time1970, time1970, "y"));
447         assertEquals("0", DurationFormatUtils.formatPeriod(time1970, time1970, "M"));
448         assertEquals("0", DurationFormatUtils.formatPeriod(time1970, time1970, "d"));
449         assertEquals("0", DurationFormatUtils.formatPeriod(time1970, time1970, "H"));
450         assertEquals("0", DurationFormatUtils.formatPeriod(time1970, time1970, "m"));
451         assertEquals("0", DurationFormatUtils.formatPeriod(time1970, time1970, "s"));
452         assertEquals("0", DurationFormatUtils.formatPeriod(time1970, time1970, "S"));
453         assertEquals("0000", DurationFormatUtils.formatPeriod(time1970, time1970, "SSSS"));
454         assertEquals("0000", DurationFormatUtils.formatPeriod(time1970, time1970, "yyyy"));
455         assertEquals("0000", DurationFormatUtils.formatPeriod(time1970, time1970, "yyMM"));
456 
457         long time = time1970 + 60 * 1000;
458         assertEquals("0", DurationFormatUtils.formatPeriod(time1970, time, "y"));
459         assertEquals("0", DurationFormatUtils.formatPeriod(time1970, time, "M"));
460         assertEquals("0", DurationFormatUtils.formatPeriod(time1970, time, "d"));
461         assertEquals("0", DurationFormatUtils.formatPeriod(time1970, time, "H"));
462         assertEquals("1", DurationFormatUtils.formatPeriod(time1970, time, "m"));
463         assertEquals("60", DurationFormatUtils.formatPeriod(time1970, time, "s"));
464         assertEquals("60000", DurationFormatUtils.formatPeriod(time1970, time, "S"));
465         assertEquals("01:00", DurationFormatUtils.formatPeriod(time1970, time, "mm:ss"));
466 
467         final Calendar cal = Calendar.getInstance();
468         cal.set(1973, Calendar.JULY, 1, 0, 0, 0);
469         cal.set(Calendar.MILLISECOND, 0);
470         time = cal.getTime().getTime();
471         assertEquals("36", DurationFormatUtils.formatPeriod(time1970, time, "yM"));
472         assertEquals("3 years 6 months", DurationFormatUtils.formatPeriod(time1970, time, "y' years 'M' months'"));
473         assertEquals("03/06", DurationFormatUtils.formatPeriod(time1970, time, "yy/MM"));
474 
475         cal.set(1973, Calendar.NOVEMBER, 1, 0, 0, 0);
476         cal.set(Calendar.MILLISECOND, 0);
477         time = cal.getTime().getTime();
478         assertEquals("310", DurationFormatUtils.formatPeriod(time1970, time, "yM"));
479         assertEquals("3 years 10 months", DurationFormatUtils.formatPeriod(time1970, time, "y' years 'M' months'"));
480         assertEquals("03/10", DurationFormatUtils.formatPeriod(time1970, time, "yy/MM"));
481 
482         cal.set(1974, Calendar.JANUARY, 1, 0, 0, 0);
483         cal.set(Calendar.MILLISECOND, 0);
484         time = cal.getTime().getTime();
485         assertEquals("40", DurationFormatUtils.formatPeriod(time1970, time, "yM"));
486         assertEquals("4 'years 0 months", DurationFormatUtils.formatPeriod(time1970, time, "y' ''years' M 'months'"));
487         assertEquals("4 years 0 months", DurationFormatUtils.formatPeriod(time1970, time, "y' years 'M' months'"));
488         assertEquals("4years 0months", DurationFormatUtils.formatPeriod(time1970, time, "y'years 'M'months'"));
489         assertEquals("04/00", DurationFormatUtils.formatPeriod(time1970, time, "yy/MM"));
490         assertEquals("48", DurationFormatUtils.formatPeriod(time1970, time, "M"));
491         assertEquals("48", DurationFormatUtils.formatPeriod(time1970, time, "MM"));
492         assertEquals("048", DurationFormatUtils.formatPeriod(time1970, time, "MMM"));
493         // no date in result
494         assertEquals("hello", DurationFormatUtils.formatPeriod(time1970, time, "'hello'"));
495         assertEquals("hello'world", DurationFormatUtils.formatPeriod(time1970, time, "'hello''world'"));
496     }
497 
498     @Test
499     void testFormatPeriodeStartGreaterEnd() {
500         assertIllegalArgumentException(() -> DurationFormatUtils.formatPeriod(5000, 2500, "yy/MM"));
501     }
502 
503     @Test
504     void testFormatPeriodExtremeDatesWithOffsets() {
505         assertTimeoutPreemptively(Duration.ofSeconds(5), () -> {
506             final String format = "d H m s S";
507             final String expected = DurationFormatUtils.formatDuration(Long.MAX_VALUE, format);
508             for (final String zone : new String[] { "GMT", "GMT+14:00", "GMT-12:00" }) {
509                 final TimeZone timeZone = TimeZones.getTimeZone(zone);
510                 assertEquals(expected, DurationFormatUtils.formatPeriod(0, Long.MAX_VALUE, format, true, timeZone), zone);
511                 assertEquals(expected, DurationFormatUtils.formatPeriod(Long.MIN_VALUE, -1, format, true, timeZone), zone);
512                 assertEquals("213503982334", DurationFormatUtils.formatPeriod(Long.MIN_VALUE, Long.MAX_VALUE, "d", true, timeZone), zone);
513             }
514         });
515     }
516 
517     @SuppressWarnings("deprecation")
518     @Test
519     void testFormatPeriodISO() {
520         final TimeZone timeZone = TimeZones.getTimeZone("GMT-3");
521         final Calendar base = Calendar.getInstance(timeZone);
522         base.set(1970, Calendar.JANUARY, 1, 0, 0, 0);
523         base.set(Calendar.MILLISECOND, 0);
524 
525         final Calendar cal = Calendar.getInstance(timeZone);
526         cal.set(2002, Calendar.FEBRUARY, 23, 9, 11, 12);
527         cal.set(Calendar.MILLISECOND, 1);
528         String text;
529         // repeat a test from testDateTimeISO to compare extended and not extended.
530         text = DateFormatUtils.format(cal, DateFormatUtils.ISO_DATETIME_TIME_ZONE_FORMAT.getPattern(), timeZone);
531         assertEquals("2002-02-23T09:11:12-03:00", text);
532         // test fixture is the same as above, but now with extended format.
533         text = DurationFormatUtils.formatPeriod(base.getTime().getTime(), cal.getTime().getTime(),
534                 DurationFormatUtils.ISO_EXTENDED_FORMAT_PATTERN, false, timeZone);
535         assertEquals("P32Y1M22DT9H11M12.001S", text);
536         // test fixture from example in https://www.w3.org/TR/xmlschema-2/#duration
537         cal.set(1971, Calendar.FEBRUARY, 3, 10, 30, 0);
538         cal.set(Calendar.MILLISECOND, 0);
539         text = DurationFormatUtils.formatPeriod(base.getTime().getTime(), cal.getTime().getTime(),
540                 DurationFormatUtils.ISO_EXTENDED_FORMAT_PATTERN, false, timeZone);
541         assertEquals("P1Y1M2DT10H30M0.000S", text);
542         // want a way to say 'don't print the seconds in format()' or other fields for that matter:
543         // assertEquals("P1Y2M3DT10H30M", text);
544     }
545 
546     @Test
547     void testFormatPeriodISOAcrossMonths() {
548         final TimeZone tz = TimeZones.getTimeZone("GMT-3");
549         // Verifies period formatting across a month boundary (Jan 31 to Feb 1)
550         final Calendar start = Calendar.getInstance(tz);
551         start.clear();
552         start.set(2020, Calendar.JANUARY, 31);
553         final Calendar end = Calendar.getInstance(tz);
554         end.clear();
555         end.set(2020, Calendar.FEBRUARY, 1);
556         final String result = DurationFormatUtils.formatPeriod(start.getTimeInMillis(), end.getTimeInMillis(), DurationFormatUtils.ISO_EXTENDED_FORMAT_PATTERN,
557                 false, tz);
558         assertEquals("P0Y0M1DT0H0M0.000S", result);
559     }
560 
561     @Test
562     void testFormatPeriodISOLeapYearBoundary() {
563         final TimeZone tz = TimeZones.getTimeZone("GMT-3");
564         // Verifies period formatting across a leap-year boundary (Feb 29 to Mar 1)
565         final Calendar start = Calendar.getInstance(tz);
566         start.clear();
567         start.set(2020, Calendar.FEBRUARY, 29);
568         final Calendar end = Calendar.getInstance(tz);
569         end.clear();
570         end.set(2020, Calendar.MARCH, 1);
571         final String result = DurationFormatUtils.formatPeriod(start.getTimeInMillis(), end.getTimeInMillis(), DurationFormatUtils.ISO_EXTENDED_FORMAT_PATTERN,
572                 false, tz);
573         assertEquals("P0Y0M1DT0H0M0.000S", result);
574     }
575 
576     @Test
577     void testFormatPeriodISOMethod() {
578         assertEquals("P0Y0M0DT0H0M0.000S", DurationFormatUtils.formatPeriodISO(0L, 0L));
579         assertEquals("P0Y0M0DT0H0M1.000S", DurationFormatUtils.formatPeriodISO(0L, 1000L));
580         assertEquals("P0Y0M0DT0H1M1.000S", DurationFormatUtils.formatPeriodISO(0L, 61000L));
581     }
582 
583     @Test
584     void testFormatPeriodISOStartGreaterEnd() {
585         assertIllegalArgumentException(() -> DurationFormatUtils.formatPeriodISO(5000, 2000));
586     }
587 
588     @Test
589     void testFormatPeriodLargeFunnelledValue() {
590         final TimeZone gmt = TimeZones.getTimeZone("GMT");
591         // ~69 years, chosen so the seconds count exceeds Integer.MAX_VALUE once days/hours/minutes are
592         // funnelled into the single requested field.
593         final long endMillis = 2_175_984_000_000L;
594         assertEquals("2175984000", DurationFormatUtils.formatPeriod(0, endMillis, "s", true, gmt));
595         assertEquals("2175984000000", DurationFormatUtils.formatPeriod(0, endMillis, "S", true, gmt));
596         // formatPeriod must agree with formatDuration, which reduces the same span in long arithmetic.
597         assertEquals(DurationFormatUtils.formatDuration(endMillis, "s"),
598                 DurationFormatUtils.formatPeriod(0, endMillis, "s", true, gmt));
599     }
600 
601     /**
602      * Leap-day boundaries across the year-normalization fast path (values verified against the previous year-by-year walk).
603      */
604     @Test
605     void testFormatPeriodLeapDayBoundaries() {
606         final TimeZone gmt = TimeZones.getTimeZone("GMT");
607         final Calendar leapDay = Calendar.getInstance(gmt);
608         leapDay.clear();
609         leapDay.set(2000, Calendar.FEBRUARY, 29, 0, 0, 0);
610         final Calendar feb28 = Calendar.getInstance(gmt);
611         feb28.clear();
612         feb28.set(2005, Calendar.FEBRUARY, 28, 0, 0, 0);
613         assertEquals("1826", DurationFormatUtils.formatPeriod(leapDay.getTimeInMillis(), feb28.getTimeInMillis(), "d", true, gmt));
614         final Calendar mar1 = Calendar.getInstance(gmt);
615         mar1.clear();
616         mar1.set(2005, Calendar.MARCH, 1, 0, 0, 0);
617         assertEquals("1827", DurationFormatUtils.formatPeriod(leapDay.getTimeInMillis(), mar1.getTimeInMillis(), "d", true, gmt));
618         final Calendar mar1999 = Calendar.getInstance(gmt);
619         mar1999.clear();
620         mar1999.set(1999, Calendar.MARCH, 1, 0, 0, 0);
621         assertEquals("2191", DurationFormatUtils.formatPeriod(mar1999.getTimeInMillis(), feb28.getTimeInMillis(), "d", true, gmt));
622     }
623 
624     @Test
625     void testFormatPeriodLeapDayWithTimeBorrowing() {
626         final TimeZone timeZone = TimeZones.getTimeZone("GMT");
627         final Calendar start = Calendar.getInstance(timeZone);
628         start.clear();
629         start.set(2000, Calendar.FEBRUARY, 29, 23, 59, 59);
630         start.set(Calendar.MILLISECOND, 999);
631         final Calendar end = Calendar.getInstance(timeZone);
632         end.clear();
633         end.set(2005, Calendar.FEBRUARY, 28);
634         assertEquals("1825 0 0 0 001", DurationFormatUtils.formatPeriod(start.getTimeInMillis(), end.getTimeInMillis(), "d H m s S", true, timeZone));
635     }
636 
637     @Test
638     void testFormatPeriodLocalDaysAcrossDaylightSaving() {
639         final TimeZone timeZone = TimeZones.getTimeZone("America/New_York");
640         final Calendar start = Calendar.getInstance(timeZone);
641         start.clear();
642         start.set(2024, Calendar.MARCH, 9, 12, 0, 0);
643         final Calendar end = (Calendar) start.clone();
644         end.add(Calendar.DAY_OF_MONTH, 1);
645         assertEquals(Duration.ofHours(23).toMillis(), end.getTimeInMillis() - start.getTimeInMillis());
646         assertEquals("1 0", DurationFormatUtils.formatPeriod(start.getTimeInMillis(), end.getTimeInMillis(), "d H", true, timeZone));
647         start.set(2024, Calendar.NOVEMBER, 2, 12, 0, 0);
648         end.setTimeInMillis(start.getTimeInMillis());
649         end.add(Calendar.DAY_OF_MONTH, 1);
650         assertEquals(Duration.ofHours(25).toMillis(), end.getTimeInMillis() - start.getTimeInMillis());
651         assertEquals("1 0", DurationFormatUtils.formatPeriod(start.getTimeInMillis(), end.getTimeInMillis(), "d H", true, timeZone));
652     }
653 
654     @Test
655     void testFormatPeriodLongRangeBounds() {
656         // A one-millisecond span sitting at the extremes of the long input range must still reduce
657         // correctly, confirming formatPeriod handles the whole range of millisecond inputs.
658         assertFormatPeriodOneMilli(Long.MAX_VALUE - 1, Long.MAX_VALUE);
659         assertFormatPeriodOneMilli(Long.MIN_VALUE, Long.MIN_VALUE + 1);
660         assertFormatPeriodOneMilli((long) Integer.MIN_VALUE - 1, Integer.MIN_VALUE);
661     }
662 
663     /**
664      * The no-y/no-M path used to normalize years by walking the calendar one year per loop iteration, making the cost linear in the span: this case took ~292
665      * million Calendar round trips. It must complete promptly and produce the exact day count.
666      */
667     @Test
668     void testFormatPeriodMaximumSpanCompletesQuickly() {
669         final TimeZone gmt = TimeZones.getTimeZone("GMT");
670         // floor(Long.MAX_VALUE / MILLIS_PER_DAY) days from the epoch, with time-of-day remainders that never borrow.
671         assertTimeoutPreemptively(Duration.ofSeconds(5),
672                 () -> assertEquals("106751991167", DurationFormatUtils.formatPeriod(0, Long.MAX_VALUE, "d", true, gmt)));
673     }
674 
675     @Test
676     void testFormatPeriodWithoutMonths() {
677         final TimeZone timeZone = TimeZone.getTimeZone("UTC");
678         final Calendar start = Calendar.getInstance(timeZone);
679         start.set(2024, Calendar.DECEMBER, 15, 0, 0, 0);
680         start.set(Calendar.MILLISECOND, 0);
681 
682         final Calendar end = Calendar.getInstance(timeZone);
683         end.set(2025, Calendar.JANUARY, 15, 0, 0, 0);
684         end.set(Calendar.MILLISECOND, 0);
685 
686         // 31 days elapsed across year boundary
687         assertEquals("0 years 31 days", DurationFormatUtils.formatPeriod(start.getTimeInMillis(), end.getTimeInMillis(), "y' years 'd' days'", false, timeZone));
688         assertEquals("0y 31d", DurationFormatUtils.formatPeriod(start.getTimeInMillis(), end.getTimeInMillis(), "y'y 'd'd'", false, timeZone));
689 
690         // 361 days elapsed (less than 1 full year)
691         start.set(2024, Calendar.JANUARY, 15, 0, 0, 0);
692         end.set(2025, Calendar.JANUARY, 10, 0, 0, 0);
693         assertEquals("0 years 361 days", DurationFormatUtils.formatPeriod(start.getTimeInMillis(), end.getTimeInMillis(), "y' years 'd' days'", false, timeZone));
694 
695         // Leap year to non-leap year (Feb 29, 2024 to Feb 28, 2025 = 365 days)
696         start.set(2024, Calendar.FEBRUARY, 29, 0, 0, 0);
697         end.set(2025, Calendar.FEBRUARY, 28, 0, 0, 0);
698         assertEquals("0 years 365 days", DurationFormatUtils.formatPeriod(start.getTimeInMillis(), end.getTimeInMillis(), "y' years 'd' days'", false, timeZone));
699     }
700 
701     @Test
702     void testFormatPeriodWithoutMonthsAfterLeapDayAnniversary() {
703         final TimeZone timeZone = TimeZone.getTimeZone("UTC");
704         final Calendar start = Calendar.getInstance(timeZone);
705         start.clear();
706         // 2020 was a leap year
707         start.set(2020, Calendar.FEBRUARY, 29);
708         final Calendar end = Calendar.getInstance(timeZone);
709         end.clear();
710         // 2021 was not a leap year
711         end.set(2021, Calendar.MARCH, 1);
712         assertEquals("1 years 1 days", DurationFormatUtils.formatPeriod(start.getTimeInMillis(), end.getTimeInMillis(), "y' years 'd' days'", false, timeZone));
713     }
714 
715     /**
716      * Takes 8 seconds to run.
717      */
718     @Test
719     void testFourYears() {
720         final Calendar c = Calendar.getInstance();
721         c.set(2004, 0, 1, 0, 0, 0);
722         for (int i = 0; i < FOUR_YEARS; i++) {
723             bruteForce(c.get(Calendar.YEAR), c.get(Calendar.MONTH), c.get(Calendar.DAY_OF_MONTH), "d", Calendar.DAY_OF_MONTH);
724             c.add(Calendar.DAY_OF_MONTH, 1);
725         }
726     }
727 
728     @ParameterizedTest
729     @MethodSource
730     void testFractionalSecondsPadding(final String format, final boolean padWithZeros, final String expected) {
731         assertEquals(expected, DurationFormatUtils.formatDuration(1007, format, padWithZeros));
732         assertEquals(expected, DurationFormatUtils.formatPeriod(0, 1007, format, padWithZeros, TimeZones.getTimeZone("GMT")));
733     }
734 
735     // https://issues.apache.org/jira/browse/LANG-281
736     @Test
737     void testJiraLang281() {
738         assertEqualDuration("09", new int[] { 2005, 11, 31, 0, 0, 0 }, new int[] { 2006, 9, 6, 0, 0, 0 }, "MM");
739     }
740 
741     @ParameterizedTest
742     @MethodSource
743     void testLANG1827(final String label, final String expected, final long durationMillis, final String format) {
744         assertEquals(expected, DurationFormatUtils.formatDuration(durationMillis, format), label);
745     }
746 
747     @Test
748     void testLANG1827UnmatchedQuote() {
749         assertIllegalArgumentException(() -> DurationFormatUtils.lexx("'unmatched"));
750     }
751 
752     @Test
753     void testLANG815() {
754         final Calendar calendar = Calendar.getInstance();
755         calendar.set(2012, Calendar.JULY, 30, 0, 0, 0);
756         final long startMillis = calendar.getTimeInMillis();
757 
758         calendar.set(2012, Calendar.SEPTEMBER, 8);
759         final long endMillis = calendar.getTimeInMillis();
760 
761         assertEquals("1 9", DurationFormatUtils.formatPeriod(startMillis, endMillis, "M d"));
762     }
763 
764     @Test
765     void testLANG981() { // unmatched quote char in lexx
766         assertIllegalArgumentException(() -> DurationFormatUtils.lexx("'yMdHms''S"));
767     }
768 
769     @Test
770     void testLANG982() { // More than 3 millisecond digits following a second
771         assertEquals("61.999", DurationFormatUtils.formatDuration(61999, "s.S"));
772         assertEquals("1 1999", DurationFormatUtils.formatDuration(61999, "m S"));
773         assertEquals("61.999", DurationFormatUtils.formatDuration(61999, "s.SSS"));
774         assertEquals("1 1999", DurationFormatUtils.formatDuration(61999, "m SSS"));
775         assertEquals("61.0999", DurationFormatUtils.formatDuration(61999, "s.SSSS"));
776         assertEquals("1 1999", DurationFormatUtils.formatDuration(61999, "m SSSS"));
777         assertEquals("61.00999", DurationFormatUtils.formatDuration(61999, "s.SSSSS"));
778         assertEquals("1 01999", DurationFormatUtils.formatDuration(61999, "m SSSSS"));
779     }
780 
781     @Test
782     void testLANG984() { // Long durations
783         assertEquals("0", DurationFormatUtils.formatDuration(0, "S"));
784         assertEquals(Integer.toString(Integer.MAX_VALUE), DurationFormatUtils.formatDuration(Integer.MAX_VALUE, "S"));
785         long maxIntPlus = Integer.MAX_VALUE;
786         maxIntPlus++;
787         assertEquals(Long.toString(maxIntPlus), DurationFormatUtils.formatDuration(maxIntPlus, "S"));
788         assertEquals(Long.toString(Long.MAX_VALUE), DurationFormatUtils.formatDuration(Long.MAX_VALUE, "S"));
789     }
790 
791     @Test
792     void testLexx() {
793         // tests each constant
794         assertArrayEquals(new DurationFormatUtils.Token[] {
795             createTokenWithCount(Unit.YEAR, 1),
796             createTokenWithCount(Unit.MONTH, 1),
797             createTokenWithCount(Unit.DAY, 1),
798             createTokenWithCount(Unit.HOUR, 1),
799             createTokenWithCount(Unit.MINUTE, 1),
800             createTokenWithCount(Unit.SECOND, 1),
801             createTokenWithCount(Unit.MILLISECOND, 1) }, DurationFormatUtils.lexx("yMdHmsS"));
802         // tests the ISO 8601-like
803         assertArrayEquals(new DurationFormatUtils.Token[] {
804             createTokenWithCount(Unit.HOUR, 2),
805             new Token(new StringBuilder(":"), false, -1),
806             createTokenWithCount(Unit.MINUTE, 2),
807             new Token(new StringBuilder(":"), false, -1),
808             createTokenWithCount(Unit.SECOND, 2),
809             new Token(new StringBuilder("."), false, -1),
810             createTokenWithCount(Unit.MILLISECOND, 3) }, DurationFormatUtils.lexx("HH:mm:ss.SSS"));
811         // test the iso extended format
812         assertArrayEquals(new DurationFormatUtils.Token[] {
813             new Token(new StringBuilder("P"), false, -1),
814             createTokenWithCount(Unit.YEAR, 4),
815             new Token(new StringBuilder("Y"), false, -1),
816             createTokenWithCount(Unit.MONTH, 1),
817             new Token(new StringBuilder("M"), false, -1),
818             createTokenWithCount(Unit.DAY, 1),
819             new Token(new StringBuilder("DT"), false, -1),
820             createTokenWithCount(Unit.HOUR, 1),
821             new Token(new StringBuilder("H"), false, -1),
822             createTokenWithCount(Unit.MINUTE, 1),
823             new Token(new StringBuilder("M"), false, -1),
824             createTokenWithCount(Unit.SECOND, 1),
825             new Token(new StringBuilder("."), false, -1),
826             createTokenWithCount(Unit.MILLISECOND, 3),
827             new Token(new StringBuilder("S"), false, -1) }, DurationFormatUtils.lexx(DurationFormatUtils.ISO_EXTENDED_FORMAT_PATTERN));
828         // test failures in equals
829         final DurationFormatUtils.Token token = createTokenWithCount(Unit.YEAR, 4);
830         assertEquals(token, token);
831         assertEquals(token.hashCode(), token.hashCode());
832         assertNotEquals(token, new Object(), "Token equal to non-Token class.");
833         final Token token2 = new Token(new StringBuilder("y"), false, -1);
834         assertNotEquals(token, token2, "Token equal to Token with wrong value class.");
835         assertNotEquals(token, createTokenWithCount(Unit.YEAR, 1), "Token equal to Token with different count.");
836     }
837 
838     @Test
839     void testLiteralPrefixOptionalToken() {
840         assertEquals(DurationFormatUtils.formatDuration(10000L, "s's'"), DurationFormatUtils.formatDuration(10000L, "['['d']']['<'H'>']['{'m'}']s's'"));
841         assertEquals(DurationFormatUtils.formatDuration(10000L, "s's'"), DurationFormatUtils.formatDuration(10000L, "['{'m'}']s's'"));
842     }
843 
844     // Testing the under a day range in DurationFormatUtils.formatPeriod
845     @Test
846     void testLowDurations() {
847         for (int hr = 0; hr < 24; hr++) {
848             for (int min = 0; min < 60; min++) {
849                 for (int sec = 0; sec < 60; sec++) {
850                     assertEqualDuration(hr + ":" + min + ":" + sec, new int[] { 2000, 0, 1, 0, 0, 0, 0 }, new int[] { 2000, 0, 1, hr, min, sec }, "H:m:s");
851                 }
852             }
853         }
854     }
855 
856     @Test
857     void testMultipleOptionalBlocks() {
858         assertEquals(DurationFormatUtils.formatDuration(Duration.ofHours(1).toMillis(), "'[['H']]'"),
859                 DurationFormatUtils.formatDuration(Duration.ofHours(1).toMillis(), "['{'d'}']['[['H']]']"));
860         assertEquals(DurationFormatUtils.formatDuration(Duration.ofDays(1).toMillis(), "['{'d'}']"),
861                 DurationFormatUtils.formatDuration(Duration.ofDays(1).toMillis(), "['{'d'}']['['H']']"));
862     }
863 
864     @Test
865     void testOptionalLiteralSpecialCharacters() {
866       assertEquals(
867           DurationFormatUtils.formatDuration(10000L, "s's'"),
868           DurationFormatUtils.formatDuration(10000L, "['['m']']s's'"));
869     }
870 
871     @Test
872     void testOptionalToken() {
873         // make sure optional formats match corresponding adjusted non-optional formats
874         assertEquals(
875                 DurationFormatUtils.formatDuration(915361000L, "d'd'H'h'm'm's's'"),
876                 DurationFormatUtils.formatDuration(915361000L, "[d'd'H'h'm'm']s's'"));
877         assertEquals(
878                 DurationFormatUtils.formatDuration(9153610L, "H'h'm'm's's'"),
879                 DurationFormatUtils.formatDuration(9153610L, "[d'd'H'h'm'm']s's'"));
880         assertEquals(
881                 DurationFormatUtils.formatDuration(915361L, "m'm's's'"),
882                 DurationFormatUtils.formatDuration(915361L, "[d'd'H'h'm'm']s's'"));
883         assertEquals(
884                 DurationFormatUtils.formatDuration(9153L, "s's'"),
885                 DurationFormatUtils.formatDuration(9153L, "[d'd'H'h'm'm']s's'"));
886         assertEquals(
887                 DurationFormatUtils.formatDuration(9153L, "s's'"),
888                 DurationFormatUtils.formatDuration(9153L, "[d'd'H'h'm'm']s's'"));
889         assertEquals(
890                 DurationFormatUtils.formatPeriod(9153610L, 915361000L, "d'd'H'h'm'm's's'"),
891                 DurationFormatUtils.formatPeriod(9153610L, 915361000L, "[d'd'H'h'm'm']s's'"));
892         assertEquals(
893                 DurationFormatUtils.formatPeriod(915361L, 9153610L, "H'h'm'm's's'"),
894                 DurationFormatUtils.formatPeriod(915361L, 9153610L, "[d'd'H'h'm'm']s's'"));
895         assertEquals(
896                 DurationFormatUtils.formatPeriod(9153L, 915361L, "m'm's's'"),
897                 DurationFormatUtils.formatPeriod(9153L, 915361L, "[d'd'H'h'm'm']s's'"));
898         assertEquals(
899                 DurationFormatUtils.formatPeriod(0L, 9153L, "s's'"),
900                 DurationFormatUtils.formatPeriod(0L, 9153L, "[d'd'H'h'm'm']s's'"));
901         // make sure optional parts are actually omitted when zero
902         assertEquals("2h32m33s610ms", DurationFormatUtils.formatDuration(9153610L, "[d'd'H'h'm'm's's']S'ms'"));
903         assertEquals("15m15s361ms", DurationFormatUtils.formatDuration(915361L, "[d'd'H'h'm'm's's']S'ms'"));
904         assertEquals("9s153ms", DurationFormatUtils.formatDuration(9153L, "[d'd'H'h'm'm's's']S'ms'"));
905         assertEquals("915ms", DurationFormatUtils.formatDuration(915L, "[d'd'H'h'm'm's's']S'ms'"));
906         // make sure we can handle omitting multiple literals after a token
907         assertEquals(
908                 DurationFormatUtils.formatPeriod(915361L, 9153610L, "H'h''h2'm'm's's'"),
909                 DurationFormatUtils.formatPeriod(915361L, 9153610L, "[d'd''d2'H'h''h2'm'm']s's'"));
910     }
911 
912     @Test
913     void testQuotedUnits() {
914         final Token[] literals = DurationFormatUtils.lexx("'yMdHmsS'");
915         assertEquals(1, literals.length);
916         for (final Unit unit : Unit.values()) {
917             assertFalse(Token.containsTokenWithValue(literals, unit));
918             assertTrue(Token.containsTokenWithValue(DurationFormatUtils.lexx(unit.toString()), unit));
919         }
920         assertEquals("yMdHmsS", DurationFormatUtils.formatDuration(1007, "'yMdHmsS'"));
921         assertEquals("y1 M2 d3 H4 m5 s6 S007", DurationFormatUtils.format(
922                 DurationFormatUtils.lexx("'y'y 'M'M 'd'd 'H'H 'm'm 's's 'S'S"), 1, 2, 3, 4, 5, 6, 7, true));
923     }
924 
925     @Test
926     void testRepeatedTokenSeparatedByLiteral() {
927         final long fiveHours = Duration.ofHours(5).toMillis();
928         // the same field letter on either side of a literal are two separate fields, not one padded field
929         assertEquals("5x5", DurationFormatUtils.formatDuration(fiveHours, "HxH", false));
930         assertEquals("5x5", DurationFormatUtils.formatDuration(fiveHours, "H'x'H", false));
931         // each H is a single-width field, so padding does not turn either into "05"
932         assertEquals("5x5", DurationFormatUtils.formatDuration(fiveHours, "HxH", true));
933         // separated by an optional block
934         assertEquals("5x5", DurationFormatUtils.formatDuration(fiveHours, "H[x]H", false));
935         assertEquals("2-2", DurationFormatUtils.formatDuration(Duration.ofDays(2).toMillis(), "d-d", false));
936         // adjacent repeats still collapse into a single padded field
937         assertEquals("05", DurationFormatUtils.formatDuration(fiveHours, "HH", true));
938     }
939 
940     @Test
941     void testTokenEquality() {
942         final Token year = new Token(Unit.YEAR, false, -1);
943         final Token literal = new Token(new StringBuilder("y"), false, -1);
944         final Token equalLiteral = new Token(new StringBuilder("y"), false, -1);
945         assertEquals(year, new Token(Unit.YEAR, false, -1));
946         assertEquals(year.hashCode(), new Token(Unit.YEAR, false, -1).hashCode());
947         assertNotEquals(year, new Token(Unit.MONTH, false, -1));
948         assertNotEquals(year, literal);
949         assertNotEquals(literal, year);
950         assertEquals(literal, equalLiteral);
951         assertEquals(literal.hashCode(), equalLiteral.hashCode());
952         assertNotEquals(literal, new Token(new StringBuilder("M"), false, -1));
953         equalLiteral.increment();
954         assertNotEquals(literal, equalLiteral);
955     }
956 
957     @Test
958     void testTokenToString() {
959         final Token[] tokens = DurationFormatUtils.lexx("yy MM dd HH mm ss SSS 'literal'");
960         final String[] expected = { "yy", " ", "MM", " ", "dd", " ", "HH", " ", "mm", " ", "ss", " ", "SSS", " ", "literal" };
961         assertEquals(expected.length, tokens.length);
962         for (int i = 0; i < expected.length; i++) {
963             assertEquals(expected[i], tokens[i].toString());
964         }
965     }
966 
967     @Test
968     void testUnmatchedOptionalTokens() {
969         assertIllegalArgumentException(() -> DurationFormatUtils.formatDuration(1, "[s"));
970         assertIllegalArgumentException(() -> DurationFormatUtils.formatDuration(1, "[[s"));
971         assertIllegalArgumentException(() -> DurationFormatUtils.formatDuration(1, "[s]]"));
972     }
973 
974 }