Add support for parsing java.time.Duration from a string

Author: nymanjens

CHANGELOG.md

@@ -1,3 +1,11 @@
+## 1.17
+- Added support for parsing `java.time.Duration` from a string. Example:
+
+```
+@Test
+public void myTest(@TestParameter({"1d", "2h20min", "10.5ms"}) Duration duration){...}
+```
+
 ## 1.16
 
 - Deprecated [`TestParameter.TestParameterValuesProvider`](

README.md

@@ -182,6 +182,10 @@ The following examples show most of the supported types. See the `@TestParameter
 
 // Bytes
 @TestParameter({"!!binary 'ZGF0YQ=='", "some_string"}) byte[] bytes;
+
+// Durations (segments of number+unit as shown below)
+@TestParameter({"1d", "2h", "3min", "4s", "5ms", "6us", "7ns"}) java.time.Duration d;
+@TestParameter({"1h30min", "-2h10min20s", "1.5h", ".5s", "0"}) java.time.Duration d;
 ```
 
 For non-primitive types (e.g. String, enums, bytes), `"null"` is always parsed as the `null` reference.

junit4/src/main/java/com/google/testing/junit/testparameterinjector/ParameterValueParsing.java

@@ -14,6 +14,7 @@
 
 package com.google.testing.junit.testparameterinjector;
 
+import static com.google.common.base.MoreObjects.firstNonNull;
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.base.Preconditions.checkState;
@@ -23,6 +24,7 @@
 import com.google.common.base.CharMatcher;
 import com.google.common.base.Function;
 import com.google.common.base.Optional;
+import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Lists;
 import com.google.common.primitives.Primitives;
@@ -34,13 +36,17 @@
 import java.lang.reflect.ParameterizedType;
 import java.math.BigInteger;
 import java.nio.charset.Charset;
+import java.time.Duration;
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
+import java.util.Objects;
 import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 import javax.annotation.Nullable;
 import org.yaml.snakeyaml.LoaderOptions;
 import org.yaml.snakeyaml.Yaml;
@@ -189,6 +195,12 @@ static Object parseYamlObjectToJavaType(Object parsedYaml, TypeToken<?> javaType
           .supportParsedType(byte[].class, ByteStringReflection::copyFrom);
     }
 
+    yamlValueTransformer
+        .ifJavaType(Duration.class)
+        .supportParsedType(String.class, ParameterValueParsing::parseDuration)
+        // Support the special case where the YAML string is "0"
+        .supportParsedType(Integer.class, i -> parseDuration(String.valueOf(i)));
+
     // Added mainly for protocol buffer parsing
     yamlValueTransformer
         .ifJavaType(List.class)
@@ -381,5 +393,68 @@ private static String valueAsString(Object value) {
     }
   }
 
+  // ********** Duration parsing ********** //
+
+  private static final ImmutableMap<String, Duration> ABBREVIATION_TO_DURATION =
+      new ImmutableMap.Builder<String, Duration>()
+          .put("d", Duration.ofDays(1))
+          .put("h", Duration.ofHours(1))
+          .put("m", Duration.ofMinutes(1))
+          .put("min", Duration.ofMinutes(1))
+          .put("s", Duration.ofSeconds(1))
+          .put("ms", Duration.ofMillis(1))
+          .put("us", Duration.ofNanos(1000))
+          .put("ns", Duration.ofNanos(1))
+          .buildOrThrow();
+  private static final Pattern UNIT_PATTERN =
+      Pattern.compile("(?x) ([0-9]+)? (\\.[0-9]*)? (d|h|min|ms?|s|us|ns)");
+  private static final CharMatcher ASCII_DIGIT = CharMatcher.inRange('0', '9');
+
+  private static Duration parseDuration(String value) {
+    checkArgument(value != null, "input value cannot be null");
+    checkArgument(!value.isEmpty(), "input value cannot be empty");
+    checkArgument(!value.equals("-"), "input value cannot be '-'");
+    checkArgument(!value.equals("+"), "input value cannot be '+'");
+
+    value = CharMatcher.whitespace().trimFrom(value);
+
+    if (Objects.equals(value, "0")) {
+      return Duration.ZERO;
+    }
+
+    Duration duration = Duration.ZERO;
+    boolean negative = value.startsWith("-");
+    boolean explicitlyPositive = value.startsWith("+");
+    int index = negative || explicitlyPositive ? 1 : 0;
+    Matcher matcher = UNIT_PATTERN.matcher(value);
+    while (matcher.find(index) && matcher.start() == index) {
+      // Prevent strings like ".s" or "d" by requiring at least one digit.
+      checkArgument(ASCII_DIGIT.matchesAnyOf(matcher.group(0)));
+      try {
+        String unit = matcher.group(3);
+
+        long whole = Long.parseLong(firstNonNull(matcher.group(1), "0"));
+        Duration singleUnit = ABBREVIATION_TO_DURATION.get(unit);
+        checkArgument(singleUnit != null, "invalid unit (%s)", unit);
+        // TODO(b/142748138): Consider using saturated duration math here
+        duration = duration.plus(singleUnit.multipliedBy(whole));
+
+        long nanosPerUnit = singleUnit.toNanos();
+        double frac = Double.parseDouble("0" + firstNonNull(matcher.group(2), ""));
+        duration = duration.plus(Duration.ofNanos((long) (nanosPerUnit * frac)));
+      } catch (ArithmeticException e) {
+        throw new IllegalArgumentException(e);
+      }
+      index = matcher.end();
+    }
+    if (index < value.length()) {
+      throw new IllegalArgumentException("Could not parse entire duration: " + value);
+    }
+    if (negative) {
+      duration = duration.negated();
+    }
+    return duration;
+  }
+
   private ParameterValueParsing() {}
 }

junit4/src/main/java/com/google/testing/junit/testparameterinjector/TestParameterValuesProvider.java

@@ -90,7 +90,7 @@ public static final class Context {
      *
      * @throws NoSuchElementException if this there is no annotation with the given type
      * @throws IllegalArgumentException if there are multiple annotations with the given type
-     * @throws IllegalArgumentException if the argument it TestParameter.class because it is already
+     * @throws IllegalArgumentException if the argument is TestParameter.class because it is already
      *     handled by the TestParameterInjector framework.
      */
     public <A extends Annotation> A getOtherAnnotation(Class<A> annotationType) {
@@ -123,7 +123,7 @@ public <A extends Annotation> A getOtherAnnotation(Class<A> annotationType) {
      *
      * <p>Returns an empty list if this there is no annotation with the given type.
      *
-     * @throws IllegalArgumentException if the argument it TestParameter.class because it is already
+     * @throws IllegalArgumentException if the argument is TestParameter.class because it is already
      *     handled by the TestParameterInjector framework.
      */
     public <A extends Annotation> ImmutableList<A> getOtherAnnotations(Class<A> annotationType) {

junit4/src/test/java/com/google/testing/junit/testparameterinjector/ParameterValueParsingTest.java

@@ -19,9 +19,12 @@
 
 import com.google.common.base.CharMatcher;
 import com.google.common.base.Optional;
+import com.google.common.collect.ImmutableList;
 import com.google.common.primitives.UnsignedLong;
 import com.google.protobuf.ByteString;
+import com.google.testing.junit.testparameterinjector.TestParameters.TestParametersValues;
 import java.math.BigInteger;
+import java.time.Duration;
 import javax.annotation.Nullable;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -183,6 +186,136 @@ public void parseYamlStringToJavaType_success(
     assertThat(result).isEqualTo(parseYamlValueToJavaTypeCases.expectedResult);
   }
 
+  private static final class DurationSuccessTestCasesProvider extends TestParametersValuesProvider {
+    @Override
+    protected ImmutableList<TestParametersValues> provideValues(Context context) {
+      return ImmutableList.of(
+          // Simple
+          testCase("7d", Duration.ofDays(7)),
+          testCase("6h", Duration.ofHours(6)),
+          testCase("5m", Duration.ofMinutes(5)),
+          testCase("5min", Duration.ofMinutes(5)),
+          testCase("4s", Duration.ofSeconds(4)),
+          testCase("3.2s", Duration.ofMillis(3200)),
+          testCase("0.2s", Duration.ofMillis(200)),
+          testCase(".15s", Duration.ofMillis(150)),
+          testCase("5.0s", Duration.ofSeconds(5)),
+          testCase("1.0s", Duration.ofSeconds(1)),
+          testCase("1.00s", Duration.ofSeconds(1)),
+          testCase("1.004s", Duration.ofSeconds(1).plusMillis(4)),
+          testCase("1.0040s", Duration.ofSeconds(1).plusMillis(4)),
+          testCase("100.00100s", Duration.ofSeconds(100).plusMillis(1)),
+          testCase("0.3333333333333333333h", Duration.ofMinutes(20)),
+          testCase("1s3ms", Duration.ofSeconds(1).plusMillis(3)),
+          testCase("1s34ms", Duration.ofSeconds(1).plusMillis(34)),
+          testCase("1s345ms", Duration.ofSeconds(1).plusMillis(345)),
+          testCase("345ms", Duration.ofMillis(345)),
+          testCase(".9ms", Duration.ofNanos(900000)),
+          testCase("5.s", Duration.ofSeconds(5)),
+          testCase("+24h", Duration.ofHours(24)),
+          testCase("0d", Duration.ZERO),
+          testCase("-0d", Duration.ZERO),
+          testCase("-1d", Duration.ofDays(-1)),
+          testCase("1d", Duration.ofDays(1)),
+
+          // Zero
+          testCase("0", Duration.ZERO),
+          testCase("-0", Duration.ZERO),
+          testCase("+0", Duration.ZERO),
+
+          // Multiple fields
+          testCase("1h30m", Duration.ofMinutes(90)),
+          testCase("1h30min", Duration.ofMinutes(90)),
+          testCase("1d7m", Duration.ofDays(1).plusMinutes(7)),
+          testCase("1m3.5s", Duration.ofMinutes(1).plusMillis(3500)),
+          testCase("1m3s500ms", Duration.ofMinutes(1).plusMillis(3500)),
+          testCase("5d4h3m2.1s", Duration.ofDays(5).plusHours(4).plusMinutes(3).plusMillis(2100)),
+          testCase("3.5s250ms", Duration.ofMillis(3500 + 250)),
+          testCase("1m2m3m", Duration.ofMinutes(6)),
+          testCase("1m2h", Duration.ofHours(2).plusMinutes(1)),
+
+          // Negative duration
+          testCase("-.5h", Duration.ofMinutes(-30)),
+
+          // Overflow
+          testCase("106751d23h47m16s854ms775us807ns", Duration.ofNanos(Long.MAX_VALUE)),
+          testCase("106751991167d7h12m55s807ms", Duration.ofMillis(Long.MAX_VALUE)),
+          testCase("106751991167300d15h30m7s", Duration.ofSeconds(Long.MAX_VALUE)),
+          testCase("106945d", Duration.ofDays(293 * 365)),
+
+          // Underflow
+          testCase("-106751d23h47m16s854ms775us808ns", Duration.ofNanos(Long.MIN_VALUE)),
+          testCase("-106751991167d7h12m55s808ms", Duration.ofMillis(Long.MIN_VALUE)),
+          testCase("-106751991167300d15h30m7s", Duration.ofSeconds(Long.MIN_VALUE + 1)),
+          testCase("-106945d", Duration.ofDays(-293 * 365)),
+
+          // Very large values
+          testCase("9223372036854775807ns", Duration.ofNanos(Long.MAX_VALUE)),
+          testCase("9223372036854775806ns", Duration.ofNanos(Long.MAX_VALUE - 1)),
+          testCase("106751991167d7h12m55s807ms", Duration.ofMillis(Long.MAX_VALUE)),
+          testCase("900000000000d", Duration.ofDays(900000000000L)),
+          testCase("100000000000d100000000000d", Duration.ofDays(200000000000L)));
+    }
+
+    private static TestParametersValues testCase(String yamlString, Duration expectedResult) {
+      return TestParametersValues.builder()
+          .name(yamlString)
+          .addParameter("yamlString", yamlString)
+          .addParameter("expectedResult", expectedResult)
+          .build();
+    }
+  }
+
+  @Test
+  @TestParameters(valuesProvider = DurationSuccessTestCasesProvider.class)
+  public void parseYamlStringToJavaType_duration_success(String yamlString, Duration expectedResult)
+      throws Exception {
+    Object result = ParameterValueParsing.parseYamlStringToJavaType(yamlString, Duration.class);
+
+    assertThat(result).isEqualTo(expectedResult);
+  }
+
+  @Test
+  public void parseYamlStringToJavaType_duration_fails(
+      @TestParameter({
+            // Wrong format
+            "1m 3s", // spaces not allowed
+            "0x123abc",
+            "123x456",
+            ".s",
+            "d",
+            "5dh",
+            "1s500",
+            "unparseable",
+            "-",
+            "+",
+            "2",
+            "-2",
+            "+2",
+
+            // Uppercase
+            "1D",
+            "1H",
+            "1M",
+            "1S",
+            "1MS",
+            "1Ms",
+            "1mS",
+            "1NS",
+            "1Ns",
+            "1nS",
+
+            // Very large values
+            Long.MAX_VALUE + "d",
+            "10000000000000000000000000d"
+          })
+          String yamlString)
+      throws Exception {
+    assertThrows(
+        IllegalArgumentException.class,
+        () -> ParameterValueParsing.parseYamlStringToJavaType(yamlString, Duration.class));
+  }
+
   @Test
   public void parseYamlStringToJavaType_booleanToEnum_ambiguousValues_fails(
       @TestParameter({"OFF", "YES", "false", "True"}) String yamlString) throws Exception {

junit4/src/test/java/com/google/testing/junit/testparameterinjector/TestParametersMethodProcessorTest.java

@@ -31,6 +31,7 @@
 import java.lang.annotation.Annotation;
 import java.lang.annotation.Repeatable;
 import java.lang.annotation.Retention;
+import java.time.Duration;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
@@ -120,6 +121,14 @@ public void test4_withCustomName(TestEnum testEnum) {
       storeTestParametersForThisTest(testEnum);
     }
 
+    @Test
+    @TestParameters("{testDuration: 0}")
+    @TestParameters("{testDuration: 1d}")
+    @TestParameters("{testDuration: -2h}")
+    public void test5_withDuration(Duration testDuration) {
+      storeTestParametersForThisTest(testDuration);
+    }
+
     @Override
     ImmutableMap<String, String> expectedTestNameToStringifiedParameters() {
       return ImmutableMap.<String, String>builder()
@@ -167,6 +176,9 @@ ImmutableMap<String, String> expectedTestNameToStringifiedParameters() {
           .put("test4_withCustomName[custom1]", "ONE")
           .put("test4_withCustomName[{testEnum: TWO}]", "TWO")
           .put("test4_withCustomName[custom3]", "THREE")
+          .put("test5_withDuration[{testDuration: 0}]", "PT0S")
+          .put("test5_withDuration[{testDuration: 1d}]", "PT24H")
+          .put("test5_withDuration[{testDuration: -2h}]", "PT-2H")
           .build();
     }
   }