public void UnresolvedSubtypeMemberDeserializationYieldsNull()
{
var serializer = new BinaryDataSerializer();
var ingredients = serializer.Deserialize <Ingredients>(new byte[] { 0x4 });
Assert.IsNull(ingredients.MainIngredient);
}
public void NonSeekableStreamDeserializationTest()
{
var stream = new NonSeekableStream();
var serializer = new BinaryDataSerializer();
serializer.Serialize(stream, new Iron());
}
public void NonSeekableStreamWithOffsetAttributeShouldThrowInvalidOperationException()
{
var stream = new NonSeekableStream();
var serializer = new BinaryDataSerializer();
Assert.ThrowsException <InvalidOperationException>(() => serializer.Serialize(stream, Cerealize()));
}
public void ShouldThrowIOExceptionNotInvalidOperationExceptionTest()
{
var stream = new UnreadableStream();
var serializer = new BinaryDataSerializer();
Assert.ThrowsException <IOException>(() => serializer.Deserialize <int>(stream));
}
//[TestMethod]
public void DeserializeMessageTest()
{
var serializer = new BinaryDataSerializer {
Endianness = BinaryDataSerialization.Endianness.Little
};
serializer.MemberDeserializing +=
(sender, args) => { Debug.Write($"Deserializing {args.MemberName}, stream offset {args.Offset}"); };
serializer.MemberDeserialized +=
(sender, args) =>
{
Debug.Write($"Deserialized {args.MemberName}, ({args.Value ?? "null"}), stream offset {args.Offset}");
};
var inBytes = new byte[]
{
0x02, 0x00, 0x78, 0xFF, 0x00, 0x00, 0x30, 0x60, 0x03, 0x01
};
using (var stream = new MemoryStream(inBytes))
{
var actualObj = serializer.Deserialize <MachineState1>(stream);
Assert.IsNull(actualObj);
}
}
public void NullGraphSerializationShouldSerializeNothing()
{
var serializer = new BinaryDataSerializer();
var stream = new MemoryStream();
serializer.Serialize(stream, null);
Assert.AreEqual(0, stream.Length);
}
public async void DontFlushTooMuchTest()
{
var serializer = new BinaryDataSerializer();
var expected = new DontFlushTooMuchClass();
var stream = new UnflushableStream();
serializer.Serialize(stream, expected);
await serializer.SerializeAsync(stream, expected);
}
public void ImplicitTermination()
{
var data = new byte[] { 0x0, 0x1, 0x2, 0x3 };
var serializer = new BinaryDataSerializer();
var byteList = serializer.Deserialize <ImplictTermination>(data);
Assert.AreEqual(4, byteList.Data.Count);
}
public void ProtocolClassTest()
{
var bytes = new byte[] { 0xff, 0x0f };
BinaryDataSerializer serializer = new BinaryDataSerializer();
var protocol = serializer.Deserialize <ProtocolClass>(bytes);
Assert.AreEqual(0x01, protocol.Header.ITEM1);
Assert.AreEqual(0x7f, protocol.Header.ITEM2);
Assert.AreEqual(0x01, protocol.Header.ITEM3);
Assert.AreEqual(0x07, protocol.Header.ITEM4);
}
public void LargeArrayTest()
{
var ser = new BinaryDataSerializer();
var data = new byte[65536 * sizeof(int) * 2];
ser.Deserialize <IntArray64K>(data);
using (var ms = new MemoryStream(data))
{
ser.Deserialize <IntArray64K>(ms);
}
}
public void UnknownTypeSerializationTest()
{
var unknownTypeClass = new UnknownTypeClass {
Field = "hello"
};
var serializer = new BinaryDataSerializer();
var stream = new MemoryStream();
serializer.Serialize(stream, unknownTypeClass);
}
public void SubtypesOnUnknownTypeFieldShouldThrowBindingException()
{
var unknownTypeClass = new InvalidUnknownTypeClass {
Field = "hello"
};
var serializer = new BinaryDataSerializer();
var stream = new MemoryStream();
Assert.ThrowsException <BindingException>(() => serializer.Serialize(stream, unknownTypeClass));
}
public void SerializeObject()
{
var order = new MainDataOne();
order.Name = "Test";
var serializerTests = new BinaryDataSerializer();
var data = serializerTests.Serialize(order);
var orderResult = (IMainData)serializerTests.Deserialize(typeof(MainDataOne), data);
Assert.AreNotSame(order, orderResult);
Assert.AreEqual("Test", orderResult.Name);
}
public void CustomWithContextTest()
{
var expected = new CustomWithContextContainerClass {
Value = new CustomWithContextClass()
};
var serializer = new BinaryDataSerializer();
var stream = new MemoryStream();
serializer.Serialize(stream, expected, "context");
stream.Position = 0;
serializer.Deserialize <CustomWithContextContainerClass>(stream);
}
public void TestPrematureStreamTermination()
{
var serializer = new BinaryDataSerializer {
Endianness = BinaryDataSerialization.Endianness.Little
};
var inBytes = new byte[] { 0x01, 0x00, 0x00, 0x00, 0x40, 0x34 };
using (var stream = new MemoryStream(inBytes))
{
var actualObj = serializer.Deserialize <LoadCarrierData>(stream);
Assert.IsNull(actualObj);
}
}
public void SerializerEndiannessTest()
{
var serializer = new BinaryDataSerializer {
Endianness = BinaryDataSerialization.Endianness.Big
};
var expected = new EndiannessClass {
Short = 1
};
var stream = new MemoryStream();
serializer.Serialize(stream, expected);
var data = stream.ToArray();
Assert.AreEqual(0x1, data[1]);
}
public void TestInitialize()
{
dataFiller = new RandomDataFiller()
{
NumberOfBooks = 100,
NumberOfBookStates = 200,
NumberOfBookReaders = 50,
NumberOfEvents = 150
};
context = new DataContext();
dataFiller.Fill(ref context);
fileName = "binary_data.bin";
binarySerializer = new BinaryDataSerializer()
{
FileName = fileName
};
}
public void RoundtripTest()
{
var serializer = new BinaryDataSerializer {
Endianness = BinaryDataSerialization.Endianness.Big
};
var expected = new MsgHeader {
PayloadType = PlcPayloadType.Value3
};
var stream = new MemoryStream();
serializer.Serialize(stream, expected);
stream.Position = 0;
var actual = serializer.Deserialize <MsgHeader>(stream);
Assert.AreEqual(expected.PayloadType, actual.PayloadType);
}
public void BindingAcrossUnknownBoundaryTest()
{
var childClass = new BindingAcrossUnknownBoundaryChildClass {
Subfield = "hello"
};
var unknownTypeClass = new BindingAcrossUnknownBoundaryClass
{
Field = childClass
};
var serializer = new BinaryDataSerializer();
var stream = new MemoryStream();
serializer.Serialize(stream, unknownTypeClass);
var data = stream.ToArray();
Assert.AreEqual((byte)childClass.Subfield.Length, data[0]);
}
public void Test()
{
var source = new ChunkContainer
{
ChunkType = "TEST",
Chunk = new TestChunk
{
Customs = new[]
{
new CustomSerializable
{
Value = 1
},
new CustomSerializable
{
Value = 2
}
}
}
};
Roundtrip(source);
var serializer = new BinaryDataSerializer();
var outputStream = new MemoryStream();
serializer.Serialize(outputStream, source);
outputStream.Seek(0, SeekOrigin.Begin);
var inputStream = new LooksLikeANetworkStream(outputStream); //non-seekable stream
//var inputStream = outputStream; //successful
var roundtrip = serializer.Deserialize <ChunkContainer>(inputStream);
//Assert.That(roundtrip.Chunk, Is.InstanceOf<TestChunk>());
//var sourceChunk = (TestChunk)source.Chunk;
//var testChunk = (TestChunk)roundtrip.Chunk;
//Assert.That(testChunk.Customs.Length, Is.EqualTo(sourceChunk.Customs.Length));
//Assert.That(testChunk.Customs.ElementAt(0).Value, Is.EqualTo(sourceChunk.Customs.ElementAt(0).Value));
//Assert.That(testChunk.Customs.ElementAt(1).Value, Is.EqualTo(sourceChunk.Customs.ElementAt(1).Value));
}
public void DeserializeMessage()
{
var serializer = new BinaryDataSerializer {
Endianness = BinaryDataSerialization.Endianness.Little
};
var inBytes = new byte[]
{
0xFE, 0x31, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x02, Convert.ToByte('E'), Convert.ToByte('m'), Convert.ToByte('p'), Convert.ToByte('t'),
Convert.ToByte('y'), 0x00
};
var expected = new Bin3Data
{
BinType = 254,
Ident = "1",
Occupancy = BinOccupancy.Full,
OccupancyString = BinOccupancy.Empty
};
using (var stream = new MemoryStream())
{
serializer.Serialize(stream, expected);
}
//Assert.AreEqual(inBytes, actualBytes, "Objects are not equal");
Bin3Data actual;
using (var stream = new MemoryStream(inBytes))
{
actual = serializer.Deserialize <Bin3Data>(stream);
}
Assert.AreEqual(expected.BinType, actual.BinType);
Assert.AreEqual(expected.Ident, actual.Ident);
Assert.AreEqual(expected.Occupancy, actual.Occupancy);
Assert.AreEqual(expected.OccupancyString, actual.OccupancyString);
}
public void ContextTest()
{
var contextClass = new ContextClass();
var serializer = new BinaryDataSerializer();
var context = new Context {
SerializeCondtion = false
};
var stream = new MemoryStream();
serializer.Serialize(stream, contextClass, context);
context = new Context {
SerializeCondtion = true
};
stream = new MemoryStream();
serializer.Serialize(stream, contextClass, context);
Assert.AreEqual(sizeof(int), stream.Length);
}
public void NullStreamSerializationShouldThrowArgumentNullException()
{
var serializer = new BinaryDataSerializer();
Assert.ThrowsException <ArgumentNullException>(() => serializer.Serialize(null, new object()));
}
public void TestSerializeEvents()
{
var serializer = new BinaryDataSerializer();
var events = new List <MemberSerializingEventArgs>();
serializer.MemberSerializing += (sender, args) => events.Add(args);
serializer.MemberSerialized += (sender, args) => events.Add(args);
var stream = new MemoryStream();
serializer.Serialize(stream,
new EventTestClass
{
InnerClass = new EventTestInnerClass
{
InnerClass = new EventTestInnerInnerClass()
}
});
Assert.AreEqual("Length", events[0].MemberName);
Assert.AreEqual(typeof(MemberSerializingEventArgs), events[0].GetType());
Assert.AreEqual(0, (int)events[0].Offset.ByteCount);
Assert.AreEqual(0, (int)events[0].LocalOffset.ByteCount);
Assert.AreEqual("Length", events[1].MemberName);
Assert.AreEqual(typeof(MemberSerializedEventArgs), events[1].GetType());
Assert.AreEqual(4, (int)events[1].Offset.ByteCount);
Assert.AreEqual(4, (int)events[1].LocalOffset.ByteCount);
Assert.AreEqual("InnerClass", events[2].MemberName);
Assert.AreEqual(typeof(MemberSerializingEventArgs), events[2].GetType());
Assert.AreEqual(4, (int)events[2].Offset.ByteCount);
Assert.AreEqual(4, (int)events[2].LocalOffset.ByteCount);
Assert.AreEqual("Length", events[3].MemberName);
Assert.AreEqual(typeof(MemberSerializingEventArgs), events[3].GetType());
Assert.AreEqual(4, (int)events[3].Offset.ByteCount);
Assert.AreEqual(0, (int)events[3].LocalOffset.ByteCount);
Assert.AreEqual("Length", events[4].MemberName);
Assert.AreEqual(typeof(MemberSerializedEventArgs), events[4].GetType());
Assert.AreEqual(8, (int)events[4].Offset.ByteCount);
Assert.AreEqual(4, (int)events[4].LocalOffset.ByteCount);
Assert.AreEqual("InnerClass", events[5].MemberName);
Assert.AreEqual(typeof(MemberSerializingEventArgs), events[5].GetType());
Assert.AreEqual(8, (int)events[5].Offset.ByteCount);
Assert.AreEqual(4, (int)events[5].LocalOffset.ByteCount);
Assert.AreEqual("Value", events[6].MemberName);
Assert.AreEqual(typeof(MemberSerializingEventArgs), events[6].GetType());
Assert.AreEqual(8, (int)events[6].Offset.ByteCount);
Assert.AreEqual(0, (int)events[6].LocalOffset.ByteCount);
Assert.AreEqual("Value", events[7].MemberName);
Assert.AreEqual(typeof(MemberSerializedEventArgs), events[7].GetType());
Assert.AreEqual(10, (int)events[7].Offset.ByteCount);
Assert.AreEqual(2, (int)events[7].LocalOffset.ByteCount);
Assert.AreEqual("InnerClass", events[8].MemberName);
Assert.AreEqual(typeof(MemberSerializedEventArgs), events[8].GetType());
Assert.AreEqual(10, (int)events[8].Offset.ByteCount);
Assert.AreEqual(6, (int)events[8].LocalOffset.ByteCount);
Assert.AreEqual("InnerClass", events[9].MemberName);
Assert.AreEqual(typeof(MemberSerializedEventArgs), events[9].GetType());
Assert.AreEqual(10, (int)events[9].Offset.ByteCount);
Assert.AreEqual(10, (int)events[9].LocalOffset.ByteCount);
}
public MessageSerializer()
{
_binSerializer = new BinaryDataSerializer {
Endianness = BinaryDataSerialization.Endianness.Big
};
}
static DomPersistence()
{
serializer = new BinaryDataSerializer(new CodeDomDataContext());
}
