NIFI-5854 Added skeleton logic to convert decimal time units.
authorAndy LoPresto <alopresto@apache.org>
Fri, 30 Nov 2018 04:17:58 +0000 (20:17 -0800)
committerMatthew Burgess <mattyb149@apache.org>
Mon, 7 Jan 2019 14:55:06 +0000 (09:55 -0500)
Added helper methods.
Added unit tests.

NIFI-5854 [WIP] Cleaned up logic.
Resolved failing unit tests due to error message change.

NIFI-5854 [WIP] All helper method unit tests pass.

NIFI-5854 [WIP] FormatUtils#getPreciseTimeDuration() now handles all tested inputs correctly.
Added unit tests.

NIFI-5854 [WIP] FormatUtils#getTimeDuration() still using long.
Added unit tests.
Renamed existing unit tests to reflect method under test.

NIFI-5854 FormatUtils#getTimeDuration() returns long but now accepts decimal inputs.
Added @Deprecation warnings (will update callers where possible).
All unit tests pass.

NIFI-5854 Fixed unit tests (ran in IDE but not Maven) due to int overflows.
Fixed checkstyle issues.

NIFI-5854 Fixed typo in Javadoc.

NIFI-5854 Fixed typo in Javadoc.

Signed-off-by: Matthew Burgess <mattyb149@apache.org>
This closes #3193

nifi-commons/nifi-utils/src/main/java/org/apache/nifi/util/FormatUtils.java
nifi-commons/nifi-utils/src/test/groovy/org/apache/nifi/processor/TestFormatUtilsGroovy.groovy [deleted file]
nifi-commons/nifi-utils/src/test/groovy/org/apache/nifi/util/TestFormatUtilsGroovy.groovy [new file with mode: 0644]

index 1c9140b..7d2992f 100644 (file)
 package org.apache.nifi.util;
 
 import java.text.NumberFormat;
+import java.util.Arrays;
+import java.util.List;
 import java.util.concurrent.TimeUnit;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 public class FormatUtils {
-
     private static final String UNION = "|";
 
     // for Data Sizes
@@ -41,8 +42,9 @@ public class FormatUtils {
     private static final String WEEKS = join(UNION, "w", "wk", "wks", "week", "weeks");
 
     private static final String VALID_TIME_UNITS = join(UNION, NANOS, MILLIS, SECS, MINS, HOURS, DAYS, WEEKS);
-    public static final String TIME_DURATION_REGEX = "(\\d+)\\s*(" + VALID_TIME_UNITS + ")";
+    public static final String TIME_DURATION_REGEX = "([\\d.]+)\\s*(" + VALID_TIME_UNITS + ")";
     public static final Pattern TIME_DURATION_PATTERN = Pattern.compile(TIME_DURATION_REGEX);
+    private static final List<Long> TIME_UNIT_MULTIPLIERS = Arrays.asList(1000L, 1000L, 1000L, 60L, 60L, 24L);
 
     /**
      * Formats the specified count by adding commas.
@@ -58,7 +60,7 @@ public class FormatUtils {
      * Formats the specified duration in 'mm:ss.SSS' format.
      *
      * @param sourceDuration the duration to format
-     * @param sourceUnit the unit to interpret the duration
+     * @param sourceUnit     the unit to interpret the duration
      * @return representation of the given time data in minutes/seconds
      */
     public static String formatMinutesSeconds(final long sourceDuration, final TimeUnit sourceUnit) {
@@ -79,7 +81,7 @@ public class FormatUtils {
      * Formats the specified duration in 'HH:mm:ss.SSS' format.
      *
      * @param sourceDuration the duration to format
-     * @param sourceUnit the unit to interpret the duration
+     * @param sourceUnit     the unit to interpret the duration
      * @return representation of the given time data in hours/minutes/seconds
      */
     public static String formatHoursMinutesSeconds(final long sourceDuration, final TimeUnit sourceUnit) {
@@ -139,65 +141,230 @@ public class FormatUtils {
         return format.format(dataSize) + " bytes";
     }
 
+    /**
+     * Returns a time duration in the requested {@link TimeUnit} after parsing the {@code String}
+     * input. If the resulting value is a decimal (i.e.
+     * {@code 25 hours -> TimeUnit.DAYS = 1.04}), the value is rounded.
+     *
+     * @param value the raw String input (i.e. "28 minutes")
+     * @param desiredUnit the requested output {@link TimeUnit}
+     * @return the whole number value of this duration in the requested units
+     * @deprecated As of Apache NiFi 1.9.0, because this method only returns whole numbers, use {@link #getPreciseTimeDuration(String, TimeUnit)} when possible.
+     */
+    @Deprecated
     public static long getTimeDuration(final String value, final TimeUnit desiredUnit) {
+        return Math.round(getPreciseTimeDuration(value, desiredUnit));
+    }
+
+    /**
+     * Returns the parsed and converted input in the requested units.
+     * <p>
+     * If the value is {@code 0 <= x < 1} in the provided units, the units will first be converted to a smaller unit to get a value >= 1 (i.e. 0.5 seconds -> 500 milliseconds).
+     * This is because the underlying unit conversion cannot handle decimal values.
+     * <p>
+     * If the value is {@code x >= 1} but x is not a whole number, the units will first be converted to a smaller unit to attempt to get a whole number value (i.e. 1.5 seconds -> 1500 milliseconds).
+     * <p>
+     * If the value is {@code x < 1000} and the units are {@code TimeUnit.NANOSECONDS}, the result will be a whole number of nanoseconds, rounded (i.e. 123.4 ns -> 123 ns).
+     * <p>
+     * This method handles decimal values over {@code 1 ns}, but {@code < 1 ns} will return {@code 0} in any other unit.
+     * <p>
+     * Examples:
+     * <p>
+     * "10 seconds", {@code TimeUnit.MILLISECONDS} -> 10_000.0
+     * "0.010 s", {@code TimeUnit.MILLISECONDS} -> 10.0
+     * "0.010 s", {@code TimeUnit.SECONDS} -> 0.010
+     * "0.010 ns", {@code TimeUnit.NANOSECONDS} -> 1
+     * "0.010 ns", {@code TimeUnit.MICROSECONDS} -> 0
+     *
+     * @param value       the {@code String} input
+     * @param desiredUnit the desired output {@link TimeUnit}
+     * @return the parsed and converted amount (without a unit)
+     */
+    public static double getPreciseTimeDuration(final String value, final TimeUnit desiredUnit) {
         final Matcher matcher = TIME_DURATION_PATTERN.matcher(value.toLowerCase());
         if (!matcher.matches()) {
-            throw new IllegalArgumentException("Value '" + value + "' is not a valid Time Duration");
+            throw new IllegalArgumentException("Value '" + value + "' is not a valid time duration");
         }
 
         final String duration = matcher.group(1);
         final String units = matcher.group(2);
-        TimeUnit specifiedTimeUnit = null;
-        switch (units.toLowerCase()) {
+
+        double durationVal = Double.parseDouble(duration);
+        TimeUnit specifiedTimeUnit;
+
+        // The TimeUnit enum doesn't have a value for WEEKS, so handle this case independently
+        if (isWeek(units)) {
+            specifiedTimeUnit = TimeUnit.DAYS;
+            durationVal *= 7;
+        } else {
+            specifiedTimeUnit = determineTimeUnit(units);
+        }
+
+        // The units are now guaranteed to be in DAYS or smaller
+        long durationLong;
+        if (durationVal == Math.rint(durationVal)) {
+            durationLong = Math.round(durationVal);
+        } else {
+            // Try reducing the size of the units to make the input a long
+            List wholeResults = makeWholeNumberTime(durationVal, specifiedTimeUnit);
+            durationLong = (long) wholeResults.get(0);
+            specifiedTimeUnit = (TimeUnit) wholeResults.get(1);
+        }
+
+        return desiredUnit.convert(durationLong, specifiedTimeUnit);
+    }
+
+    /**
+     * Converts the provided time duration value to one that can be represented as a whole number.
+     * Returns a {@code List} containing the new value as a {@code long} at index 0 and the
+     * {@link TimeUnit} at index 1. If the incoming value is already whole, it is returned as is.
+     * If the incoming value cannot be made whole, a whole approximation is returned. For values
+     * {@code >= 1 TimeUnit.NANOSECONDS}, the value is rounded (i.e. 123.4 ns -> 123 ns).
+     * For values {@code < 1 TimeUnit.NANOSECONDS}, the constant [1L, {@code TimeUnit.NANOSECONDS}] is returned as the smallest measurable unit of time.
+     * <p>
+     * Examples:
+     * <p>
+     * 1, {@code TimeUnit.SECONDS} -> [1, {@code TimeUnit.SECONDS}]
+     * 1.1, {@code TimeUnit.SECONDS} -> [1100, {@code TimeUnit.MILLISECONDS}]
+     * 0.1, {@code TimeUnit.SECONDS} -> [100, {@code TimeUnit.MILLISECONDS}]
+     * 0.1, {@code TimeUnit.NANOSECONDS} -> [1, {@code TimeUnit.NANOSECONDS}]
+     *
+     * @param decimal  the time duration as a decimal
+     * @param timeUnit the current time unit
+     * @return the time duration as a whole number ({@code long}) and the smaller time unit used
+     */
+    protected static List<Object> makeWholeNumberTime(double decimal, TimeUnit timeUnit) {
+        // If the value is already a whole number, return it and the current time unit
+        if (decimal == Math.rint(decimal)) {
+            return Arrays.asList(new Object[]{(long) decimal, timeUnit});
+        } else if (TimeUnit.NANOSECONDS == timeUnit) {
+            // The time unit is as small as possible
+            if (decimal < 1.0) {
+                decimal = 1;
+            } else {
+                decimal = Math.rint(decimal);
+            }
+            return Arrays.asList(new Object[]{(long) decimal, timeUnit});
+        } else {
+            // Determine the next time unit and the respective multiplier
+            TimeUnit smallerTimeUnit = getSmallerTimeUnit(timeUnit);
+            long multiplier = calculateMultiplier(timeUnit, smallerTimeUnit);
+
+            // Recurse with the original number converted to the smaller unit
+            return makeWholeNumberTime(decimal * multiplier, smallerTimeUnit);
+        }
+    }
+
+    /**
+     * Returns the numerical multiplier to convert a value from {@code originalTimeUnit} to
+     * {@code newTimeUnit} (i.e. for {@code TimeUnit.DAYS -> TimeUnit.MINUTES} would return
+     * 24 * 60 = 1440). If the original and new units are the same, returns 1. If the new unit
+     * is larger than the original (i.e. the result would be less than 1), throws an
+     * {@link IllegalArgumentException}.
+     *
+     * @param originalTimeUnit the source time unit
+     * @param newTimeUnit      the destination time unit
+     * @return the numerical multiplier between the units
+     */
+    protected static long calculateMultiplier(TimeUnit originalTimeUnit, TimeUnit newTimeUnit) {
+        if (originalTimeUnit == newTimeUnit) {
+            return 1;
+        } else if (originalTimeUnit.ordinal() < newTimeUnit.ordinal()) {
+            throw new IllegalArgumentException("The original time unit '" + originalTimeUnit + "' must be larger than the new time unit '" + newTimeUnit + "'");
+        } else {
+            int originalOrd = originalTimeUnit.ordinal();
+            int newOrd = newTimeUnit.ordinal();
+
+            List<Long> unitMultipliers = TIME_UNIT_MULTIPLIERS.subList(newOrd, originalOrd);
+            return unitMultipliers.stream().reduce(1L, (a, b) -> (long) a * b);
+        }
+    }
+
+    /**
+     * Returns the next smallest {@link TimeUnit} (i.e. {@code TimeUnit.DAYS -> TimeUnit.HOURS}).
+     * If the parameter is {@code null} or {@code TimeUnit.NANOSECONDS}, an
+     * {@link IllegalArgumentException} is thrown because there is no valid smaller TimeUnit.
+     *
+     * @param originalUnit the TimeUnit
+     * @return the next smaller TimeUnit
+     */
+    protected static TimeUnit getSmallerTimeUnit(TimeUnit originalUnit) {
+        if (originalUnit == null || TimeUnit.NANOSECONDS == originalUnit) {
+            throw new IllegalArgumentException("Cannot determine a smaller time unit than '" + originalUnit + "'");
+        } else {
+            return TimeUnit.values()[originalUnit.ordinal() - 1];
+        }
+    }
+
+    /**
+     * Returns {@code true} if this raw unit {@code String} is parsed as representing "weeks", which does not have a value in the {@link TimeUnit} enum.
+     *
+     * @param rawUnit the String containing the desired unit
+     * @return true if the unit is "weeks"; false otherwise
+     */
+    protected static boolean isWeek(final String rawUnit) {
+        switch (rawUnit) {
+            case "w":
+            case "wk":
+            case "wks":
+            case "week":
+            case "weeks":
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    /**
+     * Returns the {@link TimeUnit} enum that maps to the provided raw {@code String} input. The
+     * highest time unit is {@code TimeUnit.DAYS}. Any input that cannot be parsed will result in
+     * an {@link IllegalArgumentException}.
+     *
+     * @param rawUnit the String to parse
+     * @return the TimeUnit
+     */
+    protected static TimeUnit determineTimeUnit(String rawUnit) {
+        switch (rawUnit.toLowerCase()) {
             case "ns":
             case "nano":
             case "nanos":
             case "nanoseconds":
-                specifiedTimeUnit = TimeUnit.NANOSECONDS;
-                break;
+                return TimeUnit.NANOSECONDS;
+            case "┬Ás":
+            case "micro":
+            case "micros":
+            case "microseconds":
+                return TimeUnit.MICROSECONDS;
             case "ms":
             case "milli":
             case "millis":
             case "milliseconds":
-                specifiedTimeUnit = TimeUnit.MILLISECONDS;
-                break;
+                return TimeUnit.MILLISECONDS;
             case "s":
             case "sec":
             case "secs":
             case "second":
             case "seconds":
-                specifiedTimeUnit = TimeUnit.SECONDS;
-                break;
+                return TimeUnit.SECONDS;
             case "m":
             case "min":
             case "mins":
             case "minute":
             case "minutes":
-                specifiedTimeUnit = TimeUnit.MINUTES;
-                break;
+                return TimeUnit.MINUTES;
             case "h":
             case "hr":
             case "hrs":
             case "hour":
             case "hours":
-                specifiedTimeUnit = TimeUnit.HOURS;
-                break;
+                return TimeUnit.HOURS;
             case "d":
             case "day":
             case "days":
-                specifiedTimeUnit = TimeUnit.DAYS;
-                break;
-            case "w":
-            case "wk":
-            case "wks":
-            case "week":
-            case "weeks":
-                final long durationVal = Long.parseLong(duration);
-                return desiredUnit.convert(durationVal, TimeUnit.DAYS)*7;
+                return TimeUnit.DAYS;
+            default:
+                throw new IllegalArgumentException("Could not parse '" + rawUnit + "' to TimeUnit");
         }
-
-        final long durationVal = Long.parseLong(duration);
-        return desiredUnit.convert(durationVal, specifiedTimeUnit);
     }
 
     public static String formatUtilization(final double utilization) {
@@ -225,7 +392,7 @@ public class FormatUtils {
      * 3 seconds, 8 millis, 3 nanos - if includeTotalNanos = false,
      * 3 seconds, 8 millis, 3 nanos (3008000003 nanos) - if includeTotalNanos = true
      *
-     * @param nanos the number of nanoseconds to format
+     * @param nanos             the number of nanoseconds to format
      * @param includeTotalNanos whether or not to include the total number of nanoseconds in parentheses in the returned value
      * @return a human-readable String that is a formatted representation of the given number of nanoseconds.
      */
diff --git a/nifi-commons/nifi-utils/src/test/groovy/org/apache/nifi/processor/TestFormatUtilsGroovy.groovy b/nifi-commons/nifi-utils/src/test/groovy/org/apache/nifi/processor/TestFormatUtilsGroovy.groovy
deleted file mode 100644 (file)
index f3e4f46..0000000
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
- * 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
- *
- *     http://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.nifi.processor
-
-import org.apache.nifi.util.FormatUtils
-import org.junit.After
-import org.junit.Before
-import org.junit.BeforeClass
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.junit.runners.JUnit4
-import org.slf4j.Logger
-import org.slf4j.LoggerFactory
-
-import java.util.concurrent.TimeUnit
-
-@RunWith(JUnit4.class)
-class TestFormatUtilsGroovy extends GroovyTestCase {
-    private static final Logger logger = LoggerFactory.getLogger(TestFormatUtilsGroovy.class)
-
-    @BeforeClass
-    public static void setUpOnce() throws Exception {
-        logger.metaClass.methodMissing = { String name, args ->
-            logger.info("[${name?.toUpperCase()}] ${(args as List).join(" ")}")
-        }
-    }
-
-    @Before
-    public void setUp() throws Exception {
-
-    }
-
-    @After
-    public void tearDown() throws Exception {
-
-    }
-
-    /**
-     * New feature test
-     */
-    @Test
-    void testShouldConvertWeeks() {
-        // Arrange
-        final List WEEKS = ["1 week", "1 wk", "1 w", "1 wks", "1 weeks"]
-        final long EXPECTED_DAYS = 7L
-
-        // Act
-        List days = WEEKS.collect { String week ->
-            FormatUtils.getTimeDuration(week, TimeUnit.DAYS)
-        }
-        logger.converted(days)
-
-        // Assert
-        assert days.every { it == EXPECTED_DAYS }
-    }
-
-
-
-    @Test
-    void testShouldHandleNegativeWeeks() {
-        // Arrange
-        final List WEEKS = ["-1 week", "-1 wk", "-1 w", "-1 weeks", "- 1 week"]
-
-        // Act
-        List msgs = WEEKS.collect { String week ->
-            shouldFail(IllegalArgumentException) {
-                FormatUtils.getTimeDuration(week, TimeUnit.DAYS)
-            }
-        }
-
-        // Assert
-        assert msgs.every { it =~ /Value '.*' is not a valid Time Duration/ }
-    }
-
-
-
-    /**
-     * Regression test
-     */
-    @Test
-    void testShouldHandleInvalidAbbreviations() {
-        // Arrange
-        final List WEEKS = ["1 work", "1 wek", "1 k"]
-
-        // Act
-        List msgs = WEEKS.collect { String week ->
-            shouldFail(IllegalArgumentException) {
-                FormatUtils.getTimeDuration(week, TimeUnit.DAYS)
-            }
-        }
-
-        // Assert
-        assert msgs.every { it =~ /Value '.*' is not a valid Time Duration/ }
-
-    }
-
-
-    /**
-     * New feature test
-     */
-    @Test
-    void testShouldHandleNoSpaceInInput() {
-        // Arrange
-        final List WEEKS = ["1week", "1wk", "1w", "1wks", "1weeks"]
-        final long EXPECTED_DAYS = 7L
-
-        // Act
-        List days = WEEKS.collect { String week ->
-            FormatUtils.getTimeDuration(week, TimeUnit.DAYS)
-        }
-        logger.converted(days)
-
-        // Assert
-        assert days.every { it == EXPECTED_DAYS }
-    }
-}
\ No newline at end of file
diff --git a/nifi-commons/nifi-utils/src/test/groovy/org/apache/nifi/util/TestFormatUtilsGroovy.groovy b/nifi-commons/nifi-utils/src/test/groovy/org/apache/nifi/util/TestFormatUtilsGroovy.groovy
new file mode 100644 (file)
index 0000000..8fc9d0c
--- /dev/null
@@ -0,0 +1,488 @@
+/*
+ * 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
+ *
+ *     http://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.nifi.util
+
+
+import org.junit.After
+import org.junit.Before
+import org.junit.BeforeClass
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
+
+import java.util.concurrent.TimeUnit
+
+@RunWith(JUnit4.class)
+class TestFormatUtilsGroovy extends GroovyTestCase {
+    private static final Logger logger = LoggerFactory.getLogger(TestFormatUtilsGroovy.class)
+
+    @BeforeClass
+    static void setUpOnce() throws Exception {
+        logger.metaClass.methodMissing = { String name, args ->
+            logger.info("[${name?.toUpperCase()}] ${(args as List).join(" ")}")
+        }
+    }
+
+    @Before
+    void setUp() throws Exception {
+
+    }
+
+    @After
+    void tearDown() throws Exception {
+
+    }
+
+    /**
+     * New feature test
+     */
+    @Test
+    void testGetTimeDurationShouldConvertWeeks() {
+        // Arrange
+        final List WEEKS = ["1 week", "1 wk", "1 w", "1 wks", "1 weeks"]
+        final long EXPECTED_DAYS = 7L
+
+        // Act
+        List days = WEEKS.collect { String week ->
+            FormatUtils.getTimeDuration(week, TimeUnit.DAYS)
+        }
+        logger.converted(days)
+
+        // Assert
+        assert days.every { it == EXPECTED_DAYS }
+    }
+
+
+    @Test
+    void testGetTimeDurationShouldHandleNegativeWeeks() {
+        // Arrange
+        final List WEEKS = ["-1 week", "-1 wk", "-1 w", "-1 weeks", "- 1 week"]
+
+        // Act
+        List msgs = WEEKS.collect { String week ->
+            shouldFail(IllegalArgumentException) {
+                FormatUtils.getTimeDuration(week, TimeUnit.DAYS)
+            }
+        }
+
+        // Assert
+        assert msgs.every { it =~ /Value '.*' is not a valid time duration/ }
+    }
+
+    /**
+     * Regression test
+     */
+    @Test
+    void testGetTimeDurationShouldHandleInvalidAbbreviations() {
+        // Arrange
+        final List WEEKS = ["1 work", "1 wek", "1 k"]
+
+        // Act
+        List msgs = WEEKS.collect { String week ->
+            shouldFail(IllegalArgumentException) {
+                FormatUtils.getTimeDuration(week, TimeUnit.DAYS)
+            }
+        }
+
+        // Assert
+        assert msgs.every { it =~ /Value '.*' is not a valid time duration/ }
+
+    }
+
+    /**
+     * New feature test
+     */
+    @Test
+    void testGetTimeDurationShouldHandleNoSpaceInInput() {
+        // Arrange
+        final List WEEKS = ["1week", "1wk", "1w", "1wks", "1weeks"]
+        final long EXPECTED_DAYS = 7L
+
+        // Act
+        List days = WEEKS.collect { String week ->
+            FormatUtils.getTimeDuration(week, TimeUnit.DAYS)
+        }
+        logger.converted(days)
+
+        // Assert
+        assert days.every { it == EXPECTED_DAYS }
+    }
+
+    /**
+     * New feature test
+     */
+    @Test
+    void testGetTimeDurationShouldHandleDecimalValues() {
+        // Arrange
+        final List WHOLE_NUMBERS = ["10 ms", "10 millis", "10 milliseconds"]
+        final List DECIMAL_NUMBERS = ["0.010 s", "0.010 seconds"]
+        final long EXPECTED_MILLIS = 10
+
+        // Act
+        List parsedWholeMillis = WHOLE_NUMBERS.collect { String whole ->
+            FormatUtils.getTimeDuration(whole, TimeUnit.MILLISECONDS)
+        }
+        logger.converted(parsedWholeMillis)
+
+        List parsedDecimalMillis = DECIMAL_NUMBERS.collect { String decimal ->
+            FormatUtils.getTimeDuration(decimal, TimeUnit.MILLISECONDS)
+        }
+        logger.converted(parsedDecimalMillis)
+
+        // Assert
+        assert parsedWholeMillis.every { it == EXPECTED_MILLIS }
+        assert parsedDecimalMillis.every { it == EXPECTED_MILLIS }
+    }
+
+    /**
+     * Regression test for custom week logic
+     */
+    @Test
+    void testGetPreciseTimeDurationShouldHandleWeeks() {
+        // Arrange
+        final String ONE_WEEK = "1 week"
+        final Map ONE_WEEK_IN_OTHER_UNITS = [
+                (TimeUnit.DAYS)        : 7,
+                (TimeUnit.HOURS)       : 7 * 24,
+                (TimeUnit.MINUTES)     : 7 * 24 * 60,
+                (TimeUnit.SECONDS)     : (long) 7 * 24 * 60 * 60,
+                (TimeUnit.MILLISECONDS): (long) 7 * 24 * 60 * 60 * 1000,
+                (TimeUnit.MICROSECONDS): (long) 7 * 24 * 60 * 60 * ((long) 1000 * 1000),
+                (TimeUnit.NANOSECONDS) : (long) 7 * 24 * 60 * 60 * ((long) 1000 * 1000 * 1000),
+        ]
+
+        // Act
+        Map oneWeekInOtherUnits = TimeUnit.values()[0..<-1].collectEntries { TimeUnit destinationUnit ->
+            [destinationUnit, FormatUtils.getPreciseTimeDuration(ONE_WEEK, destinationUnit)]
+        }
+        logger.converted(oneWeekInOtherUnits)
+
+        // Assert
+        oneWeekInOtherUnits.each { TimeUnit k, double value ->
+            assert value == ONE_WEEK_IN_OTHER_UNITS[k]
+        }
+    }
+
+    /**
+     * Positive flow test for custom week logic with decimal value
+     */
+    @Test
+    void testGetPreciseTimeDurationShouldHandleDecimalWeeks() {
+        // Arrange
+        final String ONE_AND_A_HALF_WEEKS = "1.5 week"
+        final Map ONE_POINT_FIVE_WEEKS_IN_OTHER_UNITS = [
+                (TimeUnit.DAYS)        : 7,
+                (TimeUnit.HOURS)       : 7 * 24,
+                (TimeUnit.MINUTES)     : 7 * 24 * 60,
+                (TimeUnit.SECONDS)     : (long) 7 * 24 * 60 * 60,
+                (TimeUnit.MILLISECONDS): (long) 7 * 24 * 60 * 60 * 1000,
+                (TimeUnit.MICROSECONDS): (long) 7 * 24 * 60 * 60 * ((long) 1000 * 1000),
+                (TimeUnit.NANOSECONDS) : (long) 7 * 24 * 60 * 60 * ((long) 1000 * 1000 * 1000),
+        ].collectEntries { k, v -> [k, v * 1.5] }
+
+        // Act
+        Map onePointFiveWeeksInOtherUnits = TimeUnit.values()[0..<-1].collectEntries { TimeUnit destinationUnit ->
+            [destinationUnit, FormatUtils.getPreciseTimeDuration(ONE_AND_A_HALF_WEEKS, destinationUnit)]
+        }
+        logger.converted(onePointFiveWeeksInOtherUnits)
+
+        // Assert
+        onePointFiveWeeksInOtherUnits.each { TimeUnit k, double value ->
+            assert value == ONE_POINT_FIVE_WEEKS_IN_OTHER_UNITS[k]
+        }
+    }
+
+    /**
+     * Positive flow test for decimal time inputs
+     */
+    @Test
+    void testGetPreciseTimeDurationShouldHandleDecimalValues() {
+        // Arrange
+        final List WHOLE_NUMBERS = ["10 ms", "10 millis", "10 milliseconds"]
+        final List DECIMAL_NUMBERS = ["0.010 s", "0.010 seconds"]
+        final float EXPECTED_MILLIS = 10.0
+
+        // Act
+        List parsedWholeMillis = WHOLE_NUMBERS.collect { String whole ->
+            FormatUtils.getPreciseTimeDuration(whole, TimeUnit.MILLISECONDS)
+        }
+        logger.converted(parsedWholeMillis)
+
+        List parsedDecimalMillis = DECIMAL_NUMBERS.collect { String decimal ->
+            FormatUtils.getPreciseTimeDuration(decimal, TimeUnit.MILLISECONDS)
+        }
+        logger.converted(parsedDecimalMillis)
+
+        // Assert
+        assert parsedWholeMillis.every { it == EXPECTED_MILLIS }
+        assert parsedDecimalMillis.every { it == EXPECTED_MILLIS }
+    }
+
+    /**
+     * Positive flow test for decimal inputs that are extremely small
+     */
+    @Test
+    void testGetPreciseTimeDurationShouldHandleSmallDecimalValues() {
+        // Arrange
+        final Map SCENARIOS = [
+                "decimalNanos"           : [originalUnits: TimeUnit.NANOSECONDS, expectedUnits: TimeUnit.NANOSECONDS, originalValue: 123.4, expectedValue: 123.0],
+                "lessThanOneNano"        : [originalUnits: TimeUnit.NANOSECONDS, expectedUnits: TimeUnit.NANOSECONDS, originalValue: 0.9, expectedValue: 1],
+                "lessThanOneNanoToMillis": [originalUnits: TimeUnit.NANOSECONDS, expectedUnits: TimeUnit.MILLISECONDS, originalValue: 0.9, expectedValue: 0],
+                "decimalMillisToNanos"        : [originalUnits: TimeUnit.MILLISECONDS, expectedUnits: TimeUnit.NANOSECONDS, originalValue: 123.4, expectedValue: 123_400_000],
+        ]
+
+        // Act
+        Map results = SCENARIOS.collectEntries { String k, Map values ->
+            logger.debug("Evaluating ${k}: ${values}")
+            String input = "${values.originalValue} ${values.originalUnits.name()}"
+            [k, FormatUtils.getPreciseTimeDuration(input, values.expectedUnits)]
+        }
+        logger.info(results)
+
+        // Assert
+        results.every { String key, double value ->
+            assert value == SCENARIOS[key].expectedValue
+        }
+    }
+
+    /**
+     * Positive flow test for decimal inputs that can be converted (all equal values)
+     */
+    @Test
+    void testMakeWholeNumberTimeShouldHandleDecimals() {
+        // Arrange
+        final List DECIMAL_TIMES = [
+                [0.000_000_010, TimeUnit.SECONDS],
+                [0.000_010, TimeUnit.MILLISECONDS],
+                [0.010, TimeUnit.MICROSECONDS]
+        ]
+        final long EXPECTED_NANOS = 10L
+
+        // Act
+        List parsedWholeNanos = DECIMAL_TIMES.collect { List it ->
+            FormatUtils.makeWholeNumberTime(it[0] as float, it[1] as TimeUnit)
+        }
+        logger.converted(parsedWholeNanos)
+
+        // Assert
+        assert parsedWholeNanos.every { it == [EXPECTED_NANOS, TimeUnit.NANOSECONDS] }
+    }
+
+    /**
+     * Positive flow test for decimal inputs that can be converted (metric values)
+     */
+    @Test
+    void testMakeWholeNumberTimeShouldHandleMetricConversions() {
+        // Arrange
+        final Map SCENARIOS = [
+                "secondsToMillis": [originalUnits: TimeUnit.SECONDS, expectedUnits: TimeUnit.MILLISECONDS, expectedValue: 123_400, originalValue: 123.4],
+                "secondsToMicros": [originalUnits: TimeUnit.SECONDS, expectedUnits: TimeUnit.MICROSECONDS, originalValue: 1.000_345, expectedValue: 1_000_345],
+                "millisToNanos"  : [originalUnits: TimeUnit.MILLISECONDS, expectedUnits: TimeUnit.NANOSECONDS, originalValue: 0.75, expectedValue: 750_000],
+                "nanosToNanosGE1": [originalUnits: TimeUnit.NANOSECONDS, expectedUnits: TimeUnit.NANOSECONDS, originalValue: 123.4, expectedValue: 123],
+                "nanosToNanosLE1": [originalUnits: TimeUnit.NANOSECONDS, expectedUnits: TimeUnit.NANOSECONDS, originalValue: 0.123, expectedValue: 1],
+        ]
+
+        // Act
+        Map results = SCENARIOS.collectEntries { String k, Map values ->
+            logger.debug("Evaluating ${k}: ${values}")
+            [k, FormatUtils.makeWholeNumberTime(values.originalValue, values.originalUnits)]
+        }
+        logger.info(results)
+
+        // Assert
+        results.every { String key, List values ->
+            assert values.first() == SCENARIOS[key].expectedValue
+            assert values.last() == SCENARIOS[key].expectedUnits
+        }
+    }
+
+    /**
+     * Positive flow test for decimal inputs that can be converted (non-metric values)
+     */
+    @Test
+    void testMakeWholeNumberTimeShouldHandleNonMetricConversions() {
+        // Arrange
+        final Map SCENARIOS = [
+                "daysToHours"    : [originalUnits: TimeUnit.DAYS, expectedUnits: TimeUnit.HOURS, expectedValue: 36, originalValue: 1.5],
+                "hoursToMinutes" : [originalUnits: TimeUnit.HOURS, expectedUnits: TimeUnit.MINUTES, originalValue: 1.5, expectedValue: 90],
+                "hoursToMinutes2": [originalUnits: TimeUnit.HOURS, expectedUnits: TimeUnit.MINUTES, originalValue: 0.75, expectedValue: 45],
+        ]
+
+        // Act
+        Map results = SCENARIOS.collectEntries { String k, Map values ->
+            logger.debug("Evaluating ${k}: ${values}")
+            [k, FormatUtils.makeWholeNumberTime(values.originalValue, values.originalUnits)]
+        }
+        logger.info(results)
+
+        // Assert
+        results.every { String key, List values ->
+            assert values.first() == SCENARIOS[key].expectedValue
+            assert values.last() == SCENARIOS[key].expectedUnits
+        }
+    }
+
+    /**
+     * Positive flow test for whole inputs
+     */
+    @Test
+    void testMakeWholeNumberTimeShouldHandleWholeNumbers() {
+        // Arrange
+        final List WHOLE_TIMES = [
+                [10.0, TimeUnit.DAYS],
+                [10.0, TimeUnit.HOURS],
+                [10.0, TimeUnit.MINUTES],
+                [10.0, TimeUnit.SECONDS],
+                [10.0, TimeUnit.MILLISECONDS],
+                [10.0, TimeUnit.MICROSECONDS],
+                [10.0, TimeUnit.NANOSECONDS],
+        ]
+
+        // Act
+        List parsedWholeTimes = WHOLE_TIMES.collect { List it ->
+            FormatUtils.makeWholeNumberTime(it[0] as float, it[1] as TimeUnit)
+        }
+        logger.converted(parsedWholeTimes)
+
+        // Assert
+        parsedWholeTimes.eachWithIndex { List elements, int i ->
+            assert elements[0] instanceof Long
+            assert elements[0] == 10L
+            assert elements[1] == WHOLE_TIMES[i][1]
+        }
+    }
+
+    /**
+     * Negative flow test for nanosecond inputs (regardless of value, the unit cannot be converted)
+     */
+    @Test
+    void testMakeWholeNumberTimeShouldHandleNanoseconds() {
+        // Arrange
+        final List WHOLE_TIMES = [
+                [1100.0, TimeUnit.NANOSECONDS],
+                [2.1, TimeUnit.NANOSECONDS],
+                [1.0, TimeUnit.NANOSECONDS],
+                [0.1, TimeUnit.NANOSECONDS],
+        ]
+
+        final List EXPECTED_TIMES = [
+                [1100L, TimeUnit.NANOSECONDS],
+                [2L, TimeUnit.NANOSECONDS],
+                [1L, TimeUnit.NANOSECONDS],
+                [1L, TimeUnit.NANOSECONDS],
+        ]
+
+        // Act
+        List parsedWholeTimes = WHOLE_TIMES.collect { List it ->
+            FormatUtils.makeWholeNumberTime(it[0] as float, it[1] as TimeUnit)
+        }
+        logger.converted(parsedWholeTimes)
+
+        // Assert
+        assert parsedWholeTimes == EXPECTED_TIMES
+    }
+
+    /**
+     * Positive flow test for whole inputs
+     */
+    @Test
+    void testShouldGetSmallerTimeUnit() {
+        // Arrange
+        final List UNITS = TimeUnit.values() as List
+
+        // Act
+        def nullMsg = shouldFail(IllegalArgumentException) {
+            FormatUtils.getSmallerTimeUnit(null)
+        }
+        logger.expected(nullMsg)
+
+        def nanosMsg = shouldFail(IllegalArgumentException) {
+            FormatUtils.getSmallerTimeUnit(TimeUnit.NANOSECONDS)
+        }
+        logger.expected(nanosMsg)
+
+        List smallerTimeUnits = UNITS[1..-1].collect { TimeUnit unit ->
+            FormatUtils.getSmallerTimeUnit(unit)
+        }
+        logger.converted(smallerTimeUnits)
+
+        // Assert
+        assert nullMsg == "Cannot determine a smaller time unit than 'null'"
+        assert nanosMsg == "Cannot determine a smaller time unit than 'NANOSECONDS'"
+        assert smallerTimeUnits == UNITS[0..<-1]
+    }
+
+    /**
+     * Positive flow test for multipliers based on valid time units
+     */
+    @Test
+    void testShouldCalculateMultiplier() {
+        // Arrange
+        final Map SCENARIOS = [
+                "allUnits"      : [original: TimeUnit.DAYS, destination: TimeUnit.NANOSECONDS, expectedMultiplier: (long) 24 * 60 * 60 * (long) 1_000_000_000],
+                "microsToNanos" : [original: TimeUnit.MICROSECONDS, destination: TimeUnit.NANOSECONDS, expectedMultiplier: 1_000],
+                "millisToNanos" : [original: TimeUnit.MILLISECONDS, destination: TimeUnit.NANOSECONDS, expectedMultiplier: 1_000_000],
+                "millisToMicros": [original: TimeUnit.MILLISECONDS, destination: TimeUnit.MICROSECONDS, expectedMultiplier: 1_000],
+                "daysToHours"   : [original: TimeUnit.DAYS, destination: TimeUnit.HOURS, expectedMultiplier: 24],
+                "daysToSeconds" : [original: TimeUnit.DAYS, destination: TimeUnit.SECONDS, expectedMultiplier: 24 * 60 * 60],
+        ]
+
+        // Act
+        Map results = SCENARIOS.collectEntries { String k, Map values ->
+            logger.debug("Evaluating ${k}: ${values}")
+            [k, FormatUtils.calculateMultiplier(values.original, values.destination)]
+        }
+        logger.converted(results)
+
+        // Assert
+        results.every { String key, long value ->
+            assert value == SCENARIOS[key].expectedMultiplier
+        }
+    }
+
+    /**
+     * Negative flow test for multipliers based on incorrectly-ordered time units
+     */
+    @Test
+    void testCalculateMultiplierShouldHandleIncorrectUnits() {
+        // Arrange
+        final Map SCENARIOS = [
+                "allUnits"     : [original: TimeUnit.NANOSECONDS, destination: TimeUnit.DAYS],
+                "nanosToMicros": [original: TimeUnit.NANOSECONDS, destination: TimeUnit.MICROSECONDS],
+                "hoursToDays"  : [original: TimeUnit.HOURS, destination: TimeUnit.DAYS],
+        ]
+
+        // Act
+        Map results = SCENARIOS.collectEntries { String k, Map values ->
+            logger.debug("Evaluating ${k}: ${values}")
+            def msg = shouldFail(IllegalArgumentException) {
+                FormatUtils.calculateMultiplier(values.original, values.destination)
+            }
+            logger.expected(msg)
+            [k, msg]
+        }
+
+        // Assert
+        results.every { String key, String value ->
+            assert value =~ "The original time unit '.*' must be larger than the new time unit '.*'"
+        }
+    }
+
+    // TODO: Microsecond parsing
+}
\ No newline at end of file