public void ByteArray()
{
var schema = Schema.Parse(_fixedSchema);
var fixedRecWrite = new ByteArrayFixedRec()
{
myFixed = new byte[16] {
1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6
}
};
var fixedRecBad = new ByteArrayFixedRec()
{
myFixed = new byte[10]
};
ByteArrayFixedRec fixedRecRead = null;
var writer = new ReflectWriter <ByteArrayFixedRec>(schema);
var reader = new ReflectReader <ByteArrayFixedRec>(schema, schema);
Assert.Throws(typeof(AvroException), () => {
using (var stream = new MemoryStream(256))
{
writer.Write(fixedRecBad, new BinaryEncoder(stream));
}
});
using (var stream = new MemoryStream(256))
{
writer.Write(fixedRecWrite, new BinaryEncoder(stream));
stream.Seek(0, SeekOrigin.Begin);
fixedRecRead = reader.Read(null, new BinaryDecoder(stream));
Assert.IsTrue(fixedRecRead.myFixed.Length == 16);
Assert.IsTrue(fixedRecWrite.myFixed.SequenceEqual(fixedRecRead.myFixed));
}
}
public void TestFoo()
{
var simple = typeof(Foo).GetSchema();
_output.WriteLine(simple);
var schema = Schema.Parse(simple);
var writer = new ReflectWriter <Foo>(schema);
Assert.Contains("Age", simple);
}
public void TestDictionaryRecursiveArray()
{
var actual = typeof(Dictionary).GetSchema();
_output.WriteLine(actual);
var schema = Schema.Parse(actual);
var writer = new ReflectWriter <Dictionary>(schema);
Assert.True(true);
}
public void TestAliasesDictionary()
{
var actual = typeof(ClassWithAliasesWithDictionary).GetSchema();
_output.WriteLine(actual);
var schema = Schema.Parse(actual);
var writer = new ReflectWriter <ClassWithAliasesWithDictionary>(schema);
Assert.True(true);
}
public void TestFooCustom()
{
var simplecu = typeof(FooCustom).GetSchema();
_output.WriteLine(simplecu);
var schema = Schema.Parse(simplecu);
var writer = new ReflectWriter <FooCustom>(schema);
Assert.Contains("EntryYear", simplecu);
Assert.Contains("Level", simplecu);
}
public void TestStaticFieldsAreIgnored()
{
var expectSchema = "{\"type\":\"record\",\"namespace\":\"AvroSchemaGenerator.Tests\",\"name\":\"SimpleWithStaticFieldsAndNestedClass\",\"fields\":[{\"name\":\"FactTime\",\"type\":\"long\"},{\"name\":\"SimpleStaticInner\",\"type\":[\"null\",{\"type\":\"record\",\"namespace\":\"AvroSchemaGenerator.Tests\",\"name\":\"SimpleWithStaticFields\",\"fields\":[{\"name\":\"Name\",\"type\":[\"null\",\"string\"],\"default\":null}]}],\"default\":null}]}";
var actual = typeof(SimpleWithStaticFieldsAndNestedClass).GetSchema();
_output.WriteLine(actual);
var schema = Schema.Parse(actual);
var writer = new ReflectWriter <SimpleWithStaticFieldsAndNestedClass>(schema);
Assert.Equal(expectSchema, actual);
}
public void TestAliasesList()
{
var expectSchema = "{\"type\":\"record\",\"namespace\":\"AvroSchemaGenerator.Tests\",\"name\":\"ClassWithAliasesWithList\",\"aliases\":[\"InterLives\",\"CountrySide\"],\"fields\":[{\"name\":\"City\",\"aliases\":[\"TownHall\",\"Province\"],\"type\":[\"null\",\"string\"],\"default\":null},{\"name\":\"State\",\"type\":[\"null\",\"string\"],\"default\":null},{\"name\":\"Movie\",\"aliases\":[\"PopularMovie\"],\"type\":[\"null\",{\"type\":\"record\",\"namespace\":\"AvroSchemaGenerator.Tests\",\"name\":\"InnerAliases\",\"fields\":[{\"name\":\"Container\",\"aliases\":[\"Media\"],\"type\":{\"type\":\"enum\",\"name\":\"MediaContainer\",\"namespace\":\"AvroSchemaGenerator.Tests\",\"symbols\":[\"Flv\",\"Mp3\",\"Avi\",\"Mp4\"]}},{\"name\":\"Title\",\"type\":[\"null\",\"string\"],\"default\":null}]}],\"default\":null},{\"name\":\"Popular\",\"aliases\":[\"PopularMediaType\"],\"type\":{\"type\":\"enum\",\"name\":\"MediaType\",\"namespace\":\"AvroSchemaGenerator.Tests\",\"symbols\":[\"Video\",\"Audio\"]}},{\"name\":\"Movies\",\"aliases\":[\"MovieCollection\"],\"type\":[\"null\",{\"type\":\"array\",\"items\":{\"type\":\"record\",\"namespace\":\"AvroSchemaGenerator.Tests\",\"name\":\"MovieAliase\",\"aliases\":[\"Movies_Aliase\"],\"fields\":[{\"name\":\"Dated\",\"aliases\":[\"DateCreated\"],\"type\":\"long\"},{\"name\":\"Year\",\"aliases\":[\"ReleaseYear\"],\"type\":\"int\"},{\"name\":\"Month\",\"aliases\":[\"ReleaseMonth\"],\"type\":{\"type\":\"enum\",\"name\":\"Month\",\"namespace\":\"AvroSchemaGenerator.Tests\",\"symbols\":[\"January\",\"February\",\"March\",\"April\",\"June\",\"July\"]}}]}}]}]}";
var actual = typeof(ClassWithAliasesWithList).GetSchema();
_output.WriteLine(actual);
var schema = Schema.Parse(actual);
var writer = new ReflectWriter <ClassWithAliasesWithList>(schema);
Assert.Equal(expectSchema, actual);
}
public void TestEnums()
{
var expectSchema = "{\"type\":\"record\",\"namespace\":\"AvroSchemaGenerator.Tests\",\"name\":\"MediaStream\",\"fields\":[{\"name\":\"Id\",\"type\":[\"null\",\"string\"],\"default\":null},{\"name\":\"Title\",\"type\":[\"null\",\"string\"],\"default\":null},{\"name\":\"Type\",\"type\":{\"type\":\"enum\",\"name\":\"MediaType\",\"namespace\":\"AvroSchemaGenerator.Tests\",\"symbols\":[\"Video\",\"Audio\"]}},{\"name\":\"Container\",\"type\":{\"type\":\"enum\",\"name\":\"MediaContainer\",\"namespace\":\"AvroSchemaGenerator.Tests\",\"symbols\":[\"Flv\",\"Mp3\",\"Avi\",\"Mp4\"]}},{\"name\":\"Media\",\"type\":[\"null\",\"bytes\"],\"default\":null}]}";
var actual = typeof(MediaStream).GetSchema();
var schema = Schema.Parse(actual);
var writer = new ReflectWriter <MediaStream>(schema);
_output.WriteLine(actual);
Assert.Equal(expectSchema, actual);
}
private static void checkAlternateSerializers <T>(byte[] expected, T value, Schema ws)
{
var ms = new MemoryStream();
var writer = new ReflectWriter <T>(ws);
var e = new BinaryEncoder(ms);
writer.Write(value, e);
var output = ms.ToArray();
Assert.AreEqual(expected.Length, output.Length);
Assert.True(expected.SequenceEqual(output));
}
private sbyte[] Write <T>(T message, ReflectWriter <T> writer)
{
var ms = new MemoryStream();
Avro.IO.Encoder e = new BinaryEncoder(ms);
writer.Write(message, e);
ms.Flush();
ms.Position = 0;
var b = ms.ToArray();
return((sbyte[])(object)b);
}
private static Stream serialize <T>(Schema ws, T actual)
{
var ms = new MemoryStream();
Encoder e = new BinaryEncoder(ms);
var w = new ReflectWriter <T>(ws);
w.Write(actual, e);
ms.Flush();
ms.Position = 0;
checkAlternateSerializers(ms.ToArray(), actual, ws);
return(ms);
}
public void TestDictionaryRecursive()
{
try
{
var actual = typeof(DictionaryRecursive).GetSchema();
var schema = Schema.Parse(actual);
var writer = new ReflectWriter <DictionaryRecursive>(schema);
_output.WriteLine(actual);
}
catch (Exception ex)
{
_output.WriteLine(ex.ToString());
Assert.True(false);
}
}
public void HeterogeneousTest()
{
var heterogeneousSchema = @"
[
""string"",
""null"",
{ ""type"" : ""record"", ""name"" : ""Dervied2"", ""fields"" :
[
{ ""name"" : ""A"", ""type"" : ""string""},
{ ""name"" : ""C"", ""type"" : ""double""}
]
},
]
";
var schema = Schema.Parse(heterogeneousSchema);
var derived2write = new Derived2()
{
A = "derived2", C = 3.14
};
// union types (except for [null, type]) need to be manually registered
var unionSchema = schema as UnionSchema;
var cache = new ClassCache();
cache.LoadClassCache(typeof(Derived2), unionSchema[2]);
var writer = new ReflectWriter <object>(schema, cache);
var reader = new ReflectReader <object>(schema, schema, cache);
using (var stream = new MemoryStream(256))
{
var encoder = new BinaryEncoder(stream);
writer.Write(derived2write, encoder);
writer.Write("string value", encoder);
writer.Write(null, encoder);
stream.Seek(0, SeekOrigin.Begin);
var decoder = new BinaryDecoder(stream);
var derived2read = (Derived2)reader.Read(decoder);
var stringRead = (string)reader.Read(decoder);
var nullRead = reader.Read(decoder);
Assert.AreEqual(derived2read.A, derived2write.A);
Assert.AreEqual(derived2read.C, derived2write.C);
Assert.AreEqual(stringRead, "string value");
Assert.IsNull(nullRead);
}
}
public void TestRecursiveSchema()
{
try
{
var actual = typeof(Recursive).GetSchema();
var schema = Schema.Parse(actual);
_output.WriteLine(actual);
var recursive = new Recursive
{
Fo = new SimpleFoo
{
Age = 67,
Attending = true,
FactTime = 90909099L,
Id = new byte[0] {
},
Name = "Ebere",
Point = 888D,
Precision = 787F
},
Recurse = new Recursive
{
Fo = new SimpleFoo
{
Age = 6,
Attending = false,
FactTime = 90L,
Id = new byte[0] {
},
Name = "Ebere Abanonu",
Point = 88D,
Precision = 78F
},
}
};
var writer = new ReflectWriter <Recursive>(schema);
var reader = new ReflectReader <Recursive>(schema, schema);
var msgBytes = Write(recursive, writer);
using var stream = new MemoryStream((byte[])(object) msgBytes);
var msg = Read(stream, reader);
Assert.NotNull(msg);
}
catch (Exception ex)
{
_output.WriteLine(ex.ToString());
Assert.True(false);
}
}
public void RecurseTest()
{
var schema = Schema.Parse(_recurse);
var recursive = new Recursive
{
Fo = new SimpleFoo
{
Age = 67,
Attending = true,
FactTime = 90909099L,
Id = new byte[0] {
},
Name = "Ebere",
Point = 888D,
Precision = 787F
},
Recurse = new Recursive
{
Fo = new SimpleFoo
{
Age = 6,
Attending = false,
FactTime = 90L,
Id = new byte[0] {
},
Name = "Ebere Abanonu",
Point = 88D,
Precision = 78F
},
}
};
var writer = new ReflectWriter <Recursive>(schema);
var reader = new ReflectReader <Recursive>(schema, schema);
using (var stream = new MemoryStream(256))
{
writer.Write(recursive, new BinaryEncoder(stream));
stream.Seek(0, SeekOrigin.Begin);
var recursiveRead = reader.Read(new BinaryDecoder(stream));
Assert.IsTrue(recursiveRead.Fo.Attending);
Assert.AreEqual(recursiveRead.Recurse.Fo.Name, "Ebere Abanonu");
}
}
public void ListTest()
{
var schema = Schema.Parse(_simpleList);
var fixedRecWrite = new List <string>()
{
"value"
};
var writer = new ReflectWriter <List <string> >(schema);
var reader = new ReflectReader <List <string> >(schema, schema);
using (var stream = new MemoryStream(256))
{
writer.Write(fixedRecWrite, new BinaryEncoder(stream));
stream.Seek(0, SeekOrigin.Begin);
var fixedRecRead = reader.Read(new BinaryDecoder(stream));
Assert.IsTrue(fixedRecRead.Count == 1);
Assert.AreEqual(fixedRecWrite[0], fixedRecRead[0]);
}
}
public void BaseClassTest()
{
var schema = Schema.Parse(BaseClassSchema);
var derived1write = new Derived1()
{
A = "derived1", B = 7
};
var derived2write = new Derived2()
{
A = "derived2", C = 3.14
};
// union types (except for [null, type]) need to be manually registered
var unionSchema = schema as UnionSchema;
var cache = new ClassCache();
cache.LoadClassCache(typeof(Derived1), unionSchema[0]);
cache.LoadClassCache(typeof(Derived2), unionSchema[1]);
var x = schema as RecordSchema;
var writer = new ReflectWriter <BaseClass>(schema, cache);
var reader = new ReflectReader <BaseClass>(schema, schema, cache);
using (var stream = new MemoryStream(256))
{
var encoder = new BinaryEncoder(stream);
writer.Write(derived1write, encoder);
writer.Write(derived2write, encoder);
stream.Seek(0, SeekOrigin.Begin);
var decoder = new BinaryDecoder(stream);
var derived1read = (Derived1)reader.Read(decoder);
var derived2read = (Derived2)reader.Read(decoder);
Assert.AreEqual(derived1read.A, derived1write.A);
Assert.AreEqual(derived1read.B, derived1write.B);
Assert.AreEqual(derived2read.A, derived2write.A);
Assert.AreEqual(derived2read.C, derived2write.C);
}
}
public Z SerializeDeserialize(Z z)
{
try
{
Protocol protocol = Protocol.Parse(_avroTestSchemaV1);
Schema schema = null;
foreach (var s in protocol.Types)
{
if (s.Name == "Z")
{
schema = s;
}
}
var avroWriter = new ReflectWriter <Z>(schema);
var avroReader = new ReflectReader <Z>(schema, schema);
byte[] serialized;
using (var stream = new MemoryStream(256))
{
avroWriter.Write(z, new BinaryEncoder(stream));
serialized = stream.ToArray();
}
Z deserialized = null;
using (var stream = new MemoryStream(serialized))
{
deserialized = avroReader.Read(default(Z), new BinaryDecoder(stream));
}
return(deserialized);
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
throw ex;
}
}
public void NestedTypesProduceValidAvroSchema()
{
try
{
var simple = typeof(NestedSchema).GetSchema();
_output.WriteLine(simple);
var schema = Schema.Parse(simple);
var data = new NestedSchema
{
Foo = new RecType
{
Name = "Foo-Name",
Child = new RecType
{
Name = "Foo Grand Child"
}
},
Bar = new RecType
{
Name = "Bar-Name",
Child = new RecType
{
Name = "Bar Grand Child"
}
}
};
var reader = new ReflectReader <NestedSchema>(schema, schema);
var writer = new ReflectWriter <NestedSchema>(schema);
var msgBytes = Write(data, writer);
using var stream = new MemoryStream((byte[])(object) msgBytes);
var msg = Read(stream, reader);
Assert.NotNull(msg);
Assert.True(msg.Foo.Name == "Foo-Name");
}
catch (Exception ex)
{
_output.WriteLine(ex.ToString());
}
}
public void NullableTest()
{
var nullableSchema = @"
[
""null"",
{ ""type"" : ""record"", ""name"" : ""Dervied2"", ""fields"" :
[
{ ""name"" : ""A"", ""type"" : ""string""},
{ ""name"" : ""C"", ""type"" : ""double""}
]
},
]
";
var schema = Schema.Parse(nullableSchema);
var derived2write = new Derived2()
{
A = "derived2", C = 3.14
};
var writer = new ReflectWriter <Derived2>(schema);
var reader = new ReflectReader <Derived2>(schema, schema);
using (var stream = new MemoryStream(256))
{
var encoder = new BinaryEncoder(stream);
writer.Write(derived2write, encoder);
writer.Write(null, encoder);
stream.Seek(0, SeekOrigin.Begin);
var decoder = new BinaryDecoder(stream);
var derived2read = reader.Read(decoder);
var derived2null = reader.Read(decoder);
Assert.AreEqual(derived2read.A, derived2write.A);
Assert.AreEqual(derived2read.C, derived2write.C);
Assert.IsNull(derived2null);
}
}
public void ListRecTest()
{
var schema = Schema.Parse(_recordList);
var fixedRecWrite = new List <ListRec>()
{
new ListRec()
{
S = "hello"
}
};
var writer = new ReflectWriter <List <ListRec> >(schema);
var reader = new ReflectReader <List <ListRec> >(schema, schema);
using (var stream = new MemoryStream(256))
{
writer.Write(fixedRecWrite, new BinaryEncoder(stream));
stream.Seek(0, SeekOrigin.Begin);
var fixedRecRead = reader.Read(new BinaryDecoder(stream));
Assert.IsTrue(fixedRecRead.Count == 1);
Assert.AreEqual(fixedRecWrite[0].S, fixedRecRead[0].S);
}
}
public void GenericFixedDefaultConverter()
{
var schema = Schema.Parse(_fixedSchema);
var rs = schema as RecordSchema;
FixedSchema fs = null;
foreach (var f in rs.Fields)
{
if (f.Name == "myFixed")
{
fs = f.Schema as FixedSchema;
}
}
var fixedRecWrite = new GenericFixedRec()
{
myFixed = new GenericFixed(fs)
{
Value = new byte[16] {
1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6
}
}
};
GenericFixedRec fixedRecRead = null;
ClassCache.AddDefaultConverter <byte[], GenericFixed>((a, s) => new GenericFixed(s as FixedSchema, a), (p, s) => p.Value);
var writer = new ReflectWriter <GenericFixedRec>(schema);
var reader = new ReflectReader <GenericFixedRec>(schema, schema);
using (var stream = new MemoryStream(256))
{
writer.Write(fixedRecWrite, new BinaryEncoder(stream));
stream.Seek(0, SeekOrigin.Begin);
fixedRecRead = reader.Read(null, new BinaryDecoder(stream));
Assert.IsTrue(fixedRecRead.myFixed.Value.Length == 16);
Assert.IsTrue(fixedRecWrite.myFixed.Value.SequenceEqual(fixedRecRead.myFixed.Value));
}
}
