Limit IntegerParseStrategy's fallback Double path to lossless integer range (#667)

* Some tests about IntegerParseStrategy's big int behavior w.r.t. Double.

IntegerParseStrategy currently tries to parse a Double when it fails to parse an Int64, which results in some odd behavior for magnitudes greater than 2^53. The oddities stem the from fact that the parseAsDouble(_:) method rounds its input String to the nearest Double. This commit adds some tests that fail when this happens.

* Updated: NumberParseStrategyTests/testNumericBoundsParsing().

I added some UInt8 and Int64 checks and some UInt64 test w.r.t. exact Double values.

* Do not round to the nearest Double when parsing integers greater than Int64.

This change rejects values greater than ±2^53 in IntegerParseStrategy's Double fallback path. This limit is the upper bound of Double's lossless integer range. The parseAsDouble(_:) method rounds greater magnitudes to the nearest Double. Ideally, the parser should not have to fall back on Double but that is out-of-scope of this contribution.

* Disabled UInt64 parsing tests for values in (Int64.max, UInt64.max].

See previous commits. The currently supported integer parsing range is [Int64.min, Int64.max].

* Corrects the lossless range in IntegerParseStrategy's fallback Double path.

A value of ±(2^53) may not be exact since ±(2^53+1) is not a Double and becomes ±(2^53) when rounded towards zero.

* Reenabled some IntegerParseStrategy tests in accordance with review comments.

The test suite now checks the new behavior rather than awaiting the desired behavior via code comments.

Author: oscbyspro

Sources/FoundationInternationalization/Formatting/Number/IntegerParseStrategy.swift

@@ -40,6 +40,10 @@ extension IntegerParseStrategy: ParseStrategy {
             }
             return exact
         } else if let v = parser.parseAsDouble(trimmedString) {
+            guard v.magnitude < Double(sign: .plus, exponent: Double.significandBitCount + 1, significand: 1) else {
+                throw CocoaError(CocoaError.formatting, userInfo: [
+                    NSDebugDescriptionErrorKey: "Cannot parse \(value). The number does not fall within the lossless floating-point range" ])
+            }
             guard let exact = Format.FormatInput(exactly: v) else {
                 throw CocoaError(CocoaError.formatting, userInfo: [
                     NSDebugDescriptionErrorKey: "Cannot parse \(value). The number does not fall within the valid bounds of the specified output type" ])

Tests/FoundationInternationalizationTests/Formatting/NumberParseStrategyTests.swift

@@ -192,22 +192,68 @@ final class NumberParseStrategyTests : XCTestCase {
     func testNumericBoundsParsing() throws {
         let locale = Locale(identifier: "en_US")
         do {
+            let format: IntegerFormatStyle<Int8> = .init(locale: locale)
+            let parseStrategy = IntegerParseStrategy(format: format, lenient: true)
+            XCTAssertEqual(try parseStrategy.parse(Int8.min.formatted(format)), Int8.min)
+            XCTAssertEqual(try parseStrategy.parse(Int8.max.formatted(format)), Int8.max)
+            XCTAssertThrowsError(try parseStrategy.parse("-129"))
+            XCTAssertThrowsError(try parseStrategy.parse("128"))
+        }
+        
+        do {
+            let format: IntegerFormatStyle<Int64> = .init(locale: locale)
+            let parseStrategy = IntegerParseStrategy(format: format, lenient: true)
+            XCTAssertEqual(try parseStrategy.parse(Int64.min.formatted(format)), Int64.min)
+            XCTAssertEqual(try parseStrategy.parse(Int64.max.formatted(format)), Int64.max)
+            XCTAssertThrowsError(try parseStrategy.parse("-9223372036854775809"))
+            XCTAssertThrowsError(try parseStrategy.parse("9223372036854775808"))
+        }
+        
+        do {
+            let format: IntegerFormatStyle<UInt8> = .init(locale: locale)
+            let parseStrategy = IntegerParseStrategy(format: format, lenient: true)
+            XCTAssertEqual(try parseStrategy.parse(UInt8.min.formatted(format)), UInt8.min)
+            XCTAssertEqual(try parseStrategy.parse(UInt8.max.formatted(format)), UInt8.max)
+            XCTAssertThrowsError(try parseStrategy.parse("-1"))
+            XCTAssertThrowsError(try parseStrategy.parse("256"))
+        }
+        
+        do {
+            // TODO: Parse integers greater than Int64
             let format: IntegerFormatStyle<UInt64> = .init(locale: locale)
             let parseStrategy = IntegerParseStrategy(format: format, lenient: true)
-            XCTAssertEqual(try parseStrategy.parse(0.formatted(format)), 0)
-            let aboveInt64Max = UInt64(Int64.max) + 1
-            XCTAssertEqual(try parseStrategy.parse(aboveInt64Max.formatted(format)), aboveInt64Max)
+            XCTAssertEqual(      try parseStrategy.parse(UInt64.min.formatted(format)), UInt64.min)
+            XCTAssertThrowsError(try parseStrategy.parse(UInt64.max.formatted(format)))
             XCTAssertThrowsError(try parseStrategy.parse("-1"))
-            XCTAssertThrowsError(try parseStrategy.parse("-1,000,000"))
+            XCTAssertThrowsError(try parseStrategy.parse("18446744073709551616"))
+            
+            // TODO: Parse integers greater than Int64
+            let maxInt64 = UInt64(Int64.max)
+            XCTAssertEqual(      try parseStrategy.parse((maxInt64 + 0).formatted(format)), maxInt64) // not a Double
+            XCTAssertThrowsError(try parseStrategy.parse((maxInt64 + 1).formatted(format)))           // exact Double
+            XCTAssertThrowsError(try parseStrategy.parse((maxInt64 + 2).formatted(format)))           // not a Double
+            XCTAssertThrowsError(try parseStrategy.parse((maxInt64 + 3).formatted(format)))           // not a Double
+        }
+    }
+    
+    func testIntegerParseStrategyDoesNotRoundLargeIntegersToNearestDouble() {
+        XCTAssertEqual(Double("9007199254740992"), Double(exactly: UInt64(1) << 53)!) // +2^53 + 0 -> +2^53
+        XCTAssertEqual(Double("9007199254740993"), Double(exactly: UInt64(1) << 53)!) // +2^53 + 1 -> +2^53
+        XCTAssertEqual(Double.significandBitCount, 52, "Double can represent each integer in -2^53 ... 2^53")
+        let locale = Locale(identifier: "en_US")
+
+        do {
+            let format: IntegerFormatStyle<Int64> = .init(locale: locale)
+            let parseStrategy = IntegerParseStrategy(format: format, lenient: true)
+            XCTAssertNotEqual(try? parseStrategy.parse("-9223372036854776832"), -9223372036854775808) // -2^63 - 1024 (Double: -2^63)
+            XCTAssertNil(     try? parseStrategy.parse("-9223372036854776833"))                       // -2^63 - 1025 (Double: -2^63 - 2048)
         }
 
         do {
-            let format: IntegerFormatStyle<Int8> = .init(locale: locale)
+            let format: IntegerFormatStyle<UInt64> = .init(locale: locale)
             let parseStrategy = IntegerParseStrategy(format: format, lenient: true)
-            XCTAssertEqual(try parseStrategy.parse(Int8.min.formatted(format)), Int8.min)
-            XCTAssertEqual(try parseStrategy.parse(Int8.max.formatted(format)), Int8.max)
-            XCTAssertThrowsError(try parseStrategy.parse("-129"))
-            XCTAssertThrowsError(try parseStrategy.parse("128"))
+            XCTAssertNotEqual(try? parseStrategy.parse( "9223372036854776832"),  9223372036854775808) // +2^63 + 1024 (Double: +2^63)
+            XCTAssertNotEqual(try? parseStrategy.parse( "9223372036854776833"),  9223372036854777856) // +2^63 + 1025 (Double: +2^63 + 2048)
         }
     }
 }