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)); } }