Handle extremely large/small values

Author: Morten Haraldsen

src/main/java/com/ethlo/time/internal/ItuDurationParser.java

@@ -95,7 +95,6 @@ private static int readUntilNonDigit(final String text, final int offset, final
         int unit = 0;
         int index = offset;
         long value = 0;
-        int startIndex = index;
         while (index < text.length())
         {
             final char c = text.charAt(index);
@@ -107,20 +106,22 @@ private static int readUntilNonDigit(final String text, final int offset, final
             }
             else
             {
-                int digit = c - DIGIT_ZERO;
+                final int digit = c - DIGIT_ZERO;
+
+                // Check for overflow before updating `value`
+                if (value > (Long.MAX_VALUE - digit) / 10)
+                {
+                    error("Expression is too large", text, index);
+                }
+
                 value = (value << 3) + (value << 1) + digit;
                 index++;
             }
         }
 
-        if (index - startIndex > MAX_DIGITS || value > Integer.MAX_VALUE)
-        {
-            error("Value too large for unit '" + (char) unit + "'", text, index);
-        }
-
         final int length = index - offset;
 
-        consumer.accept(text, index, length, (char) unit, (int) value);
+        consumer.accept(text, index, length, (char) unit, value);
 
         return index + 1;
     }
@@ -153,7 +154,7 @@ private DurationPartsConsumer(final int startOffset, boolean negative)
             this.negative = negative;
         }
 
-        public final void accept(final String text, final int index, final int length, final char unit, final int value)
+        public final void accept(final String text, final int index, final int length, final char unit, final long value)
         {
             final int relIndex = index - startOffset;
 
@@ -173,12 +174,6 @@ public final void accept(final String text, final int index, final int length, f
                 error("Duration must start with 'P'", text, index);
             }
 
-            /*
-             * An int can never overflow a long when used for seconds, minutes, hours, days, and weeks,
-             * even at their maximum values, because the total number of seconds remains within the
-             * 64-bit long's limits.
-             */
-
             if (unit == 0)
             {
                 if (!dotFound)
@@ -286,12 +281,7 @@ public final void accept(final String text, final int index, final int length, f
                             error("Maximum allowed is 9 fraction digits", text, index);
                         }
 
-                        if (length == 0)
-                        {
-                            error("Must have at least one fraction digit after the '.''", text, index);
-                        }
-
-                        nano = value;
+                        nano = Math.toIntExact(value);
                         int remainingDigits = DIGITS_IN_NANO - length;
                         if (remainingDigits > 0)
                         {

src/test/java/com/ethlo/time/ItuDurationParserTest.java

@@ -20,15 +20,15 @@
  * #L%
  */
 
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.junit.jupiter.api.Assertions.assertThrows;
-
-import java.time.format.DateTimeParseException;
+import com.ethlo.time.internal.ItuDurationParser;
 
 import org.junit.jupiter.api.Test;
 
-import com.ethlo.time.internal.ItuDurationParser;
+import java.time.format.DateTimeParseException;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 class ItuDurationParserTest
 {
@@ -39,6 +39,24 @@ void testMissingP()
                 .hasMessage("Duration must start with 'P': 1D");
     }
 
+    @Test
+    void testHighestValue()
+    {
+        final String input = "PT" + Long.MAX_VALUE + ".999999999S";
+        final Duration result = ITU.parseDuration(input);
+        assertThat(result.getSeconds()).isEqualTo(Long.MAX_VALUE);
+        assertThat(result.getNanos()).isEqualTo(999_999_999);
+    }
+
+    @Test
+    void testLowestValue()
+    {
+        final String input = "-PT9223372036854775807S";
+        final Duration result = ITU.parseDuration(input);
+        assertThat(result.getSeconds()).isEqualTo(-Long.MAX_VALUE);
+        assertThat(result.getNanos()).isEqualTo(0L);
+    }
+
     @Test
     void testValidMinimal()
     {
@@ -137,10 +155,10 @@ void shouldParseDurationWithNoTimeSection()
     @Test
     void shouldThrowDateTimeParseExceptionForOverflow()
     {
-        final String input = "P20D9999999999999999H";
+        final String input = "P20D999999999999999999999H";
         assertThatThrownBy(() -> ItuDurationParser.parse(input))
                 .isInstanceOf(DateTimeParseException.class)
-                .hasMessageContaining("Value too large for unit 'H': " + input);
+                .hasMessageContaining("Expression is too large: " + input);
     }
 
     @Test