Reject hex and binary NumberStyles in Parse and TryParse [patch]

PreciseNumber.Test/PreciseNumberParseCultureTests.cs

@@ -3,6 +3,7 @@
 namespace ktsu.PreciseNumber.Test;
 
 using System.Globalization;
+using System.Numerics;
 
 [TestClass]
 public class PreciseNumberParseCultureTests
@@ -135,6 +136,27 @@ public void Parse_ThrowsForWhatTheStyleDoesNotAllow()
 		Assert.ThrowsExactly<FormatException>(() => PreciseNumber.Parse("1e 5", NumberStyles.Float, CultureInfo.InvariantCulture));
 	}
 
+	[TestMethod]
+	[DataRow("10", NumberStyles.HexNumber)]
+	[DataRow("A", NumberStyles.HexNumber)]
+	[DataRow("10", NumberStyles.AllowHexSpecifier)]
+	[DataRow("1010", NumberStyles.BinaryNumber)]
+	[DataRow("1010", NumberStyles.AllowBinarySpecifier)]
+	public void ParseAndTryParse_RejectHexAndBinaryStylesAsDecimalDoes(string text, NumberStyles style)
+	{
+		Assert.ThrowsExactly<ArgumentException>(() => decimal.Parse(text, style, CultureInfo.InvariantCulture));
+
+		Assert.ThrowsExactly<ArgumentException>(() => PreciseNumber.Parse(text, style, CultureInfo.InvariantCulture));
+		Assert.ThrowsExactly<ArgumentException>(() => PreciseNumber.Parse(text.AsSpan(), style, CultureInfo.InvariantCulture));
+		Assert.ThrowsExactly<ArgumentException>(() => PreciseNumber.TryParse(text, style, CultureInfo.InvariantCulture, out _));
+		Assert.ThrowsExactly<ArgumentException>(() => PreciseNumber.TryParse(text.AsSpan(), style, CultureInfo.InvariantCulture, out _));
+		Assert.ThrowsExactly<ArgumentException>(() => ParseGeneric<PreciseNumber>(text, style));
+	}
+
+	private static T ParseGeneric<T>(string text, NumberStyles style)
+		where T : INumberBase<T> =>
+		T.Parse(text, style, CultureInfo.InvariantCulture);
+
 	[TestMethod]
 	public void Parse_WithoutAStyleStillReadsFractionsExponentsAndSigns()
 	{

PreciseNumber/PreciseNumber.cs

@@ -48,6 +48,14 @@
 	/// The message carried by the <see cref="FormatException"/> that parsing throws.
 	/// </summary>
 	private const string InvalidFormatMessage = "Input string was not in a correct format.";
+	private const string UnsupportedParseStylesMessage = "The number styles AllowHexSpecifier and AllowBinarySpecifier are not supported by PreciseNumber.";
+
+#if NET8_0_OR_GREATER
+	private const NumberStyles UnsupportedParseStyles = NumberStyles.AllowHexSpecifier | NumberStyles.AllowBinarySpecifier;
+#else
+	// NumberStyles.AllowBinarySpecifier arrived in .NET 8, but a caller on net7.0 can still pass its value.
+	private const NumberStyles UnsupportedParseStyles = NumberStyles.AllowHexSpecifier | (NumberStyles)0x400;
+#endif
 
 	/// <summary>
 	/// The fewest significant digits <see cref="Divide(PreciseNumber, PreciseNumber)"/> produces
@@ -736,7 +744,7 @@
 	/// A fixed precision such as <c>E15</c> rounds values that need 17 digits, which turns
 	/// <see cref="double.MaxValue"/> into a number that converts back to infinity.
 	/// </remarks>
 	internal static string GetStringFormatForFloatType<TFloat>()
 		where TFloat : INumber<TFloat>
 		=> "R";
 
@@ -1197,12 +1205,19 @@
 	public static PreciseNumber MinMagnitudeNumber(PreciseNumber x, PreciseNumber y) => MinMagnitude(x, y);
 
 	/// <inheritdoc/>
 	public static PreciseNumber Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider)
 	{
 		// Read the separator and signs from the same culture TryFormat writes them with, so that
 		// Parse(x.ToString(p), p) round-trips for every provider.
 		NumberFormatInfo numberFormat = NumberFormatInfo.GetInstance(provider ?? InvariantCulture);
 
+		// Hex and binary input would be read as decimal digits and come back as the wrong number,
+		// so refuse those styles outright, as decimal and double do.
+		if ((style & UnsupportedParseStyles) != 0)
+		{
+			throw new ArgumentException(UnsupportedParseStylesMessage, nameof(style));
+		}
+
 		s = TrimAllowedWhite(s, style);
 
 		if (s.IsEmpty)
@@ -1247,14 +1262,14 @@
 					}
 
 					hasDecimal = true;
 					i += decimalSeparator.Length - 1;
 					continue;
 				}
 
 				// Group separators may only sit between integral digits.
 				if (allowThousands && !hasDecimal && digitCount > 0 && s[i..].StartsWith(groupSeparator, StringComparison.Ordinal))
 				{
 					i += groupSeparator.Length - 1;
 					continue;
 				}