Fix BigInteger.Parse returning incorrect values for exponents above 1000

src/libraries/Common/src/System/Globalization/FormatProvider.Number.cs

@@ -517,15 +517,19 @@ private static unsafe bool ParseNumber(ref char* str, char* strEnd, NumberStyles
                             {
                                 exp = exp * 10 + (ch - '0');
                                 ch = ++p < strEnd ? *p : '\0';
-                                if (exp > 1000)
-                                {
-                                    exp = 9999;
-                                    while (char.IsAsciiDigit(ch))
-                                    {
-                                        ch = ++p < strEnd ? *p : '\0';
-                                    }
-                                }
-                            } while (char.IsAsciiDigit(ch));
+                            } while (char.IsAsciiDigit(ch) && (exp < int.MaxValue / 10));
+
+                            if (char.IsAsciiDigit(ch))
+                            {
+                                // We still had remaining characters but bailed early because
+                                // the exponent was going to overflow. If exp is exactly 214748364
+                                // then we can technically handle one more character being 0-7
+                                // but the additional complexity might not be worthwhile.
+
+                                Debug.Assert(exp >= 214748364);
+                                throw new PlatformNotSupportedException();
+                            }
+
                             if (negExp)
                             {
                                 exp = -exp;

src/libraries/System.Runtime.Numerics/tests/BigInteger/BigIntegerToStringTests.cs

@@ -439,6 +439,38 @@ public static void CustomFormatPerMille()
             RunCustomFormatToStringTests(s_random, "#\u2030000000", CultureInfo.CurrentCulture.NumberFormat.NegativeSign, 6, PerMilleSymbolFormatter);
         }
 
+        public static IEnumerable<object[]> RunFormatScientificNotationToBigIntegerAndViceVersaData()
+        {
+            yield return new object[] { "1E+1000", "1E+1000" };
+            yield return new object[] { "1E+1001", "1E+1001" };
+        }
+
+        [Theory]
+        [MemberData(nameof(RunFormatScientificNotationToBigIntegerAndViceVersaData))]
+        public static void RunFormatScientificNotationToBigIntegerAndViceVersa(string testingValue, string expectedResult)
+        {
+            BigInteger parsedValue;
+            string actualResult;
+
+            parsedValue = BigInteger.Parse(testingValue, NumberStyles.AllowExponent);
+            actualResult = parsedValue.ToString("E0");
+
+            Assert.Equal(expectedResult, actualResult);
+        }
+
+        public static IEnumerable<object[]> RunFormatScientificNotationToBigIntegerThrowsExceptionData()
+        {
+            yield return new object[] { "1E+2147483647" };
+            yield return new object[] { "1E+21474836492" };
+        }
+
+        [Theory]
+        [MemberData(nameof(RunFormatScientificNotationToBigIntegerThrowsExceptionData))]
+        public static void RunFormatScientificNotationToBigIntegerThrowsException(string testingValue)
+        {
+            Assert.Throws<PlatformNotSupportedException>(() => BigInteger.Parse(testingValue, NumberStyles.AllowExponent));
+        }
+
         private static void RunSimpleProviderToStringTests(Random random, string format, NumberFormatInfo provider, int precision, StringFormatter formatter)
         {
             string test;