public virtual void TestSchemaEncodeDecodeFidelity()
{
var schema = FloatSchema.Of();
var dbl = 1234578.8754321F;
var bytes = schema.Encode(dbl);
Assert.Equal(dbl, schema.Decode(bytes));
}
public virtual void TestSchemaEncode()
{
var schema = FloatSchema.Of();
var data = 12345678.1234F;
var expected = BitConverter.GetBytes(data).Reverse().ToArray();
Assert.Equal(expected, schema.Encode(data));
}
public void SingleValues(float value)
{
var schema = new FloatSchema();
var deserializer = DeserializerBuilder.BuildDeserializer <float>(schema);
var serializer = SerializerBuilder.BuildSerializer <float>(schema);
Assert.Equal(value, deserializer.Deserialize(serializer.Serialize(value)));
}
/// <summary>
/// Builds a float schema.
/// </summary>
/// <param name="resolution">
/// A type resolution.
/// </param>
/// <param name="cache">
/// A schema cache.
/// </param>
/// <returns>
/// A <see cref="FloatSchema" /> that matches the type resolution.
/// </returns>
/// <exception cref="ArgumentException">
/// Thrown when the resolution is not an 8-bit <see cref="FloatingPointResolution" />.
/// </exception>
public override Schema BuildSchema(TypeResolution resolution, IDictionary <Type, Schema> cache)
{
if (!(resolution is FloatingPointResolution @float) || @float.Size != 8)
{
throw new ArgumentException("The double case can only be applied to 8-bit floating point resolutions.", nameof(resolution));
}
var schema = new FloatSchema();
cache.Add(@float.Type, schema);
return(schema);
}
static Schema()
{
ByteSequence = new ByteSequenceSchema();
ByteArray = new ByteArraySchema();
String = StringSchema.UTF8;
Boolean = new BooleanSchema();
Int8 = new ByteSchema();
Int16 = new ShortSchema();
Int32 = new IntegerSchema();
Int64 = new LongSchema();
Float = new FloatSchema();
TimeStamp = TimestampSchema.Timestamp;
Date = TimestampSchema.Date;
Time = new TimeSchema();
}
public void SingleValues(float value)
{
var schema = new FloatSchema();
var deserialize = deserializerBuilder.BuildDelegate <float>(schema);
var serialize = serializerBuilder.BuildDelegate <float>(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}."),
});
public void Int32Values(int value)
{
var schema = new FloatSchema();
var deserialize = deserializerBuilder.BuildDelegate <float>(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 DynamicFloatValues(dynamic value)
{
var schema = new FloatSchema();
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((float)value, deserialize(ref reader));
}
public void NonUnionValueToUnionTest()
{
var writerSchema = new FloatSchema();
var readerSchema = new UnionSchema(new FloatSchema(), new StringSchema(), new BytesSchema());
var writer = new DatumWriter <float>(writerSchema);
var reader = new DatumReader <object>(readerSchema, writerSchema);
var expectedValue = 123.456F;
using (var stream = new MemoryStream())
using (var encoder = new BinaryEncoder(stream))
using (var decoder = new BinaryDecoder(stream))
{
writer.Write(encoder, expectedValue);
stream.Seek(0, SeekOrigin.Begin);
Assert.AreEqual(expectedValue, reader.Read(decoder));
}
}
/// <summary>
/// Builds a <see cref="FloatSchema" />.
/// </summary>
/// <returns>
/// A successful <see cref="SchemaBuilderCaseResult" /> with a <see cref="FloatSchema" />
/// if <paramref name="type" /> is a <see cref="float" />; an unsuccessful
/// <see cref="SchemaBuilderCaseResult" /> with an <see cref="UnsupportedTypeException" />
/// otherwise.
/// </returns>
/// <inheritdoc />
public virtual SchemaBuilderCaseResult BuildSchema(Type type, SchemaBuilderContext context)
{
if (type == typeof(float))
{
var floatSchema = new FloatSchema();
try
{
context.Schemas.Add(type, floatSchema);
}
catch (ArgumentException exception)
{
throw new InvalidOperationException($"A schema for {type} already exists on the schema builder context.", exception);
}
return(SchemaBuilderCaseResult.FromSchema(floatSchema));
}
else
{
return(SchemaBuilderCaseResult.FromException(new UnsupportedTypeException(type, $"{nameof(FloatSchemaBuilderCase)} can only be applied to the {typeof(float)} type.")));
}
}
private void VisitCore(FloatSchema s)
{
s.Serializer = new FloatSerializer(s);
}