Refuse Float and Double data values that overflow to infinity [patch]

Schema.Test/GeneratedDataEditorTests.cs

@@ -115,7 +115,7 @@
 	public void TestAGeneratorNamingAKnownDataSourceValidates()
 	{
 		Schema schema = CreateSchema(out _);
 		Assert.IsFalse(schema.Validate().Any(i => i.Message.Contains("data source", StringComparison.Ordinal)));
 	}
 
 	[TestMethod]
@@ -123,7 +123,7 @@
 	{
 		Schema bound = CreateSchema(out _);
 		string json = SchemaSerializer.Serialize(bound);
 		StringAssert.Contains(json, "\"dataSource\": \"Items\"");
 
 		Assert.IsTrue(SchemaSerializer.TryDeserialize(json, out Schema? reloaded));
 		Assert.AreEqual("Items", reloaded!.CodeGenerators.Single().DataSource.ToString());
@@ -187,7 +187,7 @@
 
 			string[] expected = [.. SchemaDataValidator.ValidateData(item, payload, "Items").Select(i => i.ToString())];
 			string[] actual = [.. Issues(editor).Select(i => i.ToString())];
 			CollectionAssert.AreEqual(expected, actual, payload);
 			Assert.AreEqual(expected.Length == 0 || !expected.Any(e => e.StartsWith("Error", StringComparison.Ordinal)), Get(editor, "IsValid"), payload);
 		}
 	}
@@ -203,10 +203,10 @@
 		// A record added and never filled in is missing its members, which the validator reports.
 		_ = Invoke(editor, "Add");
 		string json = (string)Invoke(editor, "ToJson");
 		Assert.AreNotEqual(0, SchemaDataValidator.ValidateData(item, json, "Items").Count);
 		CollectionAssert.AreEqual(
 			SchemaDataValidator.ValidateData(item, json, "Items").Select(i => i.ToString()).ToArray(),
 			Issues(editor).Select(i => i.ToString()).ToArray());
 	}
 
 	// ---- typed accessors ------------------------------------------------------
@@ -308,6 +308,22 @@
 		Assert.ThrowsExactly<InvalidOperationException>(() => SchemaDataValues.GetString(record, "Missing"));
 	}
 
+	[TestMethod]
+	public void TestANumberPastItsTypesRangeThrowsRatherThanReadingAsInfinity()
+	{
+		JsonObject record = new()
+		{
+			["Speed"] = JsonNode.Parse("1e39"),
+			["D"] = JsonNode.Parse("1e309"),
+			["Position"] = JsonNode.Parse("[1, 1e39, 2]"),
+		};
+
+		Assert.ThrowsExactly<InvalidOperationException>(() => SchemaDataValues.GetFloat(record, "Speed"));
+		Assert.ThrowsExactly<InvalidOperationException>(() => SchemaDataValues.GetDouble(record, "D"));
+		Assert.ThrowsExactly<InvalidOperationException>(() => SchemaDataValues.GetVector3(record, "Position"));
+		Assert.AreEqual(1e39, SchemaDataValues.GetDouble(record, "Speed"));
+	}
+
 	[TestMethod]
 	public void TestANonFiniteValueIsRefusedAndTheEditorKeepsWorking()
 	{
@@ -322,7 +338,7 @@
 		{
 			TargetInvocationException thrown = Assert.ThrowsExactly<TargetInvocationException>(() => Set(sword, "Weight", bad));
 			Assert.IsInstanceOfType<ArgumentOutOfRangeException>(thrown.InnerException);
 			StringAssert.Contains(thrown.InnerException!.Message, "'Weight'");
 		}
 
 		TargetInvocationException tint = Assert.ThrowsExactly<TargetInvocationException>(
@@ -332,7 +348,7 @@
 		// The refused assignments changed nothing, so everything that goes through ToJson still works.
 		Assert.AreEqual(1.5f, Get(sword, "Weight"));
 		Assert.AreEqual(new ColorRgb(1, 0.5f, 0), Get(sword, "Tint"));
 		CollectionAssert.AreEqual(issuesBefore, Issues(editor).Select(i => i.ToString()).ToArray());
 		Assert.IsTrue((bool)Get(editor, "IsValid")!);
 		Assert.AreEqual(ConformingItems, Invoke(editor, "ToJson"));
 		Invoke(editor, "Save", Path.Combine(workingDirectory, "items.json"));

Schema.Test/SchemaDataValidatorTypeTests.cs

@@ -65,7 +65,7 @@
 	[TestMethod]
 	public void ASemanticValueIsCheckedAsItsRepresentation()
 	{
 		Assert.HasCount(0, Validate(EntityId, "42"));
 		Assert.HasCount(1, Validate(EntityId, "\"42\""));
 		Assert.HasCount(1, Validate(EntityId, "4.5"));
 	}
@@ -75,37 +75,37 @@
 	{
 		Semantic missing = new() { SemanticTypeName = "Missing".As<SemanticTypeName>() };
 
 		Assert.HasCount(0, Validate(missing, "\"anything\""));
 	}
 
 	[TestMethod]
 	public void AMagnitudeIsOneNumber()
 	{
 		Assert.HasCount(0, Validate(Quantity("Mass"), "75.5"));
 		Assert.HasCount(1, Validate(Quantity("Mass"), "[75.5]"));
 	}
 
 	[TestMethod]
 	public void AQuantityStoredInAWholeNumberRefusesAFraction()
 	{
 		Assert.HasCount(0, Validate(Quantity("Mass", new Int()), "75"));
 		Assert.HasCount(1, Validate(Quantity("Mass", new Int()), "75.5"));
 	}
 
 	[TestMethod]
 	public void AVectorQuantityIsAnArrayOfItsComponents()
 	{
 		Assert.HasCount(0, Validate(Quantity("Velocity3D"), "[1, 2, 3]"));
 
 		Collection<SchemaValidationIssue> issues = Validate(Quantity("Velocity3D"), "[1, true]");
 		Assert.IsTrue(issues.Any(i => i.Path == "data.Value[1]"), string.Join("; ", issues));
 		Assert.IsTrue(issues.Any(i => i.Path == "data.Value" && i.Message.Contains('3', StringComparison.Ordinal)), string.Join("; ", issues));
 	}
 
 	[TestMethod]
 	public void AnUnknownQuantityIsLeftToSchemaValidation()
 	{
 		Assert.HasCount(0, Validate(Quantity("Squiggles"), "\"anything\""));
 	}
 
 	[TestMethod]
@@ -113,16 +113,16 @@
 	{
 		Optional optional = new() { ElementType = new Int() };
 
 		Assert.HasCount(0, Validate(optional, "null"));
 		Assert.HasCount(0, Validate(optional, "3"));
 		Assert.HasCount(1, Validate(optional, "\"nope\""));
 	}
 
 	[TestMethod]
 	public void AVectorChecksItsComponentsAgainstItsElementType()
 	{
 		Assert.HasCount(0, Validate(new Vector3 { ElementType = new Int() }, "[1, 2, 3]"));
 		Assert.HasCount(0, Validate(new Vector3(), "[1.5, 2, 3]"));
 		Assert.HasCount(1, Validate(new Vector3 { ElementType = EntityId }, "[1, 2.5, 3]"));
 	}
 
@@ -136,4 +136,60 @@
 			Assert.AreEqual(SchemaValidationSeverity.Warning, issues[0].Severity, type.DisplayName);
 		}
 	}
+
+	// ---- floating-point overflow -----------------------------------------------
+
+	[TestMethod]
+	[DataRow("1e39")]
+	[DataRow("-1e39")]
+	public void AFloatPastFloatsRangeIsAnError(string value)
+	{
+		Collection<SchemaValidationIssue> issues = Validate(new Float(), value);
+
+		Assert.HasCount(1, issues, string.Join("; ", issues));
+		Assert.AreEqual(SchemaValidationSeverity.Error, issues[0].Severity);
+		Assert.Contains("range of Float", issues[0].Message);
+	}
+
+	[TestMethod]
+	[DataRow("3.4028234663852886E+38")]
+	[DataRow("1e38")]
+	[DataRow("0")]
+	public void AFloatAtOrInsideFloatsRangeIsAccepted(string value) =>
+		Assert.HasCount(0, Validate(new Float(), value));
+
+	[TestMethod]
+	public void ADoublePastDoublesRangeIsAnError()
+	{
+		Assert.HasCount(1, Validate(new Double(), "1e309"));
+		Assert.HasCount(0, Validate(new Double(), "1e39"));
+	}
+
+	[TestMethod]
+	public void AFloatVectorComponentPastFloatsRangeIsAnError()
+	{
+		Collection<SchemaValidationIssue> issues = Validate(new Vector3(), "[1, 1e39, 2]");
+
+		Assert.HasCount(1, issues, string.Join("; ", issues));
+		Assert.AreEqual("data.Value[1]", issues[0].Path);
+	}
+
+	[TestMethod]
+	public void AColourComponentAndAQuantityPastFloatsRangeAreErrors()
+	{
+		Assert.HasCount(1, Validate(new ColorRGB(), "[0, 1e39, 0]"));
+		Assert.HasCount(1, Validate(Quantity("Mass"), "1e39"));
+	}
+
+	[TestMethod]
+	public void ASemanticTypeOverAFloatIsHeldToFloatsRange()
+	{
+		SchemaClass schemaClass = ClassWith((schema, c) =>
+		{
+			schema.AddSemanticType("Speed".As<SemanticTypeName>())!.SetUnderlyingType(new Float());
+			c.AddMember("Value".As<MemberName>())!.SetType(new Semantic { SemanticTypeName = "Speed".As<SemanticTypeName>() });
+		});
+
+		Assert.HasCount(1, SchemaDataValidator.ValidateData(schemaClass, """{ "Value": 1e39 }""", "data"));
+	}
 }

Schema/Models/SchemaDataValidator.cs

@@ -262,7 +262,7 @@ private static void ValidateValue(BaseType type, JsonElement value, string path,
 				break;
 
 			case Float or Double:
-				Expect(value, JsonValueKind.Number, path, type, issues);
+				ExpectNumber(value, type, path, type, issues);
 				break;
 
 			case Types.String:
@@ -399,7 +399,24 @@ private static void ExpectNumber(JsonElement value, BaseType storage, string pat
 			return;
 		}
 
-		Expect(value, JsonValueKind.Number, path, type, issues);
+		if (value.ValueKind != JsonValueKind.Number)
+		{
+			Expect(value, JsonValueKind.Number, path, type, issues);
+			return;
+		}
+
+		// A number past what the storage holds reads back as an infinity rather than failing, so
+		// "1e39" in a Float passes every reader and arrives as one. Refuse it here, as the
+		// integral types already are and as schema validation already refuses such a default.
+		bool finite = value.TryGetDouble(out double number) && double.IsFinite(number);
+		if (represented is Float && !(finite && Math.Abs(number) <= float.MaxValue))
+		{
+			issues.Add(Error(path, $"Expected a number within the range of Float (±{float.MaxValue.ToString("R", CultureInfo.InvariantCulture)}) for type '{type.DisplayName}' but found {value.GetRawText()}."));
+		}
+		else if (represented is Double && !finite)
+		{
+			issues.Add(Error(path, $"Expected a number within the range of Double (±{double.MaxValue.ToString("R", CultureInfo.InvariantCulture)}) for type '{type.DisplayName}' but found {value.GetRawText()}."));
+		}
 	}
 
 	private static void ValidateEnumValue(Types.Enum enumType, JsonElement value, string path, Collection<SchemaValidationIssue> issues)

Schema/Runtime/SchemaDataValues.cs

@@ -42,7 +42,7 @@
 			return true;
 		}
 
 		foreach (KeyValuePair<string, JsonNode?> property in record)
 		{
 			if (string.Equals(property.Key, name, StringComparison.OrdinalIgnoreCase))
 			{
@@ -115,7 +115,7 @@
 	/// <param name="name">The member's declared name.</param>
 	/// <returns>The value.</returns>
 	public static float GetFloat(JsonObject record, string name) =>
-		ReadNumber(record, name, static (JsonElement e, out float v) => e.TryGetSingle(out v));
+		ReadNumber(record, name, static (JsonElement e, out float v) => e.TryGetSingle(out v) && float.IsFinite(v));
 
 	/// <summary>Writes a <c>Float</c> member.</summary>
 	/// <param name="record">The record.</param>
@@ -130,7 +130,7 @@
 	/// <param name="name">The member's declared name.</param>
 	/// <returns>The value.</returns>
 	public static double GetDouble(JsonObject record, string name) =>
-		ReadNumber(record, name, static (JsonElement e, out double v) => e.TryGetDouble(out v));
+		ReadNumber(record, name, static (JsonElement e, out double v) => e.TryGetDouble(out v) && double.IsFinite(v));
 
 	/// <summary>Writes a <c>Double</c> member.</summary>
 	/// <param name="record">The record.</param>
@@ -206,7 +206,7 @@
 		string text = GetString(record, name);
 
 		// Ordinal, as the validator matches: a value spelled in another case is not that value.
 		foreach (TEnum value in System.Enum.GetValues<TEnum>())
 		{
 			if (string.Equals(value.ToString(), text, StringComparison.Ordinal))
 			{
@@ -346,7 +346,8 @@
 		{
 			JsonNode? component = array[i];
 			if (component?.GetValueKind() != JsonValueKind.Number
-				|| !JsonSerializer.SerializeToElement(component).TryGetSingle(out components[i]))
+				|| !JsonSerializer.SerializeToElement(component).TryGetSingle(out components[i])
+				|| !float.IsFinite(components[i]))
 			{
 				throw Malformed(name, $"component {i} is not a number");
 			}