diff --git a/src/libraries/System.Private.CoreLib/src/System/Double.cs b/src/libraries/System.Private.CoreLib/src/System/Double.cs index 6fde5409e2addf..f087481dffa7cb 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Double.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Double.cs @@ -1241,7 +1241,7 @@ static double IParseable.Parse(string s, IFormatProvider? provider) [RequiresPreviewFeatures] static bool IParseable.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, out double result) - => TryParse(s, NumberStyles.Integer, provider, out result); + => TryParse(s, NumberStyles.Float | NumberStyles.AllowThousands, provider, out result); // // ISignedNumber @@ -1256,11 +1256,11 @@ static bool IParseable.TryParse([NotNullWhen(true)] string? s, IFormatPr [RequiresPreviewFeatures] static double ISpanParseable.Parse(ReadOnlySpan s, IFormatProvider? provider) - => Parse(s, NumberStyles.Integer, provider); + => Parse(s, NumberStyles.Float | NumberStyles.AllowThousands, provider); [RequiresPreviewFeatures] static bool ISpanParseable.TryParse(ReadOnlySpan s, IFormatProvider? provider, out double result) - => TryParse(s, NumberStyles.Integer, provider, out result); + => TryParse(s, NumberStyles.Float | NumberStyles.AllowThousands, provider, out result); // // ISubtractionOperators diff --git a/src/libraries/System.Private.CoreLib/src/System/Half.cs b/src/libraries/System.Private.CoreLib/src/System/Half.cs index c8791e1b8d9ac6..ccee67bae0f1d0 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Half.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Half.cs @@ -241,7 +241,7 @@ public static bool IsSubnormal(Half value) public static Half Parse(string s) { if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s); - return Number.ParseHalf(s, NumberStyles.Float | NumberStyles.AllowThousands, NumberFormatInfo.CurrentInfo); + return Number.ParseHalf(s, DefaultParseStyle, NumberFormatInfo.CurrentInfo); } /// @@ -266,7 +266,7 @@ public static Half Parse(string s, NumberStyles style) public static Half Parse(string s, IFormatProvider? provider) { if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s); - return Number.ParseHalf(s, NumberStyles.Float | NumberStyles.AllowThousands, NumberFormatInfo.GetInstance(provider)); + return Number.ParseHalf(s, DefaultParseStyle, NumberFormatInfo.GetInstance(provider)); } /// @@ -1554,7 +1554,7 @@ static Half IParseable.Parse(string s, IFormatProvider? provider) [RequiresPreviewFeatures] static bool IParseable.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, out Half result) - => TryParse(s, NumberStyles.Integer, provider, out result); + => TryParse(s, DefaultParseStyle, provider, out result); // // ISignedNumber @@ -1569,11 +1569,11 @@ static bool IParseable.TryParse([NotNullWhen(true)] string? s, IFormatProv [RequiresPreviewFeatures] static Half ISpanParseable.Parse(ReadOnlySpan s, IFormatProvider? provider) - => Parse(s, NumberStyles.Integer, provider); + => Parse(s, DefaultParseStyle, provider); [RequiresPreviewFeatures] static bool ISpanParseable.TryParse(ReadOnlySpan s, IFormatProvider? provider, out Half result) - => TryParse(s, NumberStyles.Integer, provider, out result); + => TryParse(s, DefaultParseStyle, provider, out result); // // ISubtractionOperators diff --git a/src/libraries/System.Private.CoreLib/src/System/Single.cs b/src/libraries/System.Private.CoreLib/src/System/Single.cs index 26ea34a6d70fb3..456209b4dc3d67 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Single.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Single.cs @@ -1233,7 +1233,7 @@ static float IParseable.Parse(string s, IFormatProvider? provider) [RequiresPreviewFeatures] static bool IParseable.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, out float result) - => TryParse(s, NumberStyles.Integer, provider, out result); + => TryParse(s, NumberStyles.Float | NumberStyles.AllowThousands, provider, out result); // // ISignedNumber @@ -1248,11 +1248,11 @@ static bool IParseable.TryParse([NotNullWhen(true)] string? s, IFormatPro [RequiresPreviewFeatures] static float ISpanParseable.Parse(ReadOnlySpan s, IFormatProvider? provider) - => Parse(s, NumberStyles.Integer, provider); + => Parse(s, NumberStyles.Float | NumberStyles.AllowThousands, provider); [RequiresPreviewFeatures] static bool ISpanParseable.TryParse(ReadOnlySpan s, IFormatProvider? provider, out float result) - => TryParse(s, NumberStyles.Integer, provider, out result); + => TryParse(s, NumberStyles.Float | NumberStyles.AllowThousands, provider, out result); // // ISubtractionOperators diff --git a/src/libraries/System.Runtime.Experimental/tests/System.Runtime.Experimental.Tests.csproj b/src/libraries/System.Runtime.Experimental/tests/System.Runtime.Experimental.Tests.csproj index 0001351ba031ab..d8ed841331b0f3 100644 --- a/src/libraries/System.Runtime.Experimental/tests/System.Runtime.Experimental.Tests.csproj +++ b/src/libraries/System.Runtime.Experimental/tests/System.Runtime.Experimental.Tests.csproj @@ -16,11 +16,14 @@ + + + @@ -29,18 +32,22 @@ + + + + diff --git a/src/libraries/System.Runtime/tests/System.Runtime.Tests.csproj b/src/libraries/System.Runtime/tests/System.Runtime.Tests.csproj index 6d888e344bc80e..913da87c5b2845 100644 --- a/src/libraries/System.Runtime/tests/System.Runtime.Tests.csproj +++ b/src/libraries/System.Runtime/tests/System.Runtime.Tests.csproj @@ -14,32 +14,19 @@ $(DefineConstants);FEATURE_GENERIC_MATH - - - - - - - - - - - - - + + + + + + + + + + + + + @@ -248,8 +235,7 @@ - + @@ -257,12 +243,15 @@ + + + @@ -283,31 +272,27 @@ - + - + - + System.Reflection.Tests.EmbeddedImage.png System.Reflection.Tests.EmbeddedTextFile.txt - + - + diff --git a/src/libraries/System.Runtime/tests/System/DoubleTests.GenericMath.cs b/src/libraries/System.Runtime/tests/System/DoubleTests.GenericMath.cs new file mode 100644 index 00000000000000..60a20053823ec2 --- /dev/null +++ b/src/libraries/System.Runtime/tests/System/DoubleTests.GenericMath.cs @@ -0,0 +1,127 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Globalization; +using System.Runtime.Versioning; +using Xunit; + +namespace System.Tests +{ + [ActiveIssue("https://github.com/dotnet/runtime/issues/54910", typeof(PlatformDetection), nameof(PlatformDetection.IsBrowser), nameof(PlatformDetection.IsMonoAOT))] + [RequiresPreviewFeaturesAttribute] + public class DoubleTests_GenericMath + { + [Theory] + [MemberData(nameof(DoubleTests.Parse_Valid_TestData), MemberType = typeof(DoubleTests))] + public static void ParseValidStringTest(string value, NumberStyles style, IFormatProvider provider, double expected) + { + bool isDefaultProvider = provider == null || provider == NumberFormatInfo.CurrentInfo; + double result; + if ((style & ~(NumberStyles.Float | NumberStyles.AllowThousands)) == 0 && style != NumberStyles.None) + { + // Use Parse(string) or Parse(string, IFormatProvider) + if (isDefaultProvider) + { + Assert.True(NumberHelper.TryParse(value, null, out result)); + Assert.Equal(expected, result); + + Assert.Equal(expected, NumberHelper.Parse(value, null)); + } + + Assert.Equal(expected, NumberHelper.Parse(value, provider)); + } + + // Use Parse(string, NumberStyles, IFormatProvider) + Assert.True(NumberHelper.TryParse(value, style, provider, out result)); + Assert.Equal(expected, result); + + Assert.Equal(expected, NumberHelper.Parse(value, style, provider)); + + if (isDefaultProvider) + { + // Use Parse(string, NumberStyles) or Parse(string, NumberStyles, IFormatProvider) + Assert.True(NumberHelper.TryParse(value, style, NumberFormatInfo.CurrentInfo, out result)); + Assert.Equal(expected, result); + + Assert.Equal(expected, NumberHelper.Parse(value, style, null)); + Assert.Equal(expected, NumberHelper.Parse(value, style, NumberFormatInfo.CurrentInfo)); + } + } + + [Theory] + [MemberData(nameof(DoubleTests.Parse_Invalid_TestData), MemberType = typeof(DoubleTests))] + public static void ParseInvalidStringTest(string value, NumberStyles style, IFormatProvider provider, Type exceptionType) + { + bool isDefaultProvider = provider == null || provider == NumberFormatInfo.CurrentInfo; + double result; + if ((style & ~(NumberStyles.Float | NumberStyles.AllowThousands)) == 0 && style != NumberStyles.None && (style & NumberStyles.AllowLeadingWhite) == (style & NumberStyles.AllowTrailingWhite)) + { + // Use Parse(string) or Parse(string, IFormatProvider) + if (isDefaultProvider) + { + Assert.False(NumberHelper.TryParse(value, null, out result)); + Assert.Equal(default(double), result); + + Assert.Throws(exceptionType, () => NumberHelper.Parse(value, null)); + } + + Assert.Throws(exceptionType, () => NumberHelper.Parse(value, provider)); + } + + // Use Parse(string, NumberStyles, IFormatProvider) + Assert.False(NumberHelper.TryParse(value, style, provider, out result)); + Assert.Equal(default(double), result); + + Assert.Throws(exceptionType, () => NumberHelper.Parse(value, style, provider)); + + if (isDefaultProvider) + { + // Use Parse(string, NumberStyles) or Parse(string, NumberStyles, IFormatProvider) + Assert.False(NumberHelper.TryParse(value, style, NumberFormatInfo.CurrentInfo, out result)); + Assert.Equal(default(double), result); + + Assert.Throws(exceptionType, () => NumberHelper.Parse(value, style, null)); + Assert.Throws(exceptionType, () => NumberHelper.Parse(value, style, NumberFormatInfo.CurrentInfo)); + } + } + + [Theory] + [MemberData(nameof(DoubleTests.Parse_ValidWithOffsetCount_TestData), MemberType = typeof(DoubleTests))] + public static void ParseValidSpanTest(string value, int offset, int count, NumberStyles style, IFormatProvider provider, double expected) + { + bool isDefaultProvider = provider == null || provider == NumberFormatInfo.CurrentInfo; + double result; + if ((style & ~(NumberStyles.Float | NumberStyles.AllowThousands)) == 0 && style != NumberStyles.None) + { + // Use Parse(string) or Parse(string, IFormatProvider) + if (isDefaultProvider) + { + Assert.True(NumberHelper.TryParse(value.AsSpan(offset, count), null, out result)); + Assert.Equal(expected, result); + + Assert.Equal(expected, NumberHelper.Parse(value.AsSpan(offset, count), null)); + } + + Assert.Equal(expected, NumberHelper.Parse(value.AsSpan(offset, count), provider: provider)); + } + + Assert.Equal(expected, NumberHelper.Parse(value.AsSpan(offset, count), style, provider)); + + Assert.True(NumberHelper.TryParse(value.AsSpan(offset, count), style, provider, out result)); + Assert.Equal(expected, result); + } + + [Theory] + [MemberData(nameof(DoubleTests.Parse_Invalid_TestData), MemberType = typeof(DoubleTests))] + public static void ParseInvalidSpanTest(string value, NumberStyles style, IFormatProvider provider, Type exceptionType) + { + if (value != null) + { + Assert.Throws(exceptionType, () => NumberHelper.Parse(value.AsSpan(), style, provider)); + + Assert.False(NumberHelper.TryParse(value.AsSpan(), style, provider, out double result)); + Assert.Equal(0, result); + } + } + } +} diff --git a/src/libraries/System.Runtime/tests/System/GenericMathHelpers.cs b/src/libraries/System.Runtime/tests/System/GenericMathHelpers.cs index 2895dd8841962e..e1d4659db229be 100644 --- a/src/libraries/System.Runtime/tests/System/GenericMathHelpers.cs +++ b/src/libraries/System.Runtime/tests/System/GenericMathHelpers.cs @@ -157,8 +157,12 @@ public static TSelf CreateTruncating(TOther value) public static TSelf Min(TSelf x, TSelf y) => TSelf.Min(x, y); + public static TSelf Parse(string s, IFormatProvider provider) => TSelf.Parse(s, provider); + public static TSelf Parse(string s, NumberStyles style, IFormatProvider provider) => TSelf.Parse(s, style, provider); + public static TSelf Parse(ReadOnlySpan s, IFormatProvider provider) => TSelf.Parse(s, provider); + public static TSelf Parse(ReadOnlySpan s, NumberStyles style, IFormatProvider provider) => TSelf.Parse(s, style, provider); public static TSelf Sign(TSelf value) => TSelf.Sign(value); @@ -166,8 +170,12 @@ public static TSelf CreateTruncating(TOther value) public static bool TryCreate(TOther value, out TSelf result) where TOther : INumber => TSelf.TryCreate(value, out result); + public static bool TryParse(string s, IFormatProvider provider, out TSelf result) => TSelf.TryParse(s, provider, out result); + public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out TSelf result) => TSelf.TryParse(s, style, provider, out result); + public static bool TryParse(ReadOnlySpan s, IFormatProvider provider, out TSelf result) => TSelf.TryParse(s, provider, out result); + public static bool TryParse(ReadOnlySpan s, NumberStyles style, IFormatProvider provider, out TSelf result) => TSelf.TryParse(s, style, provider, out result); } diff --git a/src/libraries/System.Runtime/tests/System/HalfTests.GenericMath.cs b/src/libraries/System.Runtime/tests/System/HalfTests.GenericMath.cs new file mode 100644 index 00000000000000..c9fe77c9154a98 --- /dev/null +++ b/src/libraries/System.Runtime/tests/System/HalfTests.GenericMath.cs @@ -0,0 +1,127 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Globalization; +using System.Runtime.Versioning; +using Xunit; + +namespace System.Tests +{ + [ActiveIssue("https://github.com/dotnet/runtime/issues/54910", typeof(PlatformDetection), nameof(PlatformDetection.IsBrowser), nameof(PlatformDetection.IsMonoAOT))] + [RequiresPreviewFeaturesAttribute] + public class HalfTests_GenericMath + { + [Theory] + [MemberData(nameof(HalfTests.Parse_Valid_TestData), MemberType = typeof(HalfTests))] + public static void ParseValidStringTest(string value, NumberStyles style, IFormatProvider provider, Half expected) + { + bool isDefaultProvider = provider == null || provider == NumberFormatInfo.CurrentInfo; + Half result; + if ((style & ~(NumberStyles.Float | NumberStyles.AllowThousands)) == 0 && style != NumberStyles.None) + { + // Use Parse(string) or Parse(string, IFormatProvider) + if (isDefaultProvider) + { + Assert.True(NumberHelper.TryParse(value, null, out result)); + Assert.Equal(expected, result); + + Assert.Equal(expected, NumberHelper.Parse(value, null)); + } + + Assert.Equal(expected, NumberHelper.Parse(value, provider)); + } + + // Use Parse(string, NumberStyles, IFormatProvider) + Assert.True(NumberHelper.TryParse(value, style, provider, out result)); + Assert.Equal(expected, result); + + Assert.Equal(expected, NumberHelper.Parse(value, style, provider)); + + if (isDefaultProvider) + { + // Use Parse(string, NumberStyles) or Parse(string, NumberStyles, IFormatProvider) + Assert.True(NumberHelper.TryParse(value, style, NumberFormatInfo.CurrentInfo, out result)); + Assert.Equal(expected, result); + + Assert.Equal(expected, NumberHelper.Parse(value, style, null)); + Assert.Equal(expected, NumberHelper.Parse(value, style, NumberFormatInfo.CurrentInfo)); + } + } + + [Theory] + [MemberData(nameof(HalfTests.Parse_Invalid_TestData), MemberType = typeof(HalfTests))] + public static void ParseInvalidStringTest(string value, NumberStyles style, IFormatProvider provider, Type exceptionType) + { + bool isDefaultProvider = provider == null || provider == NumberFormatInfo.CurrentInfo; + Half result; + if ((style & ~(NumberStyles.Float | NumberStyles.AllowThousands)) == 0 && style != NumberStyles.None && (style & NumberStyles.AllowLeadingWhite) == (style & NumberStyles.AllowTrailingWhite)) + { + // Use Parse(string) or Parse(string, IFormatProvider) + if (isDefaultProvider) + { + Assert.False(NumberHelper.TryParse(value, null, out result)); + Assert.Equal(default(Half), result); + + Assert.Throws(exceptionType, () => NumberHelper.Parse(value, null)); + } + + Assert.Throws(exceptionType, () => NumberHelper.Parse(value, provider)); + } + + // Use Parse(string, NumberStyles, IFormatProvider) + Assert.False(NumberHelper.TryParse(value, style, provider, out result)); + Assert.Equal(default(Half), result); + + Assert.Throws(exceptionType, () => NumberHelper.Parse(value, style, provider)); + + if (isDefaultProvider) + { + // Use Parse(string, NumberStyles) or Parse(string, NumberStyles, IFormatProvider) + Assert.False(NumberHelper.TryParse(value, style, NumberFormatInfo.CurrentInfo, out result)); + Assert.Equal(default(Half), result); + + Assert.Throws(exceptionType, () => NumberHelper.Parse(value, style, null)); + Assert.Throws(exceptionType, () => NumberHelper.Parse(value, style, NumberFormatInfo.CurrentInfo)); + } + } + + [Theory] + [MemberData(nameof(HalfTests.Parse_ValidWithOffsetCount_TestData), MemberType = typeof(HalfTests))] + public static void ParseValidSpanTest(string value, int offset, int count, NumberStyles style, IFormatProvider provider, Half expected) + { + bool isDefaultProvider = provider == null || provider == NumberFormatInfo.CurrentInfo; + Half result; + if ((style & ~(NumberStyles.Float | NumberStyles.AllowThousands)) == 0 && style != NumberStyles.None) + { + // Use Parse(string) or Parse(string, IFormatProvider) + if (isDefaultProvider) + { + Assert.True(NumberHelper.TryParse(value.AsSpan(offset, count), null, out result)); + Assert.Equal(expected, result); + + Assert.Equal(expected, NumberHelper.Parse(value.AsSpan(offset, count), null)); + } + + Assert.Equal(expected, NumberHelper.Parse(value.AsSpan(offset, count), provider: provider)); + } + + Assert.Equal(expected, NumberHelper.Parse(value.AsSpan(offset, count), style, provider)); + + Assert.True(NumberHelper.TryParse(value.AsSpan(offset, count), style, provider, out result)); + Assert.Equal(expected, result); + } + + [Theory] + [MemberData(nameof(HalfTests.Parse_Invalid_TestData), MemberType = typeof(HalfTests))] + public static void ParseInvalidSpanTest(string value, NumberStyles style, IFormatProvider provider, Type exceptionType) + { + if (value != null) + { + Assert.Throws(exceptionType, () => NumberHelper.Parse(value.AsSpan(), style, provider)); + + Assert.False(NumberHelper.TryParse(value.AsSpan(), style, provider, out Half result)); + Assert.Equal((Half)0, result); + } + } + } +} diff --git a/src/libraries/System.Runtime/tests/System/SingleTests.GenericMath.cs b/src/libraries/System.Runtime/tests/System/SingleTests.GenericMath.cs new file mode 100644 index 00000000000000..8e7c3e8a1c6908 --- /dev/null +++ b/src/libraries/System.Runtime/tests/System/SingleTests.GenericMath.cs @@ -0,0 +1,127 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Globalization; +using System.Runtime.Versioning; +using Xunit; + +namespace System.Tests +{ + [ActiveIssue("https://github.com/dotnet/runtime/issues/54910", typeof(PlatformDetection), nameof(PlatformDetection.IsBrowser), nameof(PlatformDetection.IsMonoAOT))] + [RequiresPreviewFeaturesAttribute] + public class SingleTests_GenericMath + { + [Theory] + [MemberData(nameof(SingleTests.Parse_Valid_TestData), MemberType = typeof(SingleTests))] + public static void ParseValidStringTest(string value, NumberStyles style, IFormatProvider provider, float expected) + { + bool isDefaultProvider = provider == null || provider == NumberFormatInfo.CurrentInfo; + float result; + if ((style & ~(NumberStyles.Float | NumberStyles.AllowThousands)) == 0 && style != NumberStyles.None) + { + // Use Parse(string) or Parse(string, IFormatProvider) + if (isDefaultProvider) + { + Assert.True(NumberHelper.TryParse(value, null, out result)); + Assert.Equal(expected, result); + + Assert.Equal(expected, NumberHelper.Parse(value, null)); + } + + Assert.Equal(expected, NumberHelper.Parse(value, provider)); + } + + // Use Parse(string, NumberStyles, IFormatProvider) + Assert.True(NumberHelper.TryParse(value, style, provider, out result)); + Assert.Equal(expected, result); + + Assert.Equal(expected, NumberHelper.Parse(value, style, provider)); + + if (isDefaultProvider) + { + // Use Parse(string, NumberStyles) or Parse(string, NumberStyles, IFormatProvider) + Assert.True(NumberHelper.TryParse(value, style, NumberFormatInfo.CurrentInfo, out result)); + Assert.Equal(expected, result); + + Assert.Equal(expected, NumberHelper.Parse(value, style, null)); + Assert.Equal(expected, NumberHelper.Parse(value, style, NumberFormatInfo.CurrentInfo)); + } + } + + [Theory] + [MemberData(nameof(SingleTests.Parse_Invalid_TestData), MemberType = typeof(SingleTests))] + public static void ParseInvalidStringTest(string value, NumberStyles style, IFormatProvider provider, Type exceptionType) + { + bool isDefaultProvider = provider == null || provider == NumberFormatInfo.CurrentInfo; + float result; + if ((style & ~(NumberStyles.Float | NumberStyles.AllowThousands)) == 0 && style != NumberStyles.None && (style & NumberStyles.AllowLeadingWhite) == (style & NumberStyles.AllowTrailingWhite)) + { + // Use Parse(string) or Parse(string, IFormatProvider) + if (isDefaultProvider) + { + Assert.False(NumberHelper.TryParse(value, null, out result)); + Assert.Equal(default(float), result); + + Assert.Throws(exceptionType, () => NumberHelper.Parse(value, null)); + } + + Assert.Throws(exceptionType, () => NumberHelper.Parse(value, provider)); + } + + // Use Parse(string, NumberStyles, IFormatProvider) + Assert.False(NumberHelper.TryParse(value, style, provider, out result)); + Assert.Equal(default(float), result); + + Assert.Throws(exceptionType, () => NumberHelper.Parse(value, style, provider)); + + if (isDefaultProvider) + { + // Use Parse(string, NumberStyles) or Parse(string, NumberStyles, IFormatProvider) + Assert.False(NumberHelper.TryParse(value, style, NumberFormatInfo.CurrentInfo, out result)); + Assert.Equal(default(float), result); + + Assert.Throws(exceptionType, () => NumberHelper.Parse(value, style, null)); + Assert.Throws(exceptionType, () => NumberHelper.Parse(value, style, NumberFormatInfo.CurrentInfo)); + } + } + + [Theory] + [MemberData(nameof(SingleTests.Parse_ValidWithOffsetCount_TestData), MemberType = typeof(SingleTests))] + public static void ParseValidSpanTest(string value, int offset, int count, NumberStyles style, IFormatProvider provider, float expected) + { + bool isDefaultProvider = provider == null || provider == NumberFormatInfo.CurrentInfo; + float result; + if ((style & ~(NumberStyles.Float | NumberStyles.AllowThousands)) == 0 && style != NumberStyles.None) + { + // Use Parse(string) or Parse(string, IFormatProvider) + if (isDefaultProvider) + { + Assert.True(NumberHelper.TryParse(value.AsSpan(offset, count), null, out result)); + Assert.Equal(expected, result); + + Assert.Equal(expected, NumberHelper.Parse(value.AsSpan(offset, count), null)); + } + + Assert.Equal(expected, NumberHelper.Parse(value.AsSpan(offset, count), provider: provider)); + } + + Assert.Equal(expected, NumberHelper.Parse(value.AsSpan(offset, count), style, provider)); + + Assert.True(NumberHelper.TryParse(value.AsSpan(offset, count), style, provider, out result)); + Assert.Equal(expected, result); + } + + [Theory] + [MemberData(nameof(SingleTests.Parse_Invalid_TestData), MemberType = typeof(SingleTests))] + public static void ParseInvalidSpanTest(string value, NumberStyles style, IFormatProvider provider, Type exceptionType) + { + if (value != null) + { + Assert.Throws(exceptionType, () => NumberHelper.Parse(value.AsSpan(), style, provider)); + + Assert.False(NumberHelper.TryParse(value.AsSpan(), style, provider, out float result)); + Assert.Equal(0, result); + } + } + } +}