DurationFormatUtilsTest.java
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.lang3.time;
import static org.apache.commons.lang3.LangAssertions.assertIllegalArgumentException;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;
import java.time.Duration;
import java.util.Calendar;
import java.util.TimeZone;
import org.apache.commons.lang3.AbstractLangTest;
import org.apache.commons.lang3.time.DurationFormatUtils.Token;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import org.junitpioneer.jupiter.DefaultTimeZone;
/**
* Tests {@link DurationFormatUtils}.
* <p>
* NOT THREAD-SAFE.
* </p>
*/
class DurationFormatUtilsTest extends AbstractLangTest {
private static final int FOUR_YEARS = 365 * 3 + 366;
private static Arguments[] testLANG1827() {
final long twoHours = Duration.ofHours(2).toMillis();
final long twoHoursThirtyMin = Duration.ofHours(2).plusMinutes(30).toMillis();
final long oneDayTwoHours = Duration.ofDays(1).plusHours(2).toMillis();
return new Arguments[] {
Arguments.of("escaped quote inside literal", "2 o'clock", twoHours, "H' o''clock'"),
Arguments.of("escaped quote at start of literal", "it's 2 hours", twoHours, "'it''s 'H' hours'"),
Arguments.of("escaped quote outside literal", "2'30", twoHoursThirtyMin, "H''m"),
Arguments.of("multiple escaped quotes", "it's been 1 day's and 2 hour's", oneDayTwoHours,
"'it''s been 'd' day''s and 'H' hour''s'"),
Arguments.of("standalone escaped quote", "2h'30m", twoHoursThirtyMin, "H'h'''m'm'"),
Arguments.of("escaped quote inside optional block", "2 hour's", twoHours, "[d' day''s ']H' hour''s'"),
Arguments.of("existing literal behavior", "2 hours 30 minutes", twoHoursThirtyMin, "H' hours 'm' minutes'")
};
}
private void assertEqualDuration(final String expected, final int[] start, final int[] end, final String format) {
assertEqualDuration(null, expected, start, end, format);
}
private void assertEqualDuration(final String message, final String expected, final int[] start, final int[] end, final String format) {
final Calendar cal1 = Calendar.getInstance();
cal1.set(start[0], start[1], start[2], start[3], start[4], start[5]);
cal1.set(Calendar.MILLISECOND, 0);
final Calendar cal2 = Calendar.getInstance();
cal2.set(end[0], end[1], end[2], end[3], end[4], end[5]);
cal2.set(Calendar.MILLISECOND, 0);
final long milli1 = cal1.getTime().getTime();
final long milli2 = cal2.getTime().getTime();
final String result = DurationFormatUtils.formatPeriod(milli1, milli2, format);
if (message == null) {
assertEquals(expected, result);
} else {
assertEquals(expected, result, message);
}
}
private void assertFormatPeriodOneMilli(final long startMillis, final long endMillis) {
final TimeZone gmt = TimeZones.getTimeZone("GMT");
assertEquals("1", DurationFormatUtils.formatPeriod(startMillis, endMillis, "S", true, gmt));
assertEquals("0/0/0/0/0/0.001",
DurationFormatUtils.formatPeriod(startMillis, endMillis, "y/M/d/H/m/s.S", true, gmt));
// formatPeriod must agree with formatDuration over the full range, not just spans near the epoch.
assertEquals(DurationFormatUtils.formatDuration(endMillis - startMillis, "S"),
DurationFormatUtils.formatPeriod(startMillis, endMillis, "S", true, gmt));
}
private void bruteForce(final int year, final int month, final int day, final String format, final int calendarType) {
final String msg = year + "-" + month + "-" + day + " to ";
final Calendar c = Calendar.getInstance();
c.set(year, month, day, 0, 0, 0);
final int[] array1 = { year, month, day, 0, 0, 0 };
final int[] array2 = { year, month, day, 0, 0, 0 };
for (int i = 0; i < FOUR_YEARS; i++) {
array2[0] = c.get(Calendar.YEAR);
array2[1] = c.get(Calendar.MONTH);
array2[2] = c.get(Calendar.DAY_OF_MONTH);
final String tmpMsg = msg + array2[0] + "-" + array2[1] + "-" + array2[2] + " at ";
assertEqualDuration(tmpMsg + i, Integer.toString(i), array1, array2, format);
c.add(calendarType, 1);
}
}
private DurationFormatUtils.Token createTokenWithCount(final CharSequence value, final int count) {
final DurationFormatUtils.Token token = new DurationFormatUtils.Token(value, false, -1);
// To help debugging, toString() on a Token should never blow up.
assertNotNull(token.toString());
for (int i = 1; i < count; i++) {
token.increment();
assertNotNull(token.toString());
}
return token;
}
@Test
void testAlternatingLiteralOptionals() {
final String format = "['d'dH'h'][m'm']['s's]['ms'S]";
assertEquals("d1", DurationFormatUtils.formatDuration(Duration.ofDays(1).toMillis(), format));
assertEquals("1h", DurationFormatUtils.formatDuration(Duration.ofHours(1).toMillis(), format));
assertEquals("1m", DurationFormatUtils.formatDuration(Duration.ofMinutes(1).toMillis(), format));
assertEquals("s1", DurationFormatUtils.formatDuration(Duration.ofSeconds(1).toMillis(), format));
assertEquals("ms001", DurationFormatUtils.formatDuration(Duration.ofMillis(1).toMillis(), format));
assertEquals("d1s1", DurationFormatUtils.formatDuration(Duration.ofDays(1).plusSeconds(1).toMillis(), format));
assertEquals("d11h", DurationFormatUtils.formatDuration(Duration.ofDays(1).plusHours(1).toMillis(), format));
assertEquals("d11h1m", DurationFormatUtils.formatDuration(Duration.ofDays(1).plusHours(1).plusMinutes(1).toMillis(), format));
assertEquals("d11h1ms1", DurationFormatUtils.formatDuration(Duration.ofDays(1).plusHours(1).plusMinutes(1).plusSeconds(1).toMillis(), format));
assertEquals("d11h1ms1ms001",
DurationFormatUtils.formatDuration(Duration.ofDays(1).plusHours(1).plusMinutes(1).plusSeconds(1).plusMillis(1).toMillis(), format));
}
/** See https://issues.apache.org/bugzilla/show_bug.cgi?id=38401 */
@Test
void testBugzilla38401() {
assertEqualDuration("0000/00/30 16:00:00 000", new int[] { 2006, 0, 26, 18, 47, 34 },
new int[] { 2006, 1, 26, 10, 47, 34 }, "yyyy/MM/dd HH:mm:ss SSS");
}
@SuppressWarnings("deprecation")
@Test
void testConstructor() {
assertNotNull(new DurationFormatUtils());
final Constructor<?>[] cons = DurationFormatUtils.class.getDeclaredConstructors();
assertEquals(1, cons.length);
assertTrue(Modifier.isPublic(cons[0].getModifiers()));
assertTrue(Modifier.isPublic(DurationFormatUtils.class.getModifiers()));
assertFalse(Modifier.isFinal(DurationFormatUtils.class.getModifiers()));
}
@Test
void testDurationsByBruteForce() {
bruteForce(2006, 0, 1, "d", Calendar.DAY_OF_MONTH);
bruteForce(2006, 0, 2, "d", Calendar.DAY_OF_MONTH);
bruteForce(2007, 1, 2, "d", Calendar.DAY_OF_MONTH);
bruteForce(2004, 1, 29, "d", Calendar.DAY_OF_MONTH);
bruteForce(1996, 1, 29, "d", Calendar.DAY_OF_MONTH);
bruteForce(1969, 1, 28, "M", Calendar.MONTH); // tests for 48 years
//bruteForce(1996, 1, 29, "M", Calendar.MONTH); // this will fail
}
/** Attempting to test edge cases in DurationFormatUtils.formatPeriod. */
@Test
@DefaultTimeZone(TimeZones.GMT_ID)
void testEdgeDurations() {
// This test case must use a time zone without DST
TimeZone.setDefault(FastTimeZone.getGmtTimeZone());
assertEqualDuration("01", new int[] { 2006, 0, 15, 0, 0, 0 }, new int[] { 2006, 2, 10, 0, 0, 0 }, "MM");
assertEqualDuration("12", new int[] { 2005, 0, 15, 0, 0, 0 }, new int[] { 2006, 0, 15, 0, 0, 0 }, "MM");
assertEqualDuration("12", new int[] { 2005, 0, 15, 0, 0, 0 }, new int[] { 2006, 0, 16, 0, 0, 0 }, "MM");
assertEqualDuration("11", new int[] { 2005, 0, 15, 0, 0, 0 }, new int[] { 2006, 0, 14, 0, 0, 0 }, "MM");
assertEqualDuration("01 26", new int[] { 2006, 0, 15, 0, 0, 0 }, new int[] { 2006, 2, 10, 0, 0, 0 }, "MM dd");
assertEqualDuration("54", new int[] { 2006, 0, 15, 0, 0, 0 }, new int[] { 2006, 2, 10, 0, 0, 0 }, "dd");
assertEqualDuration("09 12", new int[] { 2006, 1, 20, 0, 0, 0 }, new int[] { 2006, 11, 4, 0, 0, 0 }, "MM dd");
assertEqualDuration("287", new int[] { 2006, 1, 20, 0, 0, 0 }, new int[] { 2006, 11, 4, 0, 0, 0 }, "dd");
assertEqualDuration("11 30", new int[] { 2006, 0, 2, 0, 0, 0 }, new int[] { 2007, 0, 1, 0, 0, 0 }, "MM dd");
assertEqualDuration("364", new int[] { 2006, 0, 2, 0, 0, 0 }, new int[] { 2007, 0, 1, 0, 0, 0 }, "dd");
assertEqualDuration("12 00", new int[] { 2006, 0, 1, 0, 0, 0 }, new int[] { 2007, 0, 1, 0, 0, 0 }, "MM dd");
assertEqualDuration("365", new int[] { 2006, 0, 1, 0, 0, 0 }, new int[] { 2007, 0, 1, 0, 0, 0 }, "dd");
assertEqualDuration("31", new int[] { 2006, 0, 1, 0, 0, 0 }, new int[] { 2006, 1, 1, 0, 0, 0 }, "dd");
assertEqualDuration("92", new int[] { 2005, 9, 1, 0, 0, 0 }, new int[] { 2006, 0, 1, 0, 0, 0 }, "dd");
assertEqualDuration("77", new int[] { 2005, 9, 16, 0, 0, 0 }, new int[] { 2006, 0, 1, 0, 0, 0 }, "dd");
// test month larger in start than end
assertEqualDuration("136", new int[] { 2005, 9, 16, 0, 0, 0 }, new int[] { 2006, 2, 1, 0, 0, 0 }, "dd");
// test when start in leap year
assertEqualDuration("136", new int[] { 2004, 9, 16, 0, 0, 0 }, new int[] { 2005, 2, 1, 0, 0, 0 }, "dd");
// test when end in leap year
assertEqualDuration("137", new int[] { 2003, 9, 16, 0, 0, 0 }, new int[] { 2004, 2, 1, 0, 0, 0 }, "dd");
// test when end in leap year but less than end of feb
assertEqualDuration("135", new int[] { 2003, 9, 16, 0, 0, 0 }, new int[] { 2004, 1, 28, 0, 0, 0 }, "dd");
assertEqualDuration("364", new int[] { 2007, 0, 2, 0, 0, 0 }, new int[] { 2008, 0, 1, 0, 0, 0 }, "dd");
assertEqualDuration("729", new int[] { 2006, 0, 2, 0, 0, 0 }, new int[] { 2008, 0, 1, 0, 0, 0 }, "dd");
assertEqualDuration("365", new int[] { 2007, 2, 2, 0, 0, 0 }, new int[] { 2008, 2, 1, 0, 0, 0 }, "dd");
assertEqualDuration("333", new int[] { 2007, 1, 2, 0, 0, 0 }, new int[] { 2008, 0, 1, 0, 0, 0 }, "dd");
assertEqualDuration("28", new int[] { 2008, 1, 2, 0, 0, 0 }, new int[] { 2008, 2, 1, 0, 0, 0 }, "dd");
assertEqualDuration("393", new int[] { 2007, 1, 2, 0, 0, 0 }, new int[] { 2008, 2, 1, 0, 0, 0 }, "dd");
assertEqualDuration("369", new int[] { 2004, 0, 29, 0, 0, 0 }, new int[] { 2005, 1, 1, 0, 0, 0 }, "dd");
assertEqualDuration("338", new int[] { 2004, 1, 29, 0, 0, 0 }, new int[] { 2005, 1, 1, 0, 0, 0 }, "dd");
assertEqualDuration("28", new int[] { 2004, 2, 8, 0, 0, 0 }, new int[] { 2004, 3, 5, 0, 0, 0 }, "dd");
assertEqualDuration("48", new int[] { 1992, 1, 29, 0, 0, 0 }, new int[] { 1996, 1, 29, 0, 0, 0 }, "M");
// this seems odd - and will fail if I throw it in as a brute force
// below as it expects the answer to be 12. It's a tricky edge case
assertEqualDuration("11", new int[] { 1996, 1, 29, 0, 0, 0 }, new int[] { 1997, 1, 28, 0, 0, 0 }, "M");
// again - this seems odd
assertEqualDuration("11 28", new int[] { 1996, 1, 29, 0, 0, 0 }, new int[] { 1997, 1, 28, 0, 0, 0 }, "M d");
}
@Test
void testEmptyOptionals() {
assertEquals("", DurationFormatUtils.formatDuration(0L, "[d'd'][H'h'][m'm'][s's']"));
assertEquals("", DurationFormatUtils.formatDuration(0L, "['d''h''m''s's]"));
}
@Test
void testFormatDuration() {
long duration = 0;
assertEquals("0", DurationFormatUtils.formatDuration(duration, "y"));
assertEquals("0", DurationFormatUtils.formatDuration(duration, "M"));
assertEquals("0", DurationFormatUtils.formatDuration(duration, "d"));
assertEquals("0", DurationFormatUtils.formatDuration(duration, "H"));
assertEquals("0", DurationFormatUtils.formatDuration(duration, "m"));
assertEquals("0", DurationFormatUtils.formatDuration(duration, "s"));
assertEquals("0", DurationFormatUtils.formatDuration(duration, "S"));
assertEquals("0000", DurationFormatUtils.formatDuration(duration, "SSSS"));
assertEquals("0000", DurationFormatUtils.formatDuration(duration, "yyyy"));
assertEquals("0000", DurationFormatUtils.formatDuration(duration, "yyMM"));
duration = 60 * 1000;
assertEquals("0", DurationFormatUtils.formatDuration(duration, "y"));
assertEquals("0", DurationFormatUtils.formatDuration(duration, "M"));
assertEquals("0", DurationFormatUtils.formatDuration(duration, "d"));
assertEquals("0", DurationFormatUtils.formatDuration(duration, "H"));
assertEquals("1", DurationFormatUtils.formatDuration(duration, "m"));
assertEquals("60", DurationFormatUtils.formatDuration(duration, "s"));
assertEquals("60000", DurationFormatUtils.formatDuration(duration, "S"));
assertEquals("01:00", DurationFormatUtils.formatDuration(duration, "mm:ss"));
final Calendar base = Calendar.getInstance();
base.set(2000, Calendar.JANUARY, 1, 0, 0, 0);
base.set(Calendar.MILLISECOND, 0);
final Calendar cal = Calendar.getInstance();
cal.set(2003, Calendar.FEBRUARY, 1, 0, 0, 0);
cal.set(Calendar.MILLISECOND, 0);
duration = cal.getTime().getTime() - base.getTime().getTime(); // duration from 2000-01-01 to cal
// don't use 1970 in test as time zones were less reliable in 1970 than now
// remember that duration formatting ignores time zones, working on strict hour lengths
final int days = 366 + 365 + 365 + 31;
assertEquals("0 0 " + days, DurationFormatUtils.formatDuration(duration, "y M d"));
}
@Test
void testFormatDurationHMS() {
long time = 0;
assertEquals("00:00:00.000", DurationFormatUtils.formatDurationHMS(time));
time = 1;
assertEquals("00:00:00.001", DurationFormatUtils.formatDurationHMS(time));
time = 15;
assertEquals("00:00:00.015", DurationFormatUtils.formatDurationHMS(time));
time = 165;
assertEquals("00:00:00.165", DurationFormatUtils.formatDurationHMS(time));
time = 1675;
assertEquals("00:00:01.675", DurationFormatUtils.formatDurationHMS(time));
time = 13465;
assertEquals("00:00:13.465", DurationFormatUtils.formatDurationHMS(time));
time = 72789;
assertEquals("00:01:12.789", DurationFormatUtils.formatDurationHMS(time));
time = 12789 + 32 * 60000;
assertEquals("00:32:12.789", DurationFormatUtils.formatDurationHMS(time));
time = 12789 + 62 * 60000;
assertEquals("01:02:12.789", DurationFormatUtils.formatDurationHMS(time));
}
@Test
void testFormatDurationISO() {
assertEquals("P0Y0M0DT0H0M0.000S", DurationFormatUtils.formatDurationISO(0L));
assertEquals("P0Y0M0DT0H0M0.001S", DurationFormatUtils.formatDurationISO(1L));
assertEquals("P0Y0M0DT0H0M0.010S", DurationFormatUtils.formatDurationISO(10L));
assertEquals("P0Y0M0DT0H0M0.100S", DurationFormatUtils.formatDurationISO(100L));
assertEquals("P0Y0M0DT0H1M15.321S", DurationFormatUtils.formatDurationISO(75321L));
}
/**
* Tests that "1 <unit>s" gets converted to "1 <unit>" but that "11 <unit>s" is left alone.
*/
@Test
void testFormatDurationPluralWords() {
final long oneSecond = 1000;
final long oneMinute = oneSecond * 60;
final long oneHour = oneMinute * 60;
final long oneDay = oneHour * 24;
String text;
text = DurationFormatUtils.formatDurationWords(oneSecond, false, false);
assertEquals("0 days 0 hours 0 minutes 1 second", text);
text = DurationFormatUtils.formatDurationWords(oneSecond * 2, false, false);
assertEquals("0 days 0 hours 0 minutes 2 seconds", text);
text = DurationFormatUtils.formatDurationWords(oneSecond * 11, false, false);
assertEquals("0 days 0 hours 0 minutes 11 seconds", text);
text = DurationFormatUtils.formatDurationWords(oneMinute, false, false);
assertEquals("0 days 0 hours 1 minute 0 seconds", text);
text = DurationFormatUtils.formatDurationWords(oneMinute * 2, false, false);
assertEquals("0 days 0 hours 2 minutes 0 seconds", text);
text = DurationFormatUtils.formatDurationWords(oneMinute * 11, false, false);
assertEquals("0 days 0 hours 11 minutes 0 seconds", text);
text = DurationFormatUtils.formatDurationWords(oneMinute + oneSecond, false, false);
assertEquals("0 days 0 hours 1 minute 1 second", text);
text = DurationFormatUtils.formatDurationWords(oneHour, false, false);
assertEquals("0 days 1 hour 0 minutes 0 seconds", text);
text = DurationFormatUtils.formatDurationWords(oneHour * 2, false, false);
assertEquals("0 days 2 hours 0 minutes 0 seconds", text);
text = DurationFormatUtils.formatDurationWords(oneHour * 11, false, false);
assertEquals("0 days 11 hours 0 minutes 0 seconds", text);
text = DurationFormatUtils.formatDurationWords(oneHour + oneMinute + oneSecond, false, false);
assertEquals("0 days 1 hour 1 minute 1 second", text);
text = DurationFormatUtils.formatDurationWords(oneDay, false, false);
assertEquals("1 day 0 hours 0 minutes 0 seconds", text);
text = DurationFormatUtils.formatDurationWords(oneDay * 2, false, false);
assertEquals("2 days 0 hours 0 minutes 0 seconds", text);
text = DurationFormatUtils.formatDurationWords(oneDay * 11, false, false);
assertEquals("11 days 0 hours 0 minutes 0 seconds", text);
text = DurationFormatUtils.formatDurationWords(oneDay + oneHour + oneMinute + oneSecond, false, false);
assertEquals("1 day 1 hour 1 minute 1 second", text);
}
@Test
void testFormatDurationWords() {
String text;
text = DurationFormatUtils.formatDurationWords(50 * 1000, true, false);
assertEquals("50 seconds", text);
text = DurationFormatUtils.formatDurationWords(65 * 1000, true, false);
assertEquals("1 minute 5 seconds", text);
text = DurationFormatUtils.formatDurationWords(120 * 1000, true, false);
assertEquals("2 minutes 0 seconds", text);
text = DurationFormatUtils.formatDurationWords(121 * 1000, true, false);
assertEquals("2 minutes 1 second", text);
text = DurationFormatUtils.formatDurationWords(72 * 60 * 1000, true, false);
assertEquals("1 hour 12 minutes 0 seconds", text);
text = DurationFormatUtils.formatDurationWords(24 * 60 * 60 * 1000, true, false);
assertEquals("1 day 0 hours 0 minutes 0 seconds", text);
text = DurationFormatUtils.formatDurationWords(50 * 1000, true, true);
assertEquals("50 seconds", text);
text = DurationFormatUtils.formatDurationWords(65 * 1000, true, true);
assertEquals("1 minute 5 seconds", text);
text = DurationFormatUtils.formatDurationWords(120 * 1000, true, true);
assertEquals("2 minutes", text);
text = DurationFormatUtils.formatDurationWords(121 * 1000, true, true);
assertEquals("2 minutes 1 second", text);
text = DurationFormatUtils.formatDurationWords(72 * 60 * 1000, true, true);
assertEquals("1 hour 12 minutes", text);
text = DurationFormatUtils.formatDurationWords(24 * 60 * 60 * 1000, true, true);
assertEquals("1 day", text);
text = DurationFormatUtils.formatDurationWords(50 * 1000, false, true);
assertEquals("0 days 0 hours 0 minutes 50 seconds", text);
text = DurationFormatUtils.formatDurationWords(65 * 1000, false, true);
assertEquals("0 days 0 hours 1 minute 5 seconds", text);
text = DurationFormatUtils.formatDurationWords(120 * 1000, false, true);
assertEquals("0 days 0 hours 2 minutes", text);
text = DurationFormatUtils.formatDurationWords(121 * 1000, false, true);
assertEquals("0 days 0 hours 2 minutes 1 second", text);
text = DurationFormatUtils.formatDurationWords(72 * 60 * 1000, false, true);
assertEquals("0 days 1 hour 12 minutes", text);
text = DurationFormatUtils.formatDurationWords(24 * 60 * 60 * 1000, false, true);
assertEquals("1 day", text);
text = DurationFormatUtils.formatDurationWords(50 * 1000, false, false);
assertEquals("0 days 0 hours 0 minutes 50 seconds", text);
text = DurationFormatUtils.formatDurationWords(65 * 1000, false, false);
assertEquals("0 days 0 hours 1 minute 5 seconds", text);
text = DurationFormatUtils.formatDurationWords(120 * 1000, false, false);
assertEquals("0 days 0 hours 2 minutes 0 seconds", text);
text = DurationFormatUtils.formatDurationWords(121 * 1000, false, false);
assertEquals("0 days 0 hours 2 minutes 1 second", text);
text = DurationFormatUtils.formatDurationWords(72 * 60 * 1000, false, false);
assertEquals("0 days 1 hour 12 minutes 0 seconds", text);
text = DurationFormatUtils.formatDurationWords(24 * 60 * 60 * 1000 + 72 * 60 * 1000, false, false);
assertEquals("1 day 1 hour 12 minutes 0 seconds", text);
text = DurationFormatUtils.formatDurationWords(2 * 24 * 60 * 60 * 1000 + 72 * 60 * 1000, false, false);
assertEquals("2 days 1 hour 12 minutes 0 seconds", text);
for (int i = 2; i < 31; i++) {
text = DurationFormatUtils.formatDurationWords(i * 24 * 60 * 60 * 1000L, false, false);
assertEquals(i + " days 0 hours 0 minutes 0 seconds", text);
}
}
@Test
void testFormatNegativeDuration() {
assertIllegalArgumentException(() -> DurationFormatUtils.formatDuration(-5000, "S", true));
}
@Test
void testFormatNegativeDurationHMS() {
assertIllegalArgumentException(() -> DurationFormatUtils.formatDurationHMS(-5000));
}
@Test
void testFormatNegativeDurationISO() {
assertIllegalArgumentException(() -> DurationFormatUtils.formatDurationISO(-5000));
}
@Test
void testFormatNegativeDurationWords() {
assertIllegalArgumentException(() -> DurationFormatUtils.formatDurationWords(-5000, true, true));
}
@Test
void testFormatPeriod() {
final Calendar cal1970 = Calendar.getInstance();
cal1970.set(1970, Calendar.JANUARY, 1, 0, 0, 0);
cal1970.set(Calendar.MILLISECOND, 0);
final long time1970 = cal1970.getTime().getTime();
assertEquals("0", DurationFormatUtils.formatPeriod(time1970, time1970, "y"));
assertEquals("0", DurationFormatUtils.formatPeriod(time1970, time1970, "M"));
assertEquals("0", DurationFormatUtils.formatPeriod(time1970, time1970, "d"));
assertEquals("0", DurationFormatUtils.formatPeriod(time1970, time1970, "H"));
assertEquals("0", DurationFormatUtils.formatPeriod(time1970, time1970, "m"));
assertEquals("0", DurationFormatUtils.formatPeriod(time1970, time1970, "s"));
assertEquals("0", DurationFormatUtils.formatPeriod(time1970, time1970, "S"));
assertEquals("0000", DurationFormatUtils.formatPeriod(time1970, time1970, "SSSS"));
assertEquals("0000", DurationFormatUtils.formatPeriod(time1970, time1970, "yyyy"));
assertEquals("0000", DurationFormatUtils.formatPeriod(time1970, time1970, "yyMM"));
long time = time1970 + 60 * 1000;
assertEquals("0", DurationFormatUtils.formatPeriod(time1970, time, "y"));
assertEquals("0", DurationFormatUtils.formatPeriod(time1970, time, "M"));
assertEquals("0", DurationFormatUtils.formatPeriod(time1970, time, "d"));
assertEquals("0", DurationFormatUtils.formatPeriod(time1970, time, "H"));
assertEquals("1", DurationFormatUtils.formatPeriod(time1970, time, "m"));
assertEquals("60", DurationFormatUtils.formatPeriod(time1970, time, "s"));
assertEquals("60000", DurationFormatUtils.formatPeriod(time1970, time, "S"));
assertEquals("01:00", DurationFormatUtils.formatPeriod(time1970, time, "mm:ss"));
final Calendar cal = Calendar.getInstance();
cal.set(1973, Calendar.JULY, 1, 0, 0, 0);
cal.set(Calendar.MILLISECOND, 0);
time = cal.getTime().getTime();
assertEquals("36", DurationFormatUtils.formatPeriod(time1970, time, "yM"));
assertEquals("3 years 6 months", DurationFormatUtils.formatPeriod(time1970, time, "y' years 'M' months'"));
assertEquals("03/06", DurationFormatUtils.formatPeriod(time1970, time, "yy/MM"));
cal.set(1973, Calendar.NOVEMBER, 1, 0, 0, 0);
cal.set(Calendar.MILLISECOND, 0);
time = cal.getTime().getTime();
assertEquals("310", DurationFormatUtils.formatPeriod(time1970, time, "yM"));
assertEquals("3 years 10 months", DurationFormatUtils.formatPeriod(time1970, time, "y' years 'M' months'"));
assertEquals("03/10", DurationFormatUtils.formatPeriod(time1970, time, "yy/MM"));
cal.set(1974, Calendar.JANUARY, 1, 0, 0, 0);
cal.set(Calendar.MILLISECOND, 0);
time = cal.getTime().getTime();
assertEquals("40", DurationFormatUtils.formatPeriod(time1970, time, "yM"));
assertEquals("4 'years 0 months", DurationFormatUtils.formatPeriod(time1970, time, "y' ''years' M 'months'"));
assertEquals("4 years 0 months", DurationFormatUtils.formatPeriod(time1970, time, "y' years 'M' months'"));
assertEquals("4years 0months", DurationFormatUtils.formatPeriod(time1970, time, "y'years 'M'months'"));
assertEquals("04/00", DurationFormatUtils.formatPeriod(time1970, time, "yy/MM"));
assertEquals("48", DurationFormatUtils.formatPeriod(time1970, time, "M"));
assertEquals("48", DurationFormatUtils.formatPeriod(time1970, time, "MM"));
assertEquals("048", DurationFormatUtils.formatPeriod(time1970, time, "MMM"));
// no date in result
assertEquals("hello", DurationFormatUtils.formatPeriod(time1970, time, "'hello'"));
assertEquals("hello'world", DurationFormatUtils.formatPeriod(time1970, time, "'hello''world'"));
}
@Test
void testFormatPeriodeStartGreaterEnd() {
assertIllegalArgumentException(() -> DurationFormatUtils.formatPeriod(5000, 2500, "yy/MM"));
}
@SuppressWarnings("deprecation")
@Test
void testFormatPeriodISO() {
final TimeZone timeZone = TimeZones.getTimeZone("GMT-3");
final Calendar base = Calendar.getInstance(timeZone);
base.set(1970, Calendar.JANUARY, 1, 0, 0, 0);
base.set(Calendar.MILLISECOND, 0);
final Calendar cal = Calendar.getInstance(timeZone);
cal.set(2002, Calendar.FEBRUARY, 23, 9, 11, 12);
cal.set(Calendar.MILLISECOND, 1);
String text;
// repeat a test from testDateTimeISO to compare extended and not extended.
text = DateFormatUtils.format(cal, DateFormatUtils.ISO_DATETIME_TIME_ZONE_FORMAT.getPattern(), timeZone);
assertEquals("2002-02-23T09:11:12-03:00", text);
// test fixture is the same as above, but now with extended format.
text = DurationFormatUtils.formatPeriod(base.getTime().getTime(), cal.getTime().getTime(),
DurationFormatUtils.ISO_EXTENDED_FORMAT_PATTERN, false, timeZone);
assertEquals("P32Y1M22DT9H11M12.001S", text);
// test fixture from example in https://www.w3.org/TR/xmlschema-2/#duration
cal.set(1971, Calendar.FEBRUARY, 3, 10, 30, 0);
cal.set(Calendar.MILLISECOND, 0);
text = DurationFormatUtils.formatPeriod(base.getTime().getTime(), cal.getTime().getTime(),
DurationFormatUtils.ISO_EXTENDED_FORMAT_PATTERN, false, timeZone);
assertEquals("P1Y1M2DT10H30M0.000S", text);
// want a way to say 'don't print the seconds in format()' or other fields for that matter:
// assertEquals("P1Y2M3DT10H30M", text);
}
@Test
void testFormatPeriodISOAcrossMonths() {
final TimeZone tz = TimeZones.getTimeZone("GMT-3");
// Verifies period formatting across a month boundary (Jan 31 to Feb 1)
final Calendar start = Calendar.getInstance(tz);
start.clear();
start.set(2020, Calendar.JANUARY, 31);
final Calendar end = Calendar.getInstance(tz);
end.clear();
end.set(2020, Calendar.FEBRUARY, 1);
final String result = DurationFormatUtils.formatPeriod(start.getTimeInMillis(), end.getTimeInMillis(), DurationFormatUtils.ISO_EXTENDED_FORMAT_PATTERN,
false, tz);
assertEquals("P0Y0M1DT0H0M0.000S", result);
}
@Test
void testFormatPeriodISOLeapYearBoundary() {
final TimeZone tz = TimeZones.getTimeZone("GMT-3");
// Verifies period formatting across a leap-year boundary (Feb 29 to Mar 1)
final Calendar start = Calendar.getInstance(tz);
start.clear();
start.set(2020, Calendar.FEBRUARY, 29);
final Calendar end = Calendar.getInstance(tz);
end.clear();
end.set(2020, Calendar.MARCH, 1);
final String result = DurationFormatUtils.formatPeriod(start.getTimeInMillis(), end.getTimeInMillis(), DurationFormatUtils.ISO_EXTENDED_FORMAT_PATTERN,
false, tz);
assertEquals("P0Y0M1DT0H0M0.000S", result);
}
@Test
void testFormatPeriodISOMethod() {
assertEquals("P0Y0M0DT0H0M0.000S", DurationFormatUtils.formatPeriodISO(0L, 0L));
assertEquals("P0Y0M0DT0H0M1.000S", DurationFormatUtils.formatPeriodISO(0L, 1000L));
assertEquals("P0Y0M0DT0H1M1.000S", DurationFormatUtils.formatPeriodISO(0L, 61000L));
}
@Test
void testFormatPeriodISOStartGreaterEnd() {
assertIllegalArgumentException(() -> DurationFormatUtils.formatPeriodISO(5000, 2000));
}
@Test
void testFormatPeriodLargeFunnelledValue() {
final TimeZone gmt = TimeZones.getTimeZone("GMT");
// ~69 years, chosen so the seconds count exceeds Integer.MAX_VALUE once days/hours/minutes are
// funnelled into the single requested field.
final long endMillis = 2_175_984_000_000L;
assertEquals("2175984000", DurationFormatUtils.formatPeriod(0, endMillis, "s", true, gmt));
assertEquals("2175984000000", DurationFormatUtils.formatPeriod(0, endMillis, "S", true, gmt));
// formatPeriod must agree with formatDuration, which reduces the same span in long arithmetic.
assertEquals(DurationFormatUtils.formatDuration(endMillis, "s"),
DurationFormatUtils.formatPeriod(0, endMillis, "s", true, gmt));
}
@Test
void testFormatPeriodLongRangeBounds() {
// A one-millisecond span sitting at the extremes of the long input range must still reduce
// correctly, confirming formatPeriod handles the whole range of millisecond inputs.
assertFormatPeriodOneMilli(Long.MAX_VALUE - 1, Long.MAX_VALUE);
assertFormatPeriodOneMilli(Long.MIN_VALUE, Long.MIN_VALUE + 1);
assertFormatPeriodOneMilli((long) Integer.MIN_VALUE - 1, Integer.MIN_VALUE);
}
/**
* Takes 8 seconds to run.
*/
@Test
void testFourYears() {
final Calendar c = Calendar.getInstance();
c.set(2004, 0, 1, 0, 0, 0);
for (int i = 0; i < FOUR_YEARS; i++) {
bruteForce(c.get(Calendar.YEAR), c.get(Calendar.MONTH), c.get(Calendar.DAY_OF_MONTH), "d", Calendar.DAY_OF_MONTH);
c.add(Calendar.DAY_OF_MONTH, 1);
}
}
// https://issues.apache.org/jira/browse/LANG-281
@Test
void testJiraLang281() {
assertEqualDuration("09", new int[] { 2005, 11, 31, 0, 0, 0 }, new int[] { 2006, 9, 6, 0, 0, 0 }, "MM");
}
@ParameterizedTest
@MethodSource
void testLANG1827(final String label, final String expected, final long durationMillis, final String format) {
assertEquals(expected, DurationFormatUtils.formatDuration(durationMillis, format), label);
}
@Test
void testLANG1827UnmatchedQuote() {
assertIllegalArgumentException(() -> DurationFormatUtils.lexx("'unmatched"));
}
@Test
void testLANG815() {
final Calendar calendar = Calendar.getInstance();
calendar.set(2012, Calendar.JULY, 30, 0, 0, 0);
final long startMillis = calendar.getTimeInMillis();
calendar.set(2012, Calendar.SEPTEMBER, 8);
final long endMillis = calendar.getTimeInMillis();
assertEquals("1 9", DurationFormatUtils.formatPeriod(startMillis, endMillis, "M d"));
}
@Test
void testLANG981() { // unmatched quote char in lexx
assertIllegalArgumentException(() -> DurationFormatUtils.lexx("'yMdHms''S"));
}
@Test
void testLANG982() { // More than 3 millisecond digits following a second
assertEquals("61.999", DurationFormatUtils.formatDuration(61999, "s.S"));
assertEquals("1 1999", DurationFormatUtils.formatDuration(61999, "m S"));
assertEquals("61.999", DurationFormatUtils.formatDuration(61999, "s.SSS"));
assertEquals("1 1999", DurationFormatUtils.formatDuration(61999, "m SSS"));
assertEquals("61.0999", DurationFormatUtils.formatDuration(61999, "s.SSSS"));
assertEquals("1 1999", DurationFormatUtils.formatDuration(61999, "m SSSS"));
assertEquals("61.00999", DurationFormatUtils.formatDuration(61999, "s.SSSSS"));
assertEquals("1 01999", DurationFormatUtils.formatDuration(61999, "m SSSSS"));
}
@Test
void testLANG984() { // Long durations
assertEquals("0", DurationFormatUtils.formatDuration(0, "S"));
assertEquals(Integer.toString(Integer.MAX_VALUE), DurationFormatUtils.formatDuration(Integer.MAX_VALUE, "S"));
long maxIntPlus = Integer.MAX_VALUE;
maxIntPlus++;
assertEquals(Long.toString(maxIntPlus), DurationFormatUtils.formatDuration(maxIntPlus, "S"));
assertEquals(Long.toString(Long.MAX_VALUE), DurationFormatUtils.formatDuration(Long.MAX_VALUE, "S"));
}
@Test
void testLexx() {
// tests each constant
assertArrayEquals(new DurationFormatUtils.Token[] {
createTokenWithCount(DurationFormatUtils.y, 1),
createTokenWithCount(DurationFormatUtils.M, 1),
createTokenWithCount(DurationFormatUtils.d, 1),
createTokenWithCount(DurationFormatUtils.H, 1),
createTokenWithCount(DurationFormatUtils.m, 1),
createTokenWithCount(DurationFormatUtils.s, 1),
createTokenWithCount(DurationFormatUtils.S, 1) }, DurationFormatUtils.lexx("yMdHmsS"));
// tests the ISO 8601-like
assertArrayEquals(new DurationFormatUtils.Token[] {
createTokenWithCount(DurationFormatUtils.H, 2),
createTokenWithCount(new StringBuilder(":"), 1),
createTokenWithCount(DurationFormatUtils.m, 2),
createTokenWithCount(new StringBuilder(":"), 1),
createTokenWithCount(DurationFormatUtils.s, 2),
createTokenWithCount(new StringBuilder("."), 1),
createTokenWithCount(DurationFormatUtils.S, 3) }, DurationFormatUtils.lexx("HH:mm:ss.SSS"));
// test the iso extended format
assertArrayEquals(new DurationFormatUtils.Token[] {
createTokenWithCount(new StringBuilder("P"), 1),
createTokenWithCount(DurationFormatUtils.y, 4),
createTokenWithCount(new StringBuilder("Y"), 1),
createTokenWithCount(DurationFormatUtils.M, 1),
createTokenWithCount(new StringBuilder("M"), 1),
createTokenWithCount(DurationFormatUtils.d, 1),
createTokenWithCount(new StringBuilder("DT"), 1),
createTokenWithCount(DurationFormatUtils.H, 1),
createTokenWithCount(new StringBuilder("H"), 1),
createTokenWithCount(DurationFormatUtils.m, 1),
createTokenWithCount(new StringBuilder("M"), 1),
createTokenWithCount(DurationFormatUtils.s, 1),
createTokenWithCount(new StringBuilder("."), 1),
createTokenWithCount(DurationFormatUtils.S, 3),
createTokenWithCount(new StringBuilder("S"), 1) }, DurationFormatUtils.lexx(DurationFormatUtils.ISO_EXTENDED_FORMAT_PATTERN));
// test failures in equals
final DurationFormatUtils.Token token = createTokenWithCount(DurationFormatUtils.y, 4);
assertEquals(token, token);
assertEquals(token.hashCode(), token.hashCode());
assertNotEquals(token, new Object(), "Token equal to non-Token class.");
final Token token2 = createTokenWithCount("", 1);
assertNotEquals(token, token2, "Token equal to Token with wrong value class.");
assertNotEquals(token.hashCode(), token2.hashCode());
assertNotEquals(token, createTokenWithCount(DurationFormatUtils.y, 1), "Token equal to Token with different count.");
final DurationFormatUtils.Token numToken = createTokenWithCount("1", 4);
assertEquals(numToken, numToken, "Token with Number value not equal to itself.");
}
@Test
void testLiteralPrefixOptionalToken() {
assertEquals(DurationFormatUtils.formatDuration(10000L, "s's'"), DurationFormatUtils.formatDuration(10000L, "['['d']']['<'H'>']['{'m'}']s's'"));
assertEquals(DurationFormatUtils.formatDuration(10000L, "s's'"), DurationFormatUtils.formatDuration(10000L, "['{'m'}']s's'"));
}
// Testing the under a day range in DurationFormatUtils.formatPeriod
@Test
void testLowDurations() {
for (int hr = 0; hr < 24; hr++) {
for (int min = 0; min < 60; min++) {
for (int sec = 0; sec < 60; sec++) {
assertEqualDuration(hr + ":" + min + ":" + sec, new int[] { 2000, 0, 1, 0, 0, 0, 0 }, new int[] { 2000, 0, 1, hr, min, sec }, "H:m:s");
}
}
}
}
@Test
void testMultipleOptionalBlocks() {
assertEquals(DurationFormatUtils.formatDuration(Duration.ofHours(1).toMillis(), "'[['H']]'"),
DurationFormatUtils.formatDuration(Duration.ofHours(1).toMillis(), "['{'d'}']['[['H']]']"));
assertEquals(DurationFormatUtils.formatDuration(Duration.ofDays(1).toMillis(), "['{'d'}']"),
DurationFormatUtils.formatDuration(Duration.ofDays(1).toMillis(), "['{'d'}']['['H']']"));
}
@Test
void testOptionalLiteralSpecialCharacters() {
assertEquals(
DurationFormatUtils.formatDuration(10000L, "s's'"),
DurationFormatUtils.formatDuration(10000L, "['['m']']s's'"));
}
@Test
void testOptionalToken() {
// make sure optional formats match corresponding adjusted non-optional formats
assertEquals(
DurationFormatUtils.formatDuration(915361000L, "d'd'H'h'm'm's's'"),
DurationFormatUtils.formatDuration(915361000L, "[d'd'H'h'm'm']s's'"));
assertEquals(
DurationFormatUtils.formatDuration(9153610L, "H'h'm'm's's'"),
DurationFormatUtils.formatDuration(9153610L, "[d'd'H'h'm'm']s's'"));
assertEquals(
DurationFormatUtils.formatDuration(915361L, "m'm's's'"),
DurationFormatUtils.formatDuration(915361L, "[d'd'H'h'm'm']s's'"));
assertEquals(
DurationFormatUtils.formatDuration(9153L, "s's'"),
DurationFormatUtils.formatDuration(9153L, "[d'd'H'h'm'm']s's'"));
assertEquals(
DurationFormatUtils.formatDuration(9153L, "s's'"),
DurationFormatUtils.formatDuration(9153L, "[d'd'H'h'm'm']s's'"));
assertEquals(
DurationFormatUtils.formatPeriod(9153610L, 915361000L, "d'd'H'h'm'm's's'"),
DurationFormatUtils.formatPeriod(9153610L, 915361000L, "[d'd'H'h'm'm']s's'"));
assertEquals(
DurationFormatUtils.formatPeriod(915361L, 9153610L, "H'h'm'm's's'"),
DurationFormatUtils.formatPeriod(915361L, 9153610L, "[d'd'H'h'm'm']s's'"));
assertEquals(
DurationFormatUtils.formatPeriod(9153L, 915361L, "m'm's's'"),
DurationFormatUtils.formatPeriod(9153L, 915361L, "[d'd'H'h'm'm']s's'"));
assertEquals(
DurationFormatUtils.formatPeriod(0L, 9153L, "s's'"),
DurationFormatUtils.formatPeriod(0L, 9153L, "[d'd'H'h'm'm']s's'"));
// make sure optional parts are actually omitted when zero
assertEquals("2h32m33s610ms", DurationFormatUtils.formatDuration(9153610L, "[d'd'H'h'm'm's's']S'ms'"));
assertEquals("15m15s361ms", DurationFormatUtils.formatDuration(915361L, "[d'd'H'h'm'm's's']S'ms'"));
assertEquals("9s153ms", DurationFormatUtils.formatDuration(9153L, "[d'd'H'h'm'm's's']S'ms'"));
assertEquals("915ms", DurationFormatUtils.formatDuration(915L, "[d'd'H'h'm'm's's']S'ms'"));
// make sure we can handle omitting multiple literals after a token
assertEquals(
DurationFormatUtils.formatPeriod(915361L, 9153610L, "H'h''h2'm'm's's'"),
DurationFormatUtils.formatPeriod(915361L, 9153610L, "[d'd''d2'H'h''h2'm'm']s's'"));
}
@Test
void testRepeatedTokenSeparatedByLiteral() {
final long fiveHours = Duration.ofHours(5).toMillis();
// the same field letter on either side of a literal are two separate fields, not one padded field
assertEquals("5x5", DurationFormatUtils.formatDuration(fiveHours, "HxH", false));
assertEquals("5x5", DurationFormatUtils.formatDuration(fiveHours, "H'x'H", false));
// each H is a single-width field, so padding does not turn either into "05"
assertEquals("5x5", DurationFormatUtils.formatDuration(fiveHours, "HxH", true));
// separated by an optional block
assertEquals("5x5", DurationFormatUtils.formatDuration(fiveHours, "H[x]H", false));
assertEquals("2-2", DurationFormatUtils.formatDuration(Duration.ofDays(2).toMillis(), "d-d", false));
// adjacent repeats still collapse into a single padded field
assertEquals("05", DurationFormatUtils.formatDuration(fiveHours, "HH", true));
}
@Test
void testUnmatchedOptionalTokens() {
assertIllegalArgumentException(() -> DurationFormatUtils.formatDuration(1, "[s"));
assertIllegalArgumentException(() -> DurationFormatUtils.formatDuration(1, "[[s"));
assertIllegalArgumentException(() -> DurationFormatUtils.formatDuration(1, "[s]]"));
}
}