Only format non-negative int64 #760

JunTaoLuo · JunTaoLuo · commit 4043a1cfadce · 2017-02-24T14:17:12.000-08:00
diff --git a/src/Microsoft.AspNetCore.Http.Extensions/HeaderDictionaryTypeExtensions.cs b/src/Microsoft.AspNetCore.Http.Extensions/HeaderDictionaryTypeExtensions.cs
@@ -156,7 +156,7 @@ internal static void SetDate(this IHeaderDictionary headers, string name, DateTi
             { typeof(RangeHeaderValue), new Func<string, RangeHeaderValue>(value => { RangeHeaderValue result; return RangeHeaderValue.TryParse(value, out result) ? result : null; }) },
             { typeof(EntityTagHeaderValue), new Func<string, EntityTagHeaderValue>(value => { EntityTagHeaderValue result; return EntityTagHeaderValue.TryParse(value, out result) ? result : null; }) },
             { typeof(DateTimeOffset?), new Func<string, DateTimeOffset?>(value => { DateTimeOffset result; return HeaderUtilities.TryParseDate(value, out result) ? result : (DateTimeOffset?)null; }) },
-            { typeof(long?), new Func<string, long?>(value => { long result; return HeaderUtilities.TryParseInt64(value, out result) ? result : (long?)null; }) },
+            { typeof(long?), new Func<string, long?>(value => { long result; return HeaderUtilities.TryParseNonNegativeInt64(value, out result) ? result : (long?)null; }) },
         };
 
         private static IDictionary<Type, object> KnownListParsers = new Dictionary<Type, object>()
diff --git a/src/Microsoft.AspNetCore.Http.Extensions/RequestHeaders.cs b/src/Microsoft.AspNetCore.Http.Extensions/RequestHeaders.cs
@@ -101,7 +101,7 @@ public long? ContentLength
             }
             set
             {
-                Headers.Set(HeaderNames.ContentLength, value.HasValue ? HeaderUtilities.FormatInt64(value.Value) : null);
+                Headers.Set(HeaderNames.ContentLength, value.HasValue ? HeaderUtilities.FormatNonNegativeInt64(value.Value) : null);
             }
         }
 
diff --git a/src/Microsoft.AspNetCore.Http.Extensions/ResponseHeaders.cs b/src/Microsoft.AspNetCore.Http.Extensions/ResponseHeaders.cs
@@ -54,7 +54,7 @@ public long? ContentLength
             }
             set
             {
-                Headers.Set(HeaderNames.ContentLength, value.HasValue ? HeaderUtilities.FormatInt64(value.Value) : null);
+                Headers.Set(HeaderNames.ContentLength, value.HasValue ? HeaderUtilities.FormatNonNegativeInt64(value.Value) : null);
             }
         }
 
diff --git a/src/Microsoft.AspNetCore.Http/HeaderDictionary.cs b/src/Microsoft.AspNetCore.Http/HeaderDictionary.cs
@@ -106,7 +106,7 @@ public long? ContentLength
                 var rawValue = this[HeaderNames.ContentLength];
                 if (rawValue.Count == 1 &&
                     !string.IsNullOrWhiteSpace(rawValue[0]) &&
-                    HeaderUtilities.TryParseInt64(new StringSegment(rawValue[0]).Trim(), out value))
+                    HeaderUtilities.TryParseNonNegativeInt64(new StringSegment(rawValue[0]).Trim(), out value))
                 {
                     return value;
                 }
@@ -117,7 +117,7 @@ public long? ContentLength
             {
                 if (value.HasValue)
                 {
-                    this[HeaderNames.ContentLength] = HeaderUtilities.FormatInt64(value.Value);
+                    this[HeaderNames.ContentLength] = HeaderUtilities.FormatNonNegativeInt64(value.Value);
                 }
                 else
                 {
diff --git a/src/Microsoft.AspNetCore.Owin/DictionaryStringValuesWrapper.cs b/src/Microsoft.AspNetCore.Owin/DictionaryStringValuesWrapper.cs
@@ -57,7 +57,7 @@ public long? ContentLength
 
                 if (rawValue.Length == 1 &&
                     !string.IsNullOrWhiteSpace(rawValue[0]) &&
-                    HeaderUtilities.TryParseInt64(new StringSegment(rawValue[0]).Trim(), out value))
+                    HeaderUtilities.TryParseNonNegativeInt64(new StringSegment(rawValue[0]).Trim(), out value))
                 {
                     return value;
                 }
@@ -68,7 +68,7 @@ public long? ContentLength
             {
                 if (value.HasValue)
                 {
-                    Inner[HeaderNames.ContentLength] = (StringValues)HeaderUtilities.FormatInt64(value.Value);
+                    Inner[HeaderNames.ContentLength] = (StringValues)HeaderUtilities.FormatNonNegativeInt64(value.Value);
                 }
                 else
                 {
diff --git a/src/Microsoft.Net.Http.Headers/CacheControlHeaderValue.cs b/src/Microsoft.Net.Http.Headers/CacheControlHeaderValue.cs
@@ -610,7 +610,7 @@ private static bool TrySetTimeSpan(NameValueHeaderValue nameValue, ref TimeSpan?
             }
 
             int seconds;
-            if (!HeaderUtilities.TryParseInt32(nameValue.Value, out seconds))
+            if (!HeaderUtilities.TryParseNonNegativeInt32(nameValue.Value, out seconds))
             {
                 return false;
             }
diff --git a/src/Microsoft.Net.Http.Headers/ContentDispositionHeaderValue.cs b/src/Microsoft.Net.Http.Headers/ContentDispositionHeaderValue.cs
@@ -108,7 +108,7 @@ public long? Size
                 if (sizeParameter != null)
                 {
                     var sizeString = sizeParameter.Value;
-                    if (HeaderUtilities.TryParseInt64(sizeString, out value))
+                    if (HeaderUtilities.TryParseNonNegativeInt64(sizeString, out value))
                     {
                         return value;
                     }
diff --git a/src/Microsoft.Net.Http.Headers/ContentRangeHeaderValue.cs b/src/Microsoft.Net.Http.Headers/ContentRangeHeaderValue.cs
@@ -354,13 +354,13 @@ private static bool TryCreateContentRange(
             parsedValue = null;
 
             long from = 0;
-            if ((fromLength > 0) && !HeaderUtilities.TryParseInt64(input.Substring(fromStartIndex, fromLength), out from))
+            if ((fromLength > 0) && !HeaderUtilities.TryParseNonNegativeInt64(input.Substring(fromStartIndex, fromLength), out from))
             {
                 return false;
             }
 
             long to = 0;
-            if ((toLength > 0) && !HeaderUtilities.TryParseInt64(input.Substring(toStartIndex, toLength), out to))
+            if ((toLength > 0) && !HeaderUtilities.TryParseNonNegativeInt64(input.Substring(toStartIndex, toLength), out to))
             {
                 return false;
             }
@@ -372,7 +372,7 @@ private static bool TryCreateContentRange(
             }
 
             long length = 0;
-            if ((lengthLength > 0) && !HeaderUtilities.TryParseInt64(input.Substring(lengthStartIndex, lengthLength),
+            if ((lengthLength > 0) && !HeaderUtilities.TryParseNonNegativeInt64(input.Substring(lengthStartIndex, lengthLength),
                 out length))
             {
                 return false;
diff --git a/src/Microsoft.Net.Http.Headers/HeaderUtilities.cs b/src/Microsoft.Net.Http.Headers/HeaderUtilities.cs
@@ -12,7 +12,7 @@ namespace Microsoft.Net.Http.Headers
 {
     public static class HeaderUtilities
     {
-        private static readonly int _int64MaxStringLength = 20;
+        private static readonly int _int64MaxStringLength = 19;
         private const string QualityName = "q";
         internal const string BytesUnit = "bytes";
 
@@ -269,7 +269,7 @@ public static bool TryParseSeconds(StringValues headerValues, string targetValue
                     var tokenLength = HttpRuleParser.GetTokenLength(headerValues[i], current);
                     if (tokenLength == targetValue.Length
                         && string.Compare(headerValues[i], current, targetValue, 0, tokenLength, StringComparison.OrdinalIgnoreCase) == 0
-                        && TryParseInt64FromHeaderValue(current + tokenLength, headerValues[i], out seconds))
+                        && TryParseNonNegativeInt64FromHeaderValue(current + tokenLength, headerValues[i], out seconds))
                     {
                         // Token matches target value and seconds were parsed
                         value = TimeSpan.FromSeconds(seconds);
@@ -342,7 +342,7 @@ public static bool ContainsCacheDirective(StringValues cacheControlDirectives, s
             return false;
         }
 
-        private static unsafe bool TryParseInt64FromHeaderValue(int startIndex, string headerValue, out long result)
+        private static unsafe bool TryParseNonNegativeInt64FromHeaderValue(int startIndex, string headerValue, out long result)
         {
             // Trim leading whitespace
             startIndex += HttpRuleParser.GetWhitespaceLength(headerValue, startIndex);
@@ -359,7 +359,7 @@ private static unsafe bool TryParseInt64FromHeaderValue(int startIndex, string h
             startIndex += HttpRuleParser.GetWhitespaceLength(headerValue, startIndex);
 
             // Try parse the number
-            if (TryParseInt64(new StringSegment(headerValue, startIndex, HttpRuleParser.GetNumberLength(headerValue, startIndex, false)), out result))
+            if (TryParseNonNegativeInt64(new StringSegment(headerValue, startIndex, HttpRuleParser.GetNumberLength(headerValue, startIndex, false)), out result))
             {
                 return true;
             }
@@ -368,9 +368,9 @@ private static unsafe bool TryParseInt64FromHeaderValue(int startIndex, string h
             return false;
         }
 
-        internal static bool TryParseInt32(string value, out int result)
+        internal static bool TryParseNonNegativeInt32(string value, out int result)
         {
-            return TryParseInt32(new StringSegment(value), out result);
+            return TryParseNonNegativeInt32(new StringSegment(value), out result);
         }
 
         /// <summary>
@@ -388,12 +388,12 @@ internal static bool TryParseInt32(string value, out int result)
         /// result will be overwritten.
         /// </param>
         /// <returns><code>true</code> if parsing succeeded; otherwise, <code>false</code>.</returns>
-        public static bool TryParseInt64(string value, out long result)
+        public static bool TryParseNonNegativeInt64(string value, out long result)
         {
-            return TryParseInt64(new StringSegment(value), out result);
+            return TryParseNonNegativeInt64(new StringSegment(value), out result);
         }
 
-        internal static unsafe bool TryParseInt32(StringSegment value, out int result)
+        internal static unsafe bool TryParseNonNegativeInt32(StringSegment value, out int result)
         {
             if (string.IsNullOrEmpty(value.Buffer) || value.Length == 0)
             {
@@ -444,7 +444,7 @@ internal static unsafe bool TryParseInt32(StringSegment value, out int result)
         /// originally supplied in result will be overwritten.
         /// </param>
         /// <returns><code>true</code> if parsing succeeded; otherwise, <code>false</code>.</returns>
-        public static unsafe bool TryParseInt64(StringSegment value, out long result)
+        public static unsafe bool TryParseNonNegativeInt64(StringSegment value, out long result)
         {
             if (string.IsNullOrEmpty(value.Buffer) || value.Length == 0)
             {
@@ -481,31 +481,22 @@ public static unsafe bool TryParseInt64(StringSegment value, out long result)
         }
 
         /// <summary>
-        /// Converts the signed 64-bit numeric value to its equivalent string representation.
+        /// Converts the non-negative 64-bit numeric value to its equivalent string representation.
         /// </summary>
         /// <param name="value">
         /// The number to convert.
         /// </param>
         /// <returns>
-        /// The string representation of the value of this instance, consisting of a minus sign if the value is
-        /// negative, and a sequence of digits ranging from 0 to 9 with no leading zeroes.
+        /// The string representation of the value of this instance, consisting of a sequence of digits ranging from 0 to 9 with no leading zeroes.
         /// </returns>
-        public unsafe static string FormatInt64(long value)
+        public unsafe static string FormatNonNegativeInt64(long value)
         {
-            var position = _int64MaxStringLength;
-            var negative = false;
-
             if (value < 0)
             {
-                // Not possible to compute absolute value of MinValue, return the exact string instead.
-                if (value == long.MinValue)
-                {
-                    return "-9223372036854775808";
-                }
-                negative = true;
-                value = -value;
+                throw new ArgumentOutOfRangeException(nameof(value), value, "The value to be formatted must be non-negative.");
             }
 
+            var position = _int64MaxStringLength;
             char* charBuffer = stackalloc char[_int64MaxStringLength];
 
             do
@@ -517,11 +508,6 @@ public unsafe static string FormatInt64(long value)
             }
             while (value != 0);
 
-            if (negative)
-            {
-                charBuffer[--position] = '-';
-            }
-
             return new string(charBuffer, position, _int64MaxStringLength - position);
         }
 
diff --git a/src/Microsoft.Net.Http.Headers/RangeItemHeaderValue.cs b/src/Microsoft.Net.Http.Headers/RangeItemHeaderValue.cs
@@ -202,14 +202,14 @@ internal static int GetRangeItemLength(string input, int startIndex, out RangeIt
 
             // Try convert first value to int64
             long from = 0;
-            if ((fromLength > 0) && !HeaderUtilities.TryParseInt64(input.Substring(fromStartIndex, fromLength), out from))
+            if ((fromLength > 0) && !HeaderUtilities.TryParseNonNegativeInt64(input.Substring(fromStartIndex, fromLength), out from))
             {
                 return 0;
             }
 
             // Try convert second value to int64
             long to = 0;
-            if ((toLength > 0) && !HeaderUtilities.TryParseInt64(input.Substring(toStartIndex, toLength), out to))
+            if ((toLength > 0) && !HeaderUtilities.TryParseNonNegativeInt64(input.Substring(toStartIndex, toLength), out to))
             {
                 return 0;
             }
diff --git a/src/Microsoft.Net.Http.Headers/SetCookieHeaderValue.cs b/src/Microsoft.Net.Http.Headers/SetCookieHeaderValue.cs
@@ -105,7 +105,7 @@ public override string ToString()
 
             if (MaxAge.HasValue)
             {
-                maxAge = HeaderUtilities.FormatInt64((long)MaxAge.Value.TotalSeconds);
+                maxAge = HeaderUtilities.FormatNonNegativeInt64((long)MaxAge.Value.TotalSeconds);
                 length += SeparatorToken.Length + MaxAgeToken.Length + EqualsToken.Length + maxAge.Length;
             }
 
@@ -200,7 +200,7 @@ public void AppendToStringBuilder(StringBuilder builder)
 
             if (MaxAge.HasValue)
             {
-                AppendSegment(builder, MaxAgeToken, HeaderUtilities.FormatInt64((long)MaxAge.Value.TotalSeconds));
+                AppendSegment(builder, MaxAgeToken, HeaderUtilities.FormatNonNegativeInt64((long)MaxAge.Value.TotalSeconds));
             }
 
             if (Domain != null)
@@ -365,7 +365,7 @@ private static int GetSetCookieLength(string input, int startIndex, out SetCooki
                     }
                     var numberString = input.Substring(offset, itemLength);
                     long maxAge;
-                    if (!HeaderUtilities.TryParseInt64(numberString, out maxAge))
+                    if (!HeaderUtilities.TryParseNonNegativeInt64(numberString, out maxAge))
                     {
                         // Invalid expiration date, abort
                         return 0;
diff --git a/test/Microsoft.Net.Http.Headers.Tests/HeaderUtilitiesTest.cs b/test/Microsoft.Net.Http.Headers.Tests/HeaderUtilitiesTest.cs
@@ -87,15 +87,20 @@ public void TryParseSeconds_Fails(string headerValues, string targetValue)
         [Theory]
         [InlineData(0)]
         [InlineData(1)]
-        [InlineData(-1)]
         [InlineData(1234567890)]
-        [InlineData(-1234567890)]
         [InlineData(long.MaxValue)]
+        public void FormatNonNegativeInt64_MatchesToString(long value)
+        {
+            Assert.Equal(value.ToString(CultureInfo.InvariantCulture), HeaderUtilities.FormatNonNegativeInt64(value));
+        }
+
+        [Theory]
+        [InlineData(-1)]
+        [InlineData(-1234567890)]
         [InlineData(long.MinValue)]
-        [InlineData(long.MinValue + 1)]
-        public void FormatInt64_MatchesToString(long value)
+        public void FormatNonNegativeInt64_Throws_ForNegativeValues(long value)
         {
-            Assert.Equal(value.ToString(CultureInfo.InvariantCulture), HeaderUtilities.FormatInt64(value));
+            Assert.Throws<ArgumentOutOfRangeException>(() => HeaderUtilities.FormatNonNegativeInt64(value));
         }
 
         [Theory]
@@ -150,20 +155,20 @@ public void ContainsCacheDirective_MatchesExactValue(string headerValues, string
         [InlineData("a")]
         [InlineData("1.1")]
         [InlineData("9223372036854775808")] // long.MaxValue + 1
-        public void TryParseInt64_Fails(string valueString)
+        public void TryParseNonNegativeInt64_Fails(string valueString)
         {
             long value = 1;
-            Assert.False(HeaderUtilities.TryParseInt64(valueString, out value));
+            Assert.False(HeaderUtilities.TryParseNonNegativeInt64(valueString, out value));
             Assert.Equal(0, value);
         }
 
         [Theory]
         [InlineData("0", 0)]
         [InlineData("9223372036854775807", 9223372036854775807)] // long.MaxValue
-        public void TryParseInt64_Succeeds(string valueString, long expected)
+        public void TryParseNonNegativeInt64_Succeeds(string valueString, long expected)
         {
             long value = 1;
-            Assert.True(HeaderUtilities.TryParseInt64(valueString, out value));
+            Assert.True(HeaderUtilities.TryParseNonNegativeInt64(valueString, out value));
             Assert.Equal(expected, value);
         }
 
@@ -175,20 +180,20 @@ public void TryParseInt64_Succeeds(string valueString, long expected)
         [InlineData("1.1")]
         [InlineData("1,000")]
         [InlineData("2147483648")] // int.MaxValue + 1
-        public void TryParseInt32_Fails(string valueString)
+        public void TryParseNonNegativeInt32_Fails(string valueString)
         {
             int value = 1;
-            Assert.False(HeaderUtilities.TryParseInt32(valueString, out value));
+            Assert.False(HeaderUtilities.TryParseNonNegativeInt32(valueString, out value));
             Assert.Equal(0, value);
         }
 
         [Theory]
         [InlineData("0", 0)]
         [InlineData("2147483647", 2147483647)] // int.MaxValue
-        public void TryParseInt32_Succeeds(string valueString, long expected)
+        public void TryParseNonNegativeInt32_Succeeds(string valueString, long expected)
         {
             int value = 1;
-            Assert.True(HeaderUtilities.TryParseInt32(valueString, out value));
+            Assert.True(HeaderUtilities.TryParseNonNegativeInt32(valueString, out value));
             Assert.Equal(expected, value);
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -101,7 +101,7 @@ public long? ContentLength`
`101`	`101`	`}`
`102`	`102`	`set`
`103`	`103`	`{`
`104`		`- Headers.Set(HeaderNames.ContentLength, value.HasValue ? HeaderUtilities.FormatInt64(value.Value) : null);`
	`104`	`+ Headers.Set(HeaderNames.ContentLength, value.HasValue ? HeaderUtilities.FormatNonNegativeInt64(value.Value) : null);`
`105`	`105`	`}`
`106`	`106`	`}`
`107`	`107`
Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ public long? ContentLength`
`54`	`54`	`}`
`55`	`55`	`set`
`56`	`56`	`{`
`57`		`- Headers.Set(HeaderNames.ContentLength, value.HasValue ? HeaderUtilities.FormatInt64(value.Value) : null);`
	`57`	`+ Headers.Set(HeaderNames.ContentLength, value.HasValue ? HeaderUtilities.FormatNonNegativeInt64(value.Value) : null);`
`58`	`58`	`}`
`59`	`59`	`}`
`60`	`60`
Original file line number	Diff line number	Diff line change
`@@ -106,7 +106,7 @@ public long? ContentLength`
`106`	`106`	`var rawValue = this[HeaderNames.ContentLength];`
`107`	`107`	`if (rawValue.Count == 1 &&`
`108`	`108`	`!string.IsNullOrWhiteSpace(rawValue[0]) &&`
`109`		`- HeaderUtilities.TryParseInt64(new StringSegment(rawValue[0]).Trim(), out value))`
	`109`	`+ HeaderUtilities.TryParseNonNegativeInt64(new StringSegment(rawValue[0]).Trim(), out value))`
`110`	`110`	`{`
`111`	`111`	`return value;`
`112`	`112`	`}`
`@@ -117,7 +117,7 @@ public long? ContentLength`
`117`	`117`	`{`
`118`	`118`	`if (value.HasValue)`
`119`	`119`	`{`
`120`		`- this[HeaderNames.ContentLength] = HeaderUtilities.FormatInt64(value.Value);`
	`120`	`+ this[HeaderNames.ContentLength] = HeaderUtilities.FormatNonNegativeInt64(value.Value);`
`121`	`121`	`}`
`122`	`122`	`else`
`123`	`123`	`{`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ public long? ContentLength`
`57`	`57`
`58`	`58`	`if (rawValue.Length == 1 &&`
`59`	`59`	`!string.IsNullOrWhiteSpace(rawValue[0]) &&`
`60`		`- HeaderUtilities.TryParseInt64(new StringSegment(rawValue[0]).Trim(), out value))`
	`60`	`+ HeaderUtilities.TryParseNonNegativeInt64(new StringSegment(rawValue[0]).Trim(), out value))`
`61`	`61`	`{`
`62`	`62`	`return value;`
`63`	`63`	`}`
`@@ -68,7 +68,7 @@ public long? ContentLength`
`68`	`68`	`{`
`69`	`69`	`if (value.HasValue)`
`70`	`70`	`{`
`71`		`- Inner[HeaderNames.ContentLength] = (StringValues)HeaderUtilities.FormatInt64(value.Value);`
	`71`	`+ Inner[HeaderNames.ContentLength] = (StringValues)HeaderUtilities.FormatNonNegativeInt64(value.Value);`
`72`	`72`	`}`
`73`	`73`	`else`
`74`	`74`	`{`
Original file line number	Diff line number	Diff line change
`@@ -610,7 +610,7 @@ private static bool TrySetTimeSpan(NameValueHeaderValue nameValue, ref TimeSpan?`
`610`	`610`	`}`
`611`	`611`
`612`	`612`	`int seconds;`
`613`		`- if (!HeaderUtilities.TryParseInt32(nameValue.Value, out seconds))`
	`613`	`+ if (!HeaderUtilities.TryParseNonNegativeInt32(nameValue.Value, out seconds))`
`614`	`614`	`{`
`615`	`615`	`return false;`
`616`	`616`	`}`
Original file line number	Diff line number	Diff line change
`@@ -108,7 +108,7 @@ public long? Size`
`108`	`108`	`if (sizeParameter != null)`
`109`	`109`	`{`
`110`	`110`	`var sizeString = sizeParameter.Value;`
`111`		`- if (HeaderUtilities.TryParseInt64(sizeString, out value))`
	`111`	`+ if (HeaderUtilities.TryParseNonNegativeInt64(sizeString, out value))`
`112`	`112`	`{`
`113`	`113`	`return value;`
`114`	`114`	`}`
Original file line number	Diff line number	Diff line change
`@@ -354,13 +354,13 @@ private static bool TryCreateContentRange(`
`354`	`354`	`parsedValue = null;`
`355`	`355`
`356`	`356`	`long from = 0;`
`357`		`- if ((fromLength > 0) && !HeaderUtilities.TryParseInt64(input.Substring(fromStartIndex, fromLength), out from))`
	`357`	`+ if ((fromLength > 0) && !HeaderUtilities.TryParseNonNegativeInt64(input.Substring(fromStartIndex, fromLength), out from))`
`358`	`358`	`{`
`359`	`359`	`return false;`
`360`	`360`	`}`
`361`	`361`
`362`	`362`	`long to = 0;`
`363`		`- if ((toLength > 0) && !HeaderUtilities.TryParseInt64(input.Substring(toStartIndex, toLength), out to))`
	`363`	`+ if ((toLength > 0) && !HeaderUtilities.TryParseNonNegativeInt64(input.Substring(toStartIndex, toLength), out to))`
`364`	`364`	`{`
`365`	`365`	`return false;`
`366`	`366`	`}`
`@@ -372,7 +372,7 @@ private static bool TryCreateContentRange(`
`372`	`372`	`}`
`373`	`373`
`374`	`374`	`long length = 0;`
`375`		`- if ((lengthLength > 0) && !HeaderUtilities.TryParseInt64(input.Substring(lengthStartIndex, lengthLength),`
	`375`	`+ if ((lengthLength > 0) && !HeaderUtilities.TryParseNonNegativeInt64(input.Substring(lengthStartIndex, lengthLength),`
`376`	`376`	`out length))`
`377`	`377`	`{`
`378`	`378`	`return false;`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ namespace Microsoft.Net.Http.Headers`
`12`	`12`	`{`
`13`	`13`	`public static class HeaderUtilities`
`14`	`14`	`{`
`15`		`- private static readonly int _int64MaxStringLength = 20;`
	`15`	`+ private static readonly int _int64MaxStringLength = 19;`
`16`	`16`	`private const string QualityName = "q";`
`17`	`17`	`internal const string BytesUnit = "bytes";`
`18`	`18`
`@@ -269,7 +269,7 @@ public static bool TryParseSeconds(StringValues headerValues, string targetValue`
`269`	`269`	`var tokenLength = HttpRuleParser.GetTokenLength(headerValues[i], current);`
`270`	`270`	`if (tokenLength == targetValue.Length`
`271`	`271`	`&& string.Compare(headerValues[i], current, targetValue, 0, tokenLength, StringComparison.OrdinalIgnoreCase) == 0`
`272`		`- && TryParseInt64FromHeaderValue(current + tokenLength, headerValues[i], out seconds))`
	`272`	`+ && TryParseNonNegativeInt64FromHeaderValue(current + tokenLength, headerValues[i], out seconds))`
`273`	`273`	`{`
`274`	`274`	`// Token matches target value and seconds were parsed`
`275`	`275`	`value = TimeSpan.FromSeconds(seconds);`
`@@ -342,7 +342,7 @@ public static bool ContainsCacheDirective(StringValues cacheControlDirectives, s`
`342`	`342`	`return false;`
`343`	`343`	`}`
`344`	`344`
`345`		`- private static unsafe bool TryParseInt64FromHeaderValue(int startIndex, string headerValue, out long result)`
	`345`	`+ private static unsafe bool TryParseNonNegativeInt64FromHeaderValue(int startIndex, string headerValue, out long result)`
`346`	`346`	`{`
`347`	`347`	`// Trim leading whitespace`
`348`	`348`	`startIndex += HttpRuleParser.GetWhitespaceLength(headerValue, startIndex);`
`@@ -359,7 +359,7 @@ private static unsafe bool TryParseInt64FromHeaderValue(int startIndex, string h`
`359`	`359`	`startIndex += HttpRuleParser.GetWhitespaceLength(headerValue, startIndex);`
`360`	`360`
`361`	`361`	`// Try parse the number`
`362`		`- if (TryParseInt64(new StringSegment(headerValue, startIndex, HttpRuleParser.GetNumberLength(headerValue, startIndex, false)), out result))`
	`362`	`+ if (TryParseNonNegativeInt64(new StringSegment(headerValue, startIndex, HttpRuleParser.GetNumberLength(headerValue, startIndex, false)), out result))`
`363`	`363`	`{`
`364`	`364`	`return true;`
`365`	`365`	`}`
`@@ -368,9 +368,9 @@ private static unsafe bool TryParseInt64FromHeaderValue(int startIndex, string h`
`368`	`368`	`return false;`
`369`	`369`	`}`
`370`	`370`
`371`		`- internal static bool TryParseInt32(string value, out int result)`
	`371`	`+ internal static bool TryParseNonNegativeInt32(string value, out int result)`
`372`	`372`	`{`
`373`		`- return TryParseInt32(new StringSegment(value), out result);`
	`373`	`+ return TryParseNonNegativeInt32(new StringSegment(value), out result);`
`374`	`374`	`}`
`375`	`375`
`376`	`376`	`/// <summary>`
`@@ -388,12 +388,12 @@ internal static bool TryParseInt32(string value, out int result)`
`388`	`388`	`/// result will be overwritten.`
`389`	`389`	`/// </param>`
`390`	`390`	`/// <returns><code>true</code> if parsing succeeded; otherwise, <code>false</code>.</returns>`
`391`		`- public static bool TryParseInt64(string value, out long result)`
	`391`	`+ public static bool TryParseNonNegativeInt64(string value, out long result)`
`392`	`392`	`{`
`393`		`- return TryParseInt64(new StringSegment(value), out result);`
	`393`	`+ return TryParseNonNegativeInt64(new StringSegment(value), out result);`
`394`	`394`	`}`
`395`	`395`
`396`		`- internal static unsafe bool TryParseInt32(StringSegment value, out int result)`
	`396`	`+ internal static unsafe bool TryParseNonNegativeInt32(StringSegment value, out int result)`
`397`	`397`	`{`
`398`	`398`	`if (string.IsNullOrEmpty(value.Buffer) \|\| value.Length == 0)`
`399`	`399`	`{`
`@@ -444,7 +444,7 @@ internal static unsafe bool TryParseInt32(StringSegment value, out int result)`
`444`	`444`	`/// originally supplied in result will be overwritten.`
`445`	`445`	`/// </param>`
`446`	`446`	`/// <returns><code>true</code> if parsing succeeded; otherwise, <code>false</code>.</returns>`
`447`		`- public static unsafe bool TryParseInt64(StringSegment value, out long result)`
	`447`	`+ public static unsafe bool TryParseNonNegativeInt64(StringSegment value, out long result)`
`448`	`448`	`{`
`449`	`449`	`if (string.IsNullOrEmpty(value.Buffer) \|\| value.Length == 0)`
`450`	`450`	`{`
`@@ -481,31 +481,22 @@ public static unsafe bool TryParseInt64(StringSegment value, out long result)`
`481`	`481`	`}`
`482`	`482`
`483`	`483`	`/// <summary>`
`484`		`- /// Converts the signed 64-bit numeric value to its equivalent string representation.`
	`484`	`+ /// Converts the non-negative 64-bit numeric value to its equivalent string representation.`
`485`	`485`	`/// </summary>`
`486`	`486`	`/// <param name="value">`
`487`	`487`	`/// The number to convert.`
`488`	`488`	`/// </param>`
`489`	`489`	`/// <returns>`
`490`		`- /// The string representation of the value of this instance, consisting of a minus sign if the value is`
`491`		`- /// negative, and a sequence of digits ranging from 0 to 9 with no leading zeroes.`
	`490`	`+ /// The string representation of the value of this instance, consisting of a sequence of digits ranging from 0 to 9 with no leading zeroes.`
`492`	`491`	`/// </returns>`
`493`		`- public unsafe static string FormatInt64(long value)`
	`492`	`+ public unsafe static string FormatNonNegativeInt64(long value)`
`494`	`493`	`{`
`495`		`- var position = _int64MaxStringLength;`
`496`		`- var negative = false;`
`497`		`-`
`498`	`494`	`if (value < 0)`
`499`	`495`	`{`
`500`		`- // Not possible to compute absolute value of MinValue, return the exact string instead.`
`501`		`- if (value == long.MinValue)`
`502`		`- {`
`503`		`- return "-9223372036854775808";`
`504`		`- }`
`505`		`- negative = true;`
`506`		`- value = -value;`
	`496`	`+ throw new ArgumentOutOfRangeException(nameof(value), value, "The value to be formatted must be non-negative.");`
`507`	`497`	`}`
`508`	`498`
	`499`	`+ var position = _int64MaxStringLength;`
`509`	`500`	`char* charBuffer = stackalloc char[_int64MaxStringLength];`
`510`	`501`
`511`	`502`	`do`
`@@ -517,11 +508,6 @@ public unsafe static string FormatInt64(long value)`
`517`	`508`	`}`
`518`	`509`	`while (value != 0);`
`519`	`510`
`520`		`- if (negative)`
`521`		`- {`
`522`		`- charBuffer[--position] = '-';`
`523`		`- }`
`524`		`-`
`525`	`511`	`return new string(charBuffer, position, _int64MaxStringLength - position);`
`526`	`512`	`}`
`527`	`513`
Original file line number	Diff line number	Diff line change
`@@ -202,14 +202,14 @@ internal static int GetRangeItemLength(string input, int startIndex, out RangeIt`
`202`	`202`
`203`	`203`	`// Try convert first value to int64`
`204`	`204`	`long from = 0;`
`205`		`- if ((fromLength > 0) && !HeaderUtilities.TryParseInt64(input.Substring(fromStartIndex, fromLength), out from))`
	`205`	`+ if ((fromLength > 0) && !HeaderUtilities.TryParseNonNegativeInt64(input.Substring(fromStartIndex, fromLength), out from))`
`206`	`206`	`{`
`207`	`207`	`return 0;`
`208`	`208`	`}`
`209`	`209`
`210`	`210`	`// Try convert second value to int64`
`211`	`211`	`long to = 0;`
`212`		`- if ((toLength > 0) && !HeaderUtilities.TryParseInt64(input.Substring(toStartIndex, toLength), out to))`
	`212`	`+ if ((toLength > 0) && !HeaderUtilities.TryParseNonNegativeInt64(input.Substring(toStartIndex, toLength), out to))`
`213`	`213`	`{`
`214`	`214`	`return 0;`
`215`	`215`	`}`
Original file line number	Diff line number	Diff line change
`@@ -105,7 +105,7 @@ public override string ToString()`
`105`	`105`
`106`	`106`	`if (MaxAge.HasValue)`
`107`	`107`	`{`
`108`		`- maxAge = HeaderUtilities.FormatInt64((long)MaxAge.Value.TotalSeconds);`
	`108`	`+ maxAge = HeaderUtilities.FormatNonNegativeInt64((long)MaxAge.Value.TotalSeconds);`
`109`	`109`	`length += SeparatorToken.Length + MaxAgeToken.Length + EqualsToken.Length + maxAge.Length;`
`110`	`110`	`}`
`111`	`111`
`@@ -200,7 +200,7 @@ public void AppendToStringBuilder(StringBuilder builder)`
`200`	`200`
`201`	`201`	`if (MaxAge.HasValue)`
`202`	`202`	`{`
`203`		`- AppendSegment(builder, MaxAgeToken, HeaderUtilities.FormatInt64((long)MaxAge.Value.TotalSeconds));`
	`203`	`+ AppendSegment(builder, MaxAgeToken, HeaderUtilities.FormatNonNegativeInt64((long)MaxAge.Value.TotalSeconds));`
`204`	`204`	`}`
`205`	`205`
`206`	`206`	`if (Domain != null)`
`@@ -365,7 +365,7 @@ private static int GetSetCookieLength(string input, int startIndex, out SetCooki`
`365`	`365`	`}`
`366`	`366`	`var numberString = input.Substring(offset, itemLength);`
`367`	`367`	`long maxAge;`
`368`		`- if (!HeaderUtilities.TryParseInt64(numberString, out maxAge))`
	`368`	`+ if (!HeaderUtilities.TryParseNonNegativeInt64(numberString, out maxAge))`
`369`	`369`	`{`
`370`	`370`	`// Invalid expiration date, abort`
`371`	`371`	`return 0;`