1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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
46
47
48
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
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
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
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190 @Test
191 @DefaultTimeZone(TimeZones.GMT_ID)
192 void testEdgeDurations() {
193
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
211 assertEqualDuration("136", new int[] { 2005, 9, 16, 0, 0, 0 }, new int[] { 2006, 2, 1, 0, 0, 0 }, "dd");
212
213 assertEqualDuration("136", new int[] { 2004, 9, 16, 0, 0, 0 }, new int[] { 2005, 2, 1, 0, 0, 0 }, "dd");
214
215 assertEqualDuration("137", new int[] { 2003, 9, 16, 0, 0, 0 }, new int[] { 2004, 2, 1, 0, 0, 0 }, "dd");
216
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
229
230 assertEqualDuration("11", new int[] { 1996, 1, 29, 0, 0, 0 }, new int[] { 1997, 1, 28, 0, 0, 0 }, "M");
231
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();
273
274
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
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
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
530 text = DateFormatUtils.format(cal, DateFormatUtils.ISO_DATETIME_TIME_ZONE_FORMAT.getPattern(), timeZone);
531 assertEquals("2002-02-23T09:11:12-03:00", text);
532
533 text = DurationFormatUtils.formatPeriod(base.getTime().getTime(), cal.getTime().getTime(),
534 DurationFormatUtils.ISO_EXTENDED_FORMAT_PATTERN, false, timeZone);
535 assertEquals("P32Y1M22DT9H11M12.001S", text);
536
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
543
544 }
545
546 @Test
547 void testFormatPeriodISOAcrossMonths() {
548 final TimeZone tz = TimeZones.getTimeZone("GMT-3");
549
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
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
592
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
597 assertEquals(DurationFormatUtils.formatDuration(endMillis, "s"),
598 DurationFormatUtils.formatPeriod(0, endMillis, "s", true, gmt));
599 }
600
601
602
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
657
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
665
666
667 @Test
668 void testFormatPeriodMaximumSpanCompletesQuickly() {
669 final TimeZone gmt = TimeZones.getTimeZone("GMT");
670
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
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
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
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
707 start.set(2020, Calendar.FEBRUARY, 29);
708 final Calendar end = Calendar.getInstance(timeZone);
709 end.clear();
710
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
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
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() {
766 assertIllegalArgumentException(() -> DurationFormatUtils.lexx("'yMdHms''S"));
767 }
768
769 @Test
770 void testLANG982() {
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() {
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
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
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
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
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
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
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
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
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
929 assertEquals("5x5", DurationFormatUtils.formatDuration(fiveHours, "HxH", false));
930 assertEquals("5x5", DurationFormatUtils.formatDuration(fiveHours, "H'x'H", false));
931
932 assertEquals("5x5", DurationFormatUtils.formatDuration(fiveHours, "HxH", true));
933
934 assertEquals("5x5", DurationFormatUtils.formatDuration(fiveHours, "H[x]H", false));
935 assertEquals("2-2", DurationFormatUtils.formatDuration(Duration.ofDays(2).toMillis(), "d-d", false));
936
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 }