public virtual void TestSchemaEncodeDecodeFidelity()
{
var schema = DoubleSchema.Of();
var dbl = 1234578.8754321D;
var bytes = schema.Encode(dbl);
Assert.Equal(dbl, schema.Decode(bytes));
}
public virtual void TestSchemaEncode()
{
var schema = DoubleSchema.Of();
var data = 12345678.1234D;
var expected = BitConverter.GetBytes(data).Reverse().ToArray();
Assert.Equal(expected, schema.Encode(data));
}
public void Int32Values(int value)
{
var schema = new DoubleSchema();
var deserializer = DeserializerBuilder.BuildDeserializer <double>(schema);
var serializer = SerializerBuilder.BuildSerializer <int>(schema);
Assert.Equal(value, deserializer.Deserialize(serializer.Serialize(value)));
}
/// <summary>
/// Builds a double schema.
/// </summary>
/// <param name="resolution">
/// A type resolution.
/// </param>
/// <param name="cache">
/// A schema cache.
/// </param>
/// <returns>
/// A <see cref="DoubleSchema" /> that matches the type resolution.
/// </returns>
/// <exception cref="ArgumentException">
/// Thrown when the resolution is not a 16-bit <see cref="FloatingPointResolution" />.
/// </exception>
public override Schema BuildSchema(TypeResolution resolution, IDictionary <Type, Schema> cache)
{
if (!(resolution is FloatingPointResolution @double) || @double.Size != 16)
{
throw new ArgumentException("The double case can only be applied to 16-bit floating point resolutions.", nameof(resolution));
}
var schema = new DoubleSchema();
cache.Add(@double.Type, schema);
return(schema);
}
public void Int32Values(int value)
{
var schema = new DoubleSchema();
var deserialize = deserializerBuilder.BuildDelegate <double>(schema);
var serialize = serializerBuilder.BuildDelegate <int>(schema);
using (stream)
{
serialize(value, new Utf8JsonWriter(stream));
}
var reader = new Utf8JsonReader(stream.ToArray());
Assert.Equal(value, deserialize(ref reader));
}
public void DynamicDoubleValues(double value)
{
var schema = new DoubleSchema();
var deserialize = deserializerBuilder.BuildDelegate <dynamic>(schema);
var serialize = serializerBuilder.BuildDelegate <dynamic>(schema);
using (stream)
{
serialize(value, new Utf8JsonWriter(stream));
}
var reader = new Utf8JsonReader(stream.ToArray());
Assert.Equal((double)value, deserialize(ref reader));
}
public void DoubleValues(double value)
{
var schema = new DoubleSchema();
var deserialize = deserializerBuilder.BuildDelegate <double>(schema);
var serialize = serializerBuilder.BuildDelegate <double>(schema);
using (stream)
{
serialize(value, new BinaryWriter(stream));
}
var reader = new BinaryReader(stream.ToArray());
Assert.Equal(value, deserialize(ref reader));
}
/// <summary>
/// Writes an <see cref="PrimitiveSchema" />.
/// </summary>
/// <inheritdoc />
public virtual JsonSchemaWriterCaseResult Write(Schema schema, Utf8JsonWriter json, bool canonical, JsonSchemaWriterContext context)
{
if (schema is PrimitiveSchema primitiveSchema)
{
json.WriteStringValue(primitiveSchema switch
{
BooleanSchema _ => JsonSchemaToken.Boolean,
BytesSchema _ => JsonSchemaToken.Bytes,
DoubleSchema _ => JsonSchemaToken.Double,
FloatSchema _ => JsonSchemaToken.Float,
IntSchema _ => JsonSchemaToken.Int,
LongSchema _ => JsonSchemaToken.Long,
NullSchema _ => JsonSchemaToken.Null,
StringSchema _ => JsonSchemaToken.String,
_ => throw new UnsupportedSchemaException(schema, $"Unknown primitive schema {schema}."),
});
/// <summary>
/// Builds a <see cref="DoubleSchema" />.
/// </summary>
/// <returns>
/// A successful <see cref="SchemaBuilderCaseResult" /> with a <see cref="DoubleSchema" />
/// if <paramref name="type" /> is <see cref="double" />; an unsuccessful
/// <see cref="SchemaBuilderCaseResult" /> with an <see cref="UnsupportedTypeException" />
/// otherwise.
/// </returns>
/// <inheritdoc />
public virtual SchemaBuilderCaseResult BuildSchema(Type type, SchemaBuilderContext context)
{
if (type == typeof(double))
{
var doubleSchema = new DoubleSchema();
try
{
context.Schemas.Add(type, doubleSchema);
}
catch (ArgumentException exception)
{
throw new InvalidOperationException($"A schema for {type} already exists on the schema builder context.", exception);
}
return(SchemaBuilderCaseResult.FromSchema(doubleSchema));
}
else
{
return(SchemaBuilderCaseResult.FromException(new UnsupportedTypeException(type, $"{nameof(DoubleSchemaBuilderCase)} can only be applied to the {typeof(double)} type.")));
}
}
private void VisitCore(DoubleSchema s)
{
s.Serializer = new DoubleSerializer(s);
}
