| /** |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * https://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| using System.IO; |
| using Avro.IO; |
| using Avro.Generic; |
| using Avro.Reflect; |
| using NUnit.Framework; |
| |
| namespace Avro.Test |
| { |
| |
| [TestFixture] |
| public class TestFixed |
| { |
| public class ByteArrayFixedRec |
| { |
| public byte[] myFixed { get; set; } |
| } |
| |
| public class GenericFixedRec |
| { |
| public GenericFixed myFixed { get; set; } |
| } |
| |
| public class GenericFixedConverter : TypedFieldConverter<byte[],GenericFixed> |
| { |
| public override GenericFixed From(byte[] o, Schema s) |
| { |
| return new GenericFixed(s as FixedSchema, o); |
| } |
| |
| public override byte[] To(GenericFixed o, Schema s) |
| { |
| return o.Value; |
| } |
| } |
| |
| public class GenericFixedConverterRec |
| { |
| [AvroField(typeof(GenericFixedConverter))] |
| public GenericFixed myFixed { get; set; } |
| } |
| private const string _fixedSchema = @" |
| { |
| ""namespace"": ""MessageTypes"", |
| ""type"": ""record"", |
| ""doc"": ""A simple type with a fixed."", |
| ""name"": ""A"", |
| ""fields"": [ |
| { ""name"" : ""myFixed"", ""type"" : |
| { |
| ""type"": ""fixed"", |
| ""size"": 16, |
| ""name"": ""MyFixed"" |
| } |
| } |
| ] |
| }"; |
| |
| [TestCase] |
| 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)); |
| } |
| } |
| |
| [TestCase] |
| public void GenericFixedConverterTest() |
| { |
| 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 GenericFixedConverterRec() { myFixed = new GenericFixed(fs) {Value = new byte[16] {1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6} }}; |
| GenericFixedConverterRec fixedRecRead = null; |
| |
| var writer = new ReflectWriter<GenericFixedConverterRec>(schema); |
| var reader = new ReflectReader<GenericFixedConverterRec>(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)); |
| } |
| } |
| |
| [TestCase] |
| 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)); |
| } |
| } |
| } |
| } |