Reject Long defaults outside the 64-bit range [patch]

Schema.Test/MemberMetadataTests.cs

@@ -248,6 +248,36 @@
 		AssertMentions(Errors(schema), "outside the 32-bit range");
 	}
 
+	/// <summary>
+	/// 9223372036854775807 is long.MaxValue as written, but as a double it rounds to 2^63, which
+	/// no Long can hold.
+	/// </summary>
+	[TestMethod]
+	[DataRow(1e19)]
+	[DataRow(-1e19)]
+	[DataRow(9223372036854775807.0)]
+	public void ADefaultOutsideInt64RangeOnALongMemberIsAnError(double value)
+	{
+		SchemaMember member = MemberWith(new SchemaTypes.Long(), out Schema schema);
+		member.DefaultValue = new NumberDefault { Value = value };
+
+		AssertMentions(Errors(schema), "outside the 64-bit range");
+	}
+
+	/// <summary>
+	/// The largest double below 2^63, and the smallest Long, are both representable.
+	/// </summary>
+	[TestMethod]
+	[DataRow(9223372036854774784.0)]
+	[DataRow(-9223372036854775808.0)]
+	public void ADefaultInsideInt64RangeOnALongMemberIsAccepted(double value)
+	{
+		SchemaMember member = MemberWith(new SchemaTypes.Long(), out Schema schema);
+		member.DefaultValue = new NumberDefault { Value = value };
+
+		Assert.AreEqual(0, Errors(schema).Count);
+	}
+
 	[TestMethod]
 	public void ADefaultOfTheWrongKindIsAnError()
 	{

Schema/Models/Schema.Validation.cs

@@ -340,7 +340,7 @@
 	/// <summary>
 	/// A default has to be of the member's own kind, and inside its range.
 	/// </summary>
 	private static void ValidateMemberDefault(Collection<SchemaValidationIssue> issues, ISchemaMetadataCarrier carrier, BaseType type, string path, ISchemaElement element, string kind)
 	{
 		switch (carrier.DefaultValue)
 		{
@@ -369,6 +369,11 @@
 					Report(issues, path, element, $"The default {Number(number.Value)} is outside the 32-bit range of Int ({int.MinValue}..{int.MaxValue}).");
 				}
 
+				if (type is Long && isWholeNumber && !FitsInt64(number.Value))
+				{
+					Report(issues, path, element, $"The default {Number(number.Value)} is outside the 64-bit range of Long ({long.MinValue}..{long.MaxValue}).");
+				}
+
 				// A wrapping range is a period rather than a bound, so a value outside it is
 				// un-normalised rather than wrong -- the same reading a validator must take of
 				// live data, applied here to the default.
@@ -489,6 +494,12 @@
 
 	private static bool FitsInt32(double value) => value is >= int.MinValue and <= int.MaxValue;
 
+	/// <summary>
+	/// The upper bound is exclusive because (double)long.MaxValue rounds up to 2^63, which is
+	/// already one past the range: an inclusive check would pass the one value it most needs to stop.
+	/// </summary>
+	private static bool FitsInt64(double value) => value is >= -9223372036854775808.0 and < 9223372036854775808.0;
+
 	/// <summary>
 	/// Formats a number for a message, culture-invariantly: a validation message that says
 	/// "0,5" on one machine and "0.5" on another is a support problem.