public void DynamicBooleanValues(bool value)
{
var schema = new BooleanSchema();
var deserialize = deserializerBuilder.BuildDelegate <dynamic>(schema);
var serialize = serializerBuilder.BuildDelegate <dynamic>(schema);
using (stream)
{
serialize(value, new BinaryWriter(stream));
}
var reader = new BinaryReader(stream.ToArray());
Assert.Equal(value, deserialize(ref reader));
}
public void EnumValues(ImplicitEnum value)
{
var schema = new EnumSchema("ordinal", new[] { "NONE", "FIRST", "SECOND", "THIRD", "FOURTH" });
var deserialize = deserializerBuilder.BuildDelegate <ImplicitEnum>(schema);
var serialize = serializerBuilder.BuildDelegate <ImplicitEnum>(schema);
using (stream)
{
serialize(value, new BinaryWriter(stream));
}
var reader = new BinaryReader(stream.ToArray());
Assert.Equal(value, deserialize(ref reader));
}
public void IImmutableSetValues(ISet <string> value)
{
var schema = new ArraySchema(new StringSchema());
var deserialize = deserializerBuilder.BuildDelegate <IImmutableSet <string> >(schema);
var serialize = serializerBuilder.BuildDelegate <IImmutableSet <string> >(schema);
using (stream)
{
serialize(value.ToImmutableHashSet(), new BinaryWriter(stream));
}
var reader = new BinaryReader(stream.ToArray());
Assert.Equal(value, deserialize(ref reader).OrderBy(v => v));
}
public void SByteValues(sbyte value)
{
var schema = new IntSchema();
var deserialize = deserializerBuilder.BuildDelegate <sbyte>(schema);
var serialize = serializerBuilder.BuildDelegate <sbyte>(schema);
using (stream)
{
serialize(value, new BinaryWriter(stream));
}
var reader = new BinaryReader(stream.ToArray());
Assert.Equal(value, deserialize(ref reader));
}
public void ICollectionValues(long[] value)
{
var schema = new ArraySchema(new LongSchema());
var deserialize = deserializerBuilder.BuildDelegate <ICollection <long> >(schema);
var serialize = serializerBuilder.BuildDelegate <ICollection <long> >(schema);
using (stream)
{
serialize(value, new BinaryWriter(stream));
}
var reader = new BinaryReader(stream.ToArray());
Assert.Equal(value, deserialize(ref reader));
}
public void HashSetValues(HashSet <string> value)
{
var schema = new ArraySchema(new StringSchema());
var deserialize = deserializerBuilder.BuildDelegate <HashSet <string> >(schema);
var serialize = serializerBuilder.BuildDelegate <HashSet <string> >(schema);
using (stream)
{
serialize(value, new BinaryWriter(stream));
}
var reader = new BinaryReader(stream.ToArray());
Assert.Equal(value, deserialize(ref reader));
}
public void DynamicArrayValues(long[] value)
{
var schema = new ArraySchema(new LongSchema());
var deserialize = deserializerBuilder.BuildDelegate <dynamic>(schema);
var serialize = serializerBuilder.BuildDelegate <dynamic>(schema);
using (stream)
{
serialize(value, new BinaryWriter(stream));
}
var reader = new BinaryReader(stream.ToArray());
Assert.Equal(value.Cast <object>(), deserialize(ref reader));
}
public void UIntPtrValues(UIntPtr value)
{
var schema = new LongSchema();
var deserialize = deserializerBuilder.BuildDelegate <UIntPtr>(schema);
var serialize = serializerBuilder.BuildDelegate <UIntPtr>(schema);
using (stream)
{
serialize(value, new BinaryWriter(stream));
}
var reader = new BinaryReader(stream.ToArray());
Assert.Equal(value, deserialize(ref reader));
}
public void IImmutableQueueValues(long[] value)
{
var schema = new ArraySchema(new LongSchema());
var deserialize = deserializerBuilder.BuildDelegate <IImmutableQueue <long> >(schema);
var serialize = serializerBuilder.BuildDelegate <IImmutableQueue <long> >(schema);
using (stream)
{
serialize(ImmutableQueue.CreateRange(value), new BinaryWriter(stream));
}
var reader = new BinaryReader(stream.ToArray());
Assert.Equal(value, deserialize(ref reader));
}
public void NullableDateTimeOffsetValues(DateTimeOffset value)
{
var schema = new StringSchema();
var deserialize = deserializerBuilder.BuildDelegate <DateTimeOffset?>(schema);
var serialize = serializerBuilder.BuildDelegate <DateTimeOffset>(schema);
using (stream)
{
serialize(value, new BinaryWriter(stream));
}
var reader = new BinaryReader(stream.ToArray());
var decoded = deserialize(ref reader);
// comparing two DateTimeOffsets doesn’t necessarily ensure that they’re identical:
Assert.Equal(value.DateTime, decoded.Value.DateTime);
Assert.Equal(value.Offset, decoded.Value.Offset);
}
public void DynamicDecimalValues(decimal value)
{
var schema = new BytesSchema()
{
LogicalType = new DecimalLogicalType(29, 14),
};
var deserialize = deserializerBuilder.BuildDelegate <dynamic>(schema);
var serialize = serializerBuilder.BuildDelegate <dynamic>(schema);
using (stream)
{
serialize(value, new BinaryWriter(stream));
}
var reader = new BinaryReader(stream.ToArray());
Assert.Equal(value, deserialize(ref reader));
}
public void NullableGuidValues(Guid value)
{
var schema = new StringSchema()
{
LogicalType = new UuidLogicalType(),
};
var deserialize = deserializerBuilder.BuildDelegate <Guid?>(schema);
var serialize = serializerBuilder.BuildDelegate <Guid>(schema);
using (stream)
{
serialize(value, new BinaryWriter(stream));
}
var reader = new BinaryReader(stream.ToArray());
Assert.Equal(value, deserialize(ref reader));
}
public void StringUnionToStringType(string value, byte[] encoding)
{
var schema = new UnionSchema(new Schema[]
{
new StringSchema(),
});
var deserialize = deserializerBuilder.BuildDelegate <string>(schema);
var serialize = serializerBuilder.BuildDelegate <string>(schema);
using (stream)
{
serialize(value, new BinaryWriter(stream));
}
var encoded = stream.ToArray();
var reader = new BinaryReader(encoded);
Assert.Equal(encoding, encoded);
Assert.Equal(value, deserialize(ref reader));
}
public void ResizedDecimalValues(int precision, int scale, decimal value, byte[] encoding, decimal resizing)
{
var schema = new BytesSchema()
{
LogicalType = new DecimalLogicalType(precision, scale),
};
var deserialize = deserializerBuilder.BuildDelegate <decimal>(schema);
var serialize = serializerBuilder.BuildDelegate <decimal>(schema);
using (stream)
{
serialize(value, new BinaryWriter(stream));
}
var encoded = stream.ToArray();
var reader = new BinaryReader(encoded);
Assert.Equal(encoding, encoded);
Assert.Equal(resizing, deserialize(ref reader));
}
public void MicrosecondTimestampLogicalTypeToDateTimeOffsetType(DateTimeOffset value, byte[] encoding)
{
var schema = new LongSchema()
{
LogicalType = new MicrosecondTimestampLogicalType(),
};
var deserialize = deserializerBuilder.BuildDelegate <DateTimeOffset>(schema);
var serialize = serializerBuilder.BuildDelegate <DateTimeOffset>(schema);
using (stream)
{
serialize(value, new BinaryWriter(stream));
}
var encoded = stream.ToArray();
var reader = new BinaryReader(encoded);
Assert.Equal(encoding, encoded);
Assert.Equal(value, deserialize(ref reader));
}
public void TimeSpanValues(TimeSpan value, byte[] encoding)
{
var schema = new FixedSchema("duration", DurationLogicalType.DurationSize)
{
LogicalType = new DurationLogicalType(),
};
var deserialize = deserializerBuilder.BuildDelegate <TimeSpan>(schema);
var serialize = serializerBuilder.BuildDelegate <TimeSpan>(schema);
using (stream)
{
serialize(value, new BinaryWriter(stream));
}
var encoded = stream.ToArray();
var reader = new BinaryReader(encoded);
Assert.Equal(encoding, encoded);
Assert.Equal(value, deserialize(ref reader));
}
public void NullAndIntUnionToNullableInt32Type(int?value, byte[] encoding)
{
var schema = new UnionSchema(new Schema[]
{
new NullSchema(),
new IntSchema(),
});
var deserialize = deserializerBuilder.BuildDelegate <int?>(schema);
var serialize = serializerBuilder.BuildDelegate <int?>(schema);
using (stream)
{
serialize(value, new BinaryWriter(stream));
}
var encoded = stream.ToArray();
var reader = new BinaryReader(encoded);
Assert.Equal(encoding, encoded);
Assert.Equal(value, deserialize(ref reader));
}
public void RecordWithParallelDependencies()
{
var node = new RecordSchema("Node");
node.Fields.Add(new RecordField("Value", new IntSchema()));
node.Fields.Add(new RecordField("Children", new ArraySchema(node)));
var schema = new RecordSchema("Reference");
schema.Fields.Add(new RecordField("Node", node));
schema.Fields.Add(new RecordField("RelatedNodes", new ArraySchema(node)));
var deserialize = deserializerBuilder.BuildDelegate <Reference>(schema);
var serialize = serializerBuilder.BuildDelegate <Reference>(schema);
using (stream)
{
serialize(
new Reference()
{
Node = new Node()
{
Children = Array.Empty <Node>(),
},
RelatedNodes = Array.Empty <Node>(),
},
new BinaryWriter(stream));
}
var reader = new BinaryReader(stream.ToArray());
var root = deserialize(ref reader);
Assert.Empty(root.Node.Children);
Assert.Empty(root.RelatedNodes);
}
public void RecordWithCyclicDependenciesAndOptionalParameters()
{
var schema = new RecordSchema("Node");
schema.Fields.Add(new RecordField("Value", new IntSchema()));
schema.Fields.Add(new RecordField("Children", new ArraySchema(schema)));
var deserialize = deserializerBuilder.BuildDelegate <MappedNode>(schema);
var serialize = serializerBuilder.BuildDelegate <Node>(schema);
using (stream)
{
serialize(
new Node()
{
Value = 5,
Children = new[]
{
new Node()
{
Value = 9,
Children = Array.Empty <Node>(),
},
new Node()
{
Value = 3,
Children = new[]
{
new Node()
{
Value = 2,
Children = Array.Empty <Node>(),
},
new Node()
{
Value = 10,
Children = Array.Empty <Node>(),
},
},
},
},
},
new BinaryWriter(stream));
}
var reader = new BinaryReader(stream.ToArray());
var n5 = deserialize(ref reader);
Assert.Equal(5, n5.RequiredValue);
Assert.Equal(999, n5.OptionalValue);
Assert.Collection(
n5.Children,
n9 =>
{
Assert.Equal(9, n9.RequiredValue);
Assert.Equal(999, n9.OptionalValue);
Assert.Empty(n9.Children);
},
n3 =>
{
Assert.Equal(3, n3.RequiredValue);
Assert.Equal(999, n3.OptionalValue);
Assert.Collection(
n3.Children,
n2 =>
{
Assert.Equal(2, n2.RequiredValue);
Assert.Equal(999, n2.OptionalValue);
Assert.Empty(n2.Children);
},
n10 =>
{
Assert.Equal(10, n10.RequiredValue);
Assert.Equal(999, n10.OptionalValue);
Assert.Empty(n10.Children);
});
});
}
public void SelectedTypes()
{
var schema = new RecordSchema(nameof(EventContainer))
{
Fields = new[]
{
new RecordField(
"event",
new UnionSchema(new[]
{
new RecordSchema(nameof(OrderCreatedEvent))
{
Fields = new[]
{
new RecordField("timestamp", new StringSchema()),
new RecordField(
"total",
new BytesSchema()
{
LogicalType = new DecimalLogicalType(5, 2),
}),
},
},
new RecordSchema(nameof(OrderCancelledEvent))
{
Fields = new[]
{
new RecordField("timestamp", new StringSchema()),
},
},
})),
},
};
var deserialize = new BinaryDeserializerBuilder(BinaryDeserializerBuilder
.CreateDefaultCaseBuilders()
.Prepend(builder => new OrderDeserializerBuilderCase(builder)))
.BuildDelegate <EventContainer>(schema);
var serialize = new BinarySerializerBuilder(BinarySerializerBuilder
.CreateDefaultCaseBuilders()
.Prepend(builder => new OrderSerializerBuilderCase(builder)))
.BuildDelegate <EventContainer>(schema);
var creation = new EventContainer
{
Event = new OrderCreatedEvent
{
Timestamp = DateTime.UtcNow,
Total = 40M,
},
};
var cancellation = new EventContainer
{
Event = new OrderCancelledEvent
{
Timestamp = DateTime.UtcNow,
},
};
using (stream)
{
serialize(creation, new BinaryWriter(stream));
var reader = new BinaryReader(stream.ToArray());
var result = deserialize(ref reader);
Assert.IsType <OrderCreatedEvent>(result.Event);
stream.Position = 0;
serialize(cancellation, new BinaryWriter(stream));
reader = new BinaryReader(stream.ToArray());
result = deserialize(ref reader);
Assert.IsType <OrderCancelledEvent>(result.Event);
}
}
public void RecordWithMissingFields()
{
var boolean = new BooleanSchema();
var array = new ArraySchema(boolean);
var map = new MapSchema(new IntSchema());
var @enum = new EnumSchema("Ordinal", new[] { "None", "First", "Second", "Third", "Fourth" });
var union = new UnionSchema(new Schema[]
{
new NullSchema(),
array,
});
var schema = new RecordSchema("AllFields")
{
Fields = new[]
{
new RecordField("First", union),
new RecordField("Second", union),
new RecordField("Third", array),
new RecordField("Fourth", array),
new RecordField("Fifth", map),
new RecordField("Sixth", map),
new RecordField("Seventh", @enum),
new RecordField("Eighth", @enum),
},
};
var deserialize = deserializerBuilder.BuildDelegate <WithoutEvenFields>(schema);
var serialize = serializerBuilder.BuildDelegate <WithEvenFields>(schema);
var value = new WithEvenFields()
{
First = new List <bool>()
{
false
},
Second = new List <bool>()
{
false, false
},
Third = new List <bool>()
{
false, false, false
},
Fourth = new List <bool>()
{
false
},
Fifth = new Dictionary <string, int>()
{
{ "first", 1 }
},
Sixth = new Dictionary <string, int>()
{
{ "first", 1 }, { "second", 2 }
},
Seventh = ImplicitEnum.First,
Eighth = ImplicitEnum.None,
};
using (stream)
{
serialize(value, new BinaryWriter(stream));
}
var reader = new BinaryReader(stream.ToArray());
Assert.Equal(value.Seventh, deserialize(ref reader).Seventh);
}
public void RecordWithCyclicDependencies()
{
var schema = new RecordSchema("Node");
schema.Fields.Add(new RecordField("Value", new IntSchema()));
schema.Fields.Add(new RecordField("Children", new ArraySchema(schema)));
var deserialize = deserializerBuilder.BuildDelegate <Node>(schema);
var serialize = serializerBuilder.BuildDelegate <Node>(schema);
using (stream)
{
serialize(
new Node()
{
Value = 5,
Children = new[]
{
new Node()
{
Value = 4,
Children = Array.Empty <Node>(),
},
new Node()
{
Value = 7,
Children = new[]
{
new Node()
{
Value = 6,
Children = Array.Empty <Node>(),
},
new Node
{
Value = 8,
Children = Array.Empty <Node>(),
},
},
},
},
},
new BinaryWriter(stream));
}
var reader = new BinaryReader(stream.ToArray());
var n5 = deserialize(ref reader);
Assert.Equal(5, n5.Value);
Assert.Collection(
n5.Children,
n4 =>
{
Assert.Equal(4, n4.Value);
Assert.Empty(n4.Children);
},
n7 =>
{
Assert.Equal(7, n7.Value);
Assert.Collection(
n7.Children,
n6 =>
{
Assert.Equal(6, n6.Value);
Assert.Empty(n6.Children);
},
n8 =>
{
Assert.Equal(8, n8.Value);
Assert.Empty(n8.Children);
});
});
}
