public void TestBinaryGenUnsafeRead()
{
var bd = new BinaryDeserializerGen();
binaryStream.Position = 0;
var p = bd.FromReader <SamplePerson>(new UnsafeBinaryReader(binaryStream));
Assert.AreEqual(person.Name, p.Name);
}
public void TestBinaryGenStructPropRead()
{
var bd = new BinaryDeserializerGen();
bsStructProp.Position = 0;
var p = bd.FromReader <List <SampleStructWithProps> >(new BinaryReader(bsStructProp));
Assert.AreEqual(101, p[101].P.X);
}
public void TestBinaryGenRead()
{
var bd = new BinaryDeserializerGen();
binaryStream.Position = 0;
var p = bd.FromStream <SamplePerson>(binaryStream);
//var p = new SamplePerson();
//bd.FromStream(p, binaryStream);
Assert.AreEqual(person.Name, p.Name);
}
public void TestArray()
{
var bs = new BinarySerializer();
var bd = new BinaryDeserializer();
var bdg = new BinaryDeserializerGen();
var v0 = new SampleArray { A = new string[] { "a", "b", "c" } };
var result0 = bs.ToBytes(v0);
Assert.AreEqual(
"20 01 00 " + XS(typeof(SampleArray)) + " 01 00 " + XS("A", RoughType.Sequence) +
" 10 01 00 03 00 00 00 " + XS("a", "b", "c") + " 00 00",
XS(result0));
var w0 = new SampleArray();
bd.FromBytes(w0, result0);
CollectionAssert.AreEqual(v0.A, w0.A);
var w0g = (SampleArray)bdg.FromBytes(result0);
CollectionAssert.AreEqual(v0.A, w0g.A);
var v2 = new SampleArray();
var result2 = bs.ToBytes(v2);
Assert.AreEqual("20 01 00 01 00 FF FF FF FF 00 00", XS(result2));
var w2 = new SampleArray();
bd.FromBytes(w2, result2);
CollectionAssert.AreEqual(v2.A, w2.A);
var w2g = (SampleArray)bdg.FromBytes(result2);
CollectionAssert.AreEqual(v2.A, w2g.A);
}
public void TestInterface()
{
var bs = new BinarySerializer();
var v1 = new SampleInterfaceField { I = new SampleInterfaced { X = 34 } };
var result1 = bs.ToBytes(v1);
Assert.AreEqual(
"20 01 00 " + XS(typeof(SampleInterfaceField)) + " 01 00 " + XS("I", RoughType.Record) +
" 01 00 02 00 " + XS(typeof(SampleInterfaced)) + " 01 00 " + XS("X", RoughType.Int) +
" 01 00 22 00 00 00 00 00 00 00",
XS(result1));
var w1 = new SampleInterfaceField();
var bd = new BinaryDeserializer();
bd.FromBytes(w1, result1);
Assert.IsInstanceOfType(w1.I, typeof(SampleInterfaced));
Assert.AreEqual(34, w1.I.X);
var w1g = new SampleInterfaceField();
var bdg = new BinaryDeserializerGen();
bdg.FromBytes(w1g, result1);
Assert.IsInstanceOfType(w1g.I, typeof(SampleInterfaced));
Assert.AreEqual(34, w1g.I.X);
var w1n = (SampleInterfaceField)bd.FromBytes(new byte[] { 0x20, 01, 00, 01, 00, 00, 00, 00, 00 });
Assert.AreEqual(null, w1n.I);
var w1ng = (SampleInterfaceField)bdg.FromBytes(new byte[] { 0x20, 01, 00, 01, 00, 00, 00, 00, 00 });
Assert.AreEqual(null, w1ng.I);
var v2 = new List<ISample> { null, new SampleInterfaced { X = 37 } };
var result2 = bs.ToBytes(v2);
Assert.AreEqual("21 20 02 00 00 00 00 00 02 00 01 00 25 00 00 00 00 00", XS(result2));
var w2 = new List<ISample>();
bd.FromBytes(w2, result2);
Assert.AreEqual(2, w2.Count);
Assert.IsNull(w2[0]);
Assert.AreEqual(37, w2[1].X);
ISampleField v3 = new SampleInterfacedField { X = 41 };
var result3 = bs.ToBytes(v3);
Assert.AreEqual(
"20 03 00 " + XS(typeof(SampleInterfacedField)) + " 01 00 " + XS("X", RoughType.Int) +
" 01 00 29 00 00 00 00 00", XS(result3));
var w3 = (ISampleField)bd.FromBytes(result3);
Assert.AreEqual(41, w3.X);
}
public void TestGenerated()
{
var str =
"20 01 00 " + XS(typeof(Sample3)) + " 03 00 " +
XS("S1", RoughType.Record, "F", RoughType.Int, "S2", RoughType.Record) +
" 01 00 02 00 " + XS(typeof(Sample1)) +
" 02 00 " + XS("X", RoughType.Int, "Y", RoughType.String) +
" 01 00 59 01 00 00 02 00 " + XS("test") + " 00 00 " +
"02 00 DE 00 00 00 " +
"03 00 03 00 " + XS(typeof(Sample2)) +
" 02 00 " + XS("X", RoughType.Int, "Y", RoughType.String) +
" 01 00 A6 FE FF FF 02 00 " + XS("test1") + " 00 00 00 00";
var bd = new BinaryDeserializerGen();
bd.Options.TagMode = TagMode.Names;
var w = (Sample3)bd.FromBytes(SX(str));
Assert.AreEqual(345, w.S1.X);
Assert.AreEqual("test", w.S1.Y);
Assert.AreEqual(222, w.F);
Assert.AreEqual(-346, w.S2.X);
Assert.AreEqual("test1", w.S2.Y);
var w1 = new Sample1();
bd.FromBytes(w1, SX("20 02 00 01 00 58 00 00 00 00 00"));
Assert.IsInstanceOfType(w1, typeof(Sample1));
Assert.AreEqual(88, w1.X);
var w2 = bd.FromBytes(SX("20 02 00 01 00 63 00 00 00 00 00"));
Assert.IsInstanceOfType(w2, typeof(Sample1));
Assert.AreEqual(99, ((Sample1)w2).X);
var w3 = new SampleMemberI();
bd.FromBytes(w3, SX(
"20 04 00 " + XS(typeof(SampleMemberI)) + " 01 00 " + XS("X", RoughType.Int) + " 00 00"));
Assert.AreEqual(71, ((SampleMemberI)w3).X);
}
public void TestDefault()
{
var bs = new BinarySerializer();
var bd = new BinaryDeserializer();
var bdg = new BinaryDeserializerGen();
var v1 = new Sample1 { X = 6, Y = "ttt" };
var result1 = bs.ToBytes(v1);
Assert.AreEqual(
"20 01 00 " + XS(typeof(Sample1)) + " 02 00 " +
XS("X", RoughType.Int, "Y", RoughType.String) +
" 01 00 06 00 00 00 00 00", XS(result1));
var w1 = (Sample1)bd.FromBytes(result1);
Assert.AreEqual(6, w1.X);
Assert.AreEqual("zzz", w1.Y);
var w1g = (Sample1)bdg.FromBytes(result1);
Assert.AreEqual(6, w1g.X);
Assert.AreEqual("zzz", w1g.Y);
var v2 = new Sample2 { X = 5, Y = "5" };
var result2 = bs.ToBytes(v2);
Assert.AreEqual(
"20 02 00 " + XS(typeof(Sample2)) + " 02 00 " +
XS("X", RoughType.Int, "Y", RoughType.String) +
" 01 00 05 00 00 00 00 00", XS(result2));
Assert.IsInstanceOfType(bd.FromBytes(result2), typeof(Sample2));
var v3 = new SampleDefault();
var result3 = bs.ToBytes(new SampleDefault());
Assert.AreEqual(
"20 03 00 " + XS(typeof(SampleDefault)) + " 03 00 " +
XS("A", RoughType.Int, "B", RoughType.String, "P", RoughType.Record) + " 00 00",
XS(result3));
Assert.IsInstanceOfType(bd.FromBytes(result3), typeof(SampleDefault));
v3.B = "z";
var result3m = bs.ToBytes(v3);
Assert.AreEqual("20 03 00 02 00 " + XS("z") + " 00 00", XS(result3m));
var w3 = new SampleDefault();
bd.FromBytes(w3, result3m);
Assert.AreEqual(3, w3.A);
Assert.AreEqual("z", w3.B);
Assert.AreEqual(new SamplePoint { X = 7, Y = 2 }, w3.P);
var result4 = SX(
"20 01 00 " + XS(typeof(SampleDefault)) + " 02 00 " +
XS("A", RoughType.Int, "P", RoughType.Record) + " 01 00 05 00 00 00 " +
"02 00 02 00 " + XS(typeof(SamplePoint)) + " 02 00 " +
XS("X", RoughType.Int, "Y", RoughType.Int) + " 04 00 00 00 06 00 00 00 " +
"00 00"
);
bdg.ClearClassIds();
var w4 = bdg.FromBytes<SampleDefault>(result4);
Assert.AreEqual(5, w4.A);
Assert.AreEqual("default", w4.B);
Assert.AreEqual(new SamplePoint { X = 4, Y = 6 }, w4.P);
}
public void TestStruct()
{
var v = new SampleRect {
A = new SamplePoint { X = 33, Y = 44 },
B = new SamplePoint { X = 55, Y = 66 },
};
var bs = new BinarySerializer();
var result = bs.ToBytes(v);
Assert.AreEqual(
"20 01 00 " + XS(typeof(SampleRect)) + " 02 00 " +
XS("A", RoughType.Record, "B", RoughType.Record) +
" 01 00 02 00 " + XS(typeof(SamplePoint)) + " 02 00 " +
XS("X", RoughType.Int, "Y", RoughType.Int) +
" 21 00 00 00 2C 00 00 00 " +
"02 00 02 00 37 00 00 00 42 00 00 00 00 00",
XS(result));
var bd = new BinaryDeserializer();
var w = new SampleRect();
bd.FromBytes(w, result);
CheckSampleRect(v, w);
var bdg = new BinaryDeserializerGen();
w = (SampleRect)bdg.FromBytes(result);
CheckSampleRect(v, w);
var p = (SamplePoint)bdg.FromBytes(new SamplePoint(), SX("20 02 00 22 00 00 00 2D 00 00 00"));
Assert.AreEqual(34, p.X);
Assert.AreEqual(45, p.Y);
}
public void TestNullField()
{
var bs = new BinarySerializer();
var sample = new SampleWithNullField();
var result = bs.ToBytes(sample);
Assert.AreEqual(
"20 01 00 " + XS(typeof(SampleWithNullField)) + " 01 00 " + XS("About", RoughType.String) +
" 01 00 00 01 00 00",
XS(result));
var bd = new BinaryDeserializer();
var bdg = new BinaryDeserializerGen();
var w = new SampleWithNullField { About = "zzz" };
bd.FromBytes(w, result);
Assert.AreEqual(sample.About, w.About);
bd.FromBytes(w, new byte[] { 0x20, 01, 00, 01, 00, 00, 00, 00, 00 });
Assert.AreEqual("", w.About);
var wg = (SampleWithNullFieldCompact)bdg.FromBytes(SX(
"20 01 00 " + XS(typeof(SampleWithNullFieldCompact)) + " 01 00 " + XS("N", RoughType.Record) +
" 00 00 00 00"));
Assert.AreEqual(null, wg.N);
}
public void TestNullable()
{
var bs = new BinarySerializer();
var bd = new BinaryDeserializer();
var bdg = new BinaryDeserializerGen();
var v1 = new SampleNullable { N = null };
var result1 = bs.ToBytes(v1);
Assert.AreEqual(
"20 01 00 " + XS(typeof(SampleNullable)) + " 01 00 " + XS("N", RoughType.Nullable) + " 05 " +
"01 00 01 00 00",
XS(result1));
var w1 = bd.FromBytes<SampleNullable>(result1);
Assert.AreEqual(v1.N, w1.N);
var w1g = bdg.FromBytes<SampleNullable>(result1);
Assert.AreEqual(v1.N, w1g.N);
var v2 = new SampleNullable { N = 997 };
var result2 = bs.ToBytes(v2);
Assert.AreEqual(
"20 01 00 01 00 00 E5 03 00 00 00 00",
XS(result2));
var w2 = bd.FromBytes<SampleNullable>(result2);
Assert.AreEqual(v2.N, w2.N);
var w2g = bdg.FromBytes<SampleNullable>(result2);
Assert.AreEqual(v2.N, w2g.N);
var v3 = new List<SamplePoint?> { new SamplePoint { X = -1, Y = -2 }, null };
var result3 = bs.ToBytes(v3);
Assert.AreEqual(
"21 12 20 02 00 00 00 00 02 00 " + XS(typeof(SamplePoint)) + " 02 00 " +
XS("X", RoughType.Int, "Y", RoughType.Int) + " FF FF FF FF FE FF FF FF 01",
XS(result3));
var w3 = bd.FromBytes<List<SamplePoint?>>(result3);
Assert.AreEqual(v3.Count, w3.Count);
Assert.AreEqual(v3[0].Value.X, w3[0].Value.X);
Assert.AreEqual(v3[0].Value.Y, w3[0].Value.Y);
Assert.IsNull(w3[1]);
}
public void TestBinaryGenUnsafeRead()
{
var bd = new BinaryDeserializerGen();
binaryStream.Position = 0;
var p = bd.FromReader<SamplePerson>(new UnsafeBinaryReader(binaryStream));
Assert.AreEqual(person.Name, p.Name);
}
public void TestBinaryGenRead()
{
var bd = new BinaryDeserializerGen();
binaryStream.Position = 0;
var p = bd.FromStream<SamplePerson>(binaryStream);
//var p = new SamplePerson();
//bd.FromStream(p, binaryStream);
Assert.AreEqual(person.Name, p.Name);
}
