public void TestNestedGeneric()
{
var s = new XmSerializerModel();
s.AddType(typeof(GenericTestClass <, ,>));
var obj = new GenericTestClass <string, int, bool>();
obj.Field1 = "test";
obj.Field2 = 5;
obj.Field3 = true;
var obj2 = new GenericTestClass <string, GenericTestClass <string, int, bool>, int>
{
Field1 = "ff",
Field2 = obj,
Field3 = 12
};
var result = BasicTest.TestSerialization(obj2, s);
Assert.AreEqual(result.Field1, obj2.Field1);
Assert.AreEqual(result.Field2.Field1, obj.Field1);
Assert.AreEqual(result.Field2.Field2, obj.Field2);
Assert.AreEqual(result.Field2.Field3, obj.Field3);
Assert.AreEqual(result.Field3, obj2.Field3);
}
public void TestTuple()
{
var dto = new TupleTestClass
{
Foo = new Tuple <string, List <string> >("Foo", new List <string> {
"Foo", "Bar"
}),
Bar = new Tuple <int, int, int, int, int, int, int, Tuple <int, int> >(1, 2, 3, 4, 5, 6, 7, new Tuple <int, int>(8, 9))
};
var s = new XmSerializerModel();
s.AddType(typeof(TupleTestClass));
var result = BasicTest.TestSerialization(dto, s);
Assert.AreEqual(dto.Foo.Item1, result.Foo.Item1);
Assert.AreEqual(dto.Foo.Item2[0], result.Foo.Item2[0]);
Assert.AreEqual(dto.Foo.Item2[1], result.Foo.Item2[1]);
Assert.AreEqual(dto.Bar.Item1, result.Bar.Item1);
Assert.AreEqual(dto.Bar.Item2, result.Bar.Item2);
Assert.AreEqual(dto.Bar.Item3, result.Bar.Item3);
Assert.AreEqual(dto.Bar.Item4, result.Bar.Item4);
Assert.AreEqual(dto.Bar.Item5, result.Bar.Item5);
Assert.AreEqual(dto.Bar.Item6, result.Bar.Item6);
Assert.AreEqual(dto.Bar.Item7, result.Bar.Item7);
Assert.AreEqual(dto.Bar.Rest.Item1, result.Bar.Rest.Item1);
Assert.AreEqual(dto.Bar.Rest.Item2, result.Bar.Rest.Item2);
}
public void TestValueTuple()
{
var dto = new ValueTupleTestClass
{
Foo = ("Foo", new List <string> {
"Foo", "Bar"
}),
Bar = (1, 2, 3, 4, 5, 6, 7, 8, 9, (10, 11))
};
var s = new XmSerializerModel();
s.AddType(typeof(ValueTupleTestClass));
var result = BasicTest.TestSerialization(dto, s);
Assert.AreEqual(dto.Foo.Item1, result.Foo.Item1);
Assert.AreEqual(dto.Foo.Item2[0], result.Foo.Item2[0]);
Assert.AreEqual(dto.Foo.Item2[1], result.Foo.Item2[1]);
Assert.AreEqual(dto.Bar.Item1, result.Bar.Item1);
Assert.AreEqual(dto.Bar.Item2, result.Bar.Item2);
Assert.AreEqual(dto.Bar.Item3, result.Bar.Item3);
Assert.AreEqual(dto.Bar.Item4, result.Bar.Item4);
Assert.AreEqual(dto.Bar.Item5, result.Bar.Item5);
Assert.AreEqual(dto.Bar.Item6, result.Bar.Item6);
Assert.AreEqual(dto.Bar.Item7, result.Bar.Item7);
Assert.AreEqual(dto.Bar.Item8, result.Bar.Item8);
Assert.AreEqual(dto.Bar.Item9, result.Bar.Item9);
Assert.AreEqual(dto.Bar.Item10.Item1, result.Bar.Item10.Item1);
Assert.AreEqual(dto.Bar.Item10.Item2, result.Bar.Item10.Item2);
}
public void TestNestedCollection()
{
var s = new XmSerializerModel();
var obj = new List <List <int> > {
new List <int> {
1, 2, 3
}, new List <int> {
4, 5, 6
}, new List <int> {
7, 8, 9
}
};
var result = BasicTest.TestSerialization(obj, s);
Assert.AreEqual(3, result.Count);
Assert.AreEqual(3, result[0].Count);
Assert.AreEqual(3, result[1].Count);
Assert.AreEqual(3, result[2].Count);
Assert.AreEqual(obj[0][0], result[0][0]);
Assert.AreEqual(obj[0][1], result[0][1]);
Assert.AreEqual(obj[0][2], result[0][2]);
Assert.AreEqual(obj[1][0], result[1][0]);
Assert.AreEqual(obj[1][1], result[1][1]);
Assert.AreEqual(obj[1][2], result[1][2]);
Assert.AreEqual(obj[2][0], result[2][0]);
Assert.AreEqual(obj[2][1], result[2][1]);
Assert.AreEqual(obj[2][2], result[2][2]);
}
public void TestJaggedArray()
{
var s = new XmSerializerModel();
var obj = new double[2][][];
obj[0] = new double[2][];
obj[1] = new double[2][];
obj[0][0] = new[] { 1, 2d };
obj[0][1] = new[] { 3, 4d };
obj[1][0] = new[] { 5, 6d };
obj[1][1] = new[] { 7, 8d };
var result = BasicTest.TestSerialization(obj, s);
Assert.AreEqual(2, result.Length);
Assert.AreEqual(2, result[0].Length);
Assert.AreEqual(2, result[1].Length);
Assert.AreEqual(2, result[0][0].Length);
Assert.AreEqual(2, result[1][0].Length);
Assert.AreEqual(2, result[0][1].Length);
Assert.AreEqual(2, result[1][1].Length);
Assert.AreEqual(obj[0][0][0], result[0][0][0]);
Assert.AreEqual(obj[0][0][1], result[0][0][1]);
Assert.AreEqual(obj[0][1][0], result[0][1][0]);
Assert.AreEqual(obj[0][1][1], result[0][1][1]);
Assert.AreEqual(obj[1][0][0], result[1][0][0]);
Assert.AreEqual(obj[1][0][1], result[1][0][1]);
Assert.AreEqual(obj[1][1][0], result[1][1][0]);
Assert.AreEqual(obj[1][1][1], result[1][1][1]);
}
public void TestArray()
{
var s = new XmSerializerModel();
var obj = new[] { 1, 2, 3d };
var result = BasicTest.TestSerialization(obj, s);
Assert.AreEqual(3, result.Length);
Assert.AreEqual(obj[0], result[0]);
Assert.AreEqual(obj[1], result[1]);
Assert.AreEqual(obj[2], result[2]);
}
public void TestNullable()
{
var s = new XmSerializerModel();
s.AddType(typeof(NullableDto));
var dto = new NullableDto();
var result = BasicTest.TestSerialization(dto, s);
Assert.AreEqual(result.Foo, dto.Foo);
Assert.AreEqual(result.Bar, dto.Bar);
}
public void TestArraySelfReference()
{
var s = new XmSerializerModel();
var dto = new object[2];
dto[0] = dto;
dto[1] = dto;
var result = BasicTest.TestSerialization(dto, s);
Assert.AreSame(result, result[0]);
Assert.AreSame(result, result[1]);
}
public void TestImplicitFieldAttribute()
{
var s = new XmSerializerModel();
s.AddType(typeof(ImplicitFieldsTestClass));
var obj = new ImplicitFieldsTestClass {
TestField = "foobar"
};
var result = BasicTest.TestSerialization(obj, s);
Assert.AreEqual(obj.TestField, result.TestField);
}
public void TestDictionary()
{
var s = new XmSerializerModel();
var obj = new Dictionary <int, string> {
{ 5, "foo" }, { 4, "bar" }
};
var result = BasicTest.TestSerialization(obj, s);
Assert.AreEqual(obj.Count, result.Count);
Assert.AreEqual(obj[5], result[5]);
Assert.AreEqual(obj[4], result[4]);
}
public void TestSimpleInheritance()
{
var s = new XmSerializerModel();
s.AddType(typeof(DtoTestClass));
s.AddType(typeof(BaseDto));
var dto = new DtoTestClass();
var result = BasicTest.TestSerialization(dto, s);
Assert.AreEqual(dto.GetBooFar(), result.GetBooFar());
Assert.AreEqual(dto.GetFooBar(), result.GetFooBar());
}
public void TestPrivateFields()
{
var s = new XmSerializerModel();
s.AddType(typeof(MemberFilterDto1));
var dto = new MemberFilterDto1();
var result = BasicTest.TestSerialization(dto, s);
Assert.AreEqual("foobar", result.Gett2());
Assert.AreEqual("foobar", result.t3);
Assert.AreEqual("foobar", result.Gett4());
Assert.IsNull(result.t1);
}
public void TestList()
{
var s = new XmSerializerModel();
var obj = new List <int> {
1, 2, 3
};
var result = BasicTest.TestSerialization(obj, s);
Assert.AreEqual(3, result.Count);
Assert.AreEqual(obj[0], result[0]);
Assert.AreEqual(obj[1], result[1]);
Assert.AreEqual(obj[2], result[2]);
}
public void TestNotSerialized()
{
var s = new XmSerializerModel();
s.AddType(typeof(NotSerializedTestClass));
var obj = new NotSerializedTestClass {
TestField = "foobar", NonSerializedTestField = "foobar"
};
var result = BasicTest.TestSerialization(obj, s);
Assert.AreEqual(obj.TestField, result.TestField);
Assert.IsNull(result.NonSerializedTestField);
}
public void TestSelfReference()
{
var s = new XmSerializerModel();
s.AddType(typeof(ReferenceTestClass));
var dto = new ReferenceTestClass();
dto.RefernceField = dto;
dto.RefernceField2 = dto;
var result = BasicTest.TestSerialization(dto, s);
Assert.AreSame(result, result.RefernceField);
}
public void TestExplicitIList()
{
var s = new XmSerializerModel();
s.AddType(typeof(ExplicitIListTestClass));
var obj = (IList) new ExplicitIListTestClass();
obj.Add("Foo");
obj.Add("Bar");
var result = BasicTest.TestSerialization(obj, s);
Assert.AreEqual(2, result.Count);
Assert.AreEqual(obj[0], result[0]);
Assert.AreEqual(obj[1], result[1]);
}
public void TestInterface()
{
var s = new XmSerializerModel();
var dto = new List <IList <IEnumerable> >
{
new List <IEnumerable> {
new List <int> {
3456
}
}
};
var result = BasicTest.TestSerialization(dto, s);
Assert.AreEqual(3456, result.First().First().Cast <object>().First());
}
public void TestIncludeAncestors()
{
var s = new XmSerializerModel();
s.AddType(typeof(TestClass1));
s.AddType(typeof(TestClass2));
s.AddType(typeof(AncestorTestClass));
var dto1 = new TestClass1();
var dto2 = new TestClass2();
var result1 = BasicTest.TestSerialization(dto1, s);
var result2 = BasicTest.TestSerialization(dto2, s);
Assert.AreEqual(dto1.GetBooFar(), result1.GetBooFar());
Assert.AreEqual(dto2.GetBooFar(), result2.GetBooFar());
Assert.AreEqual(dto1.GetFooBar(), result1.GetFooBar());
Assert.IsNull(result2.GetFooBar());
}
public void TestGenericInheritance()
{
var s = new XmSerializerModel();
s.AddType(typeof(GenericInheritanceBaseClass <>));
s.AddType(typeof(GenericInheritanceDerivedClass <>));
var dto = new GenericInheritanceDerivedClass <string>()
{
Barfoo = "Barfoo",
Foobar = "Foobar"
};
var result = BasicTest.TestSerialization(dto, s);
Assert.AreEqual(dto.Barfoo, result.Barfoo);
Assert.AreEqual(dto.Foobar, result.Foobar);
}
public void TestTupleReference()
{
var dto = new TupleReferenceTestClass
{
Foo = new Tuple <int>(5),
};
dto.Bar = dto.Foo;
var s = new XmSerializerModel();
s.AddType(typeof(TupleReferenceTestClass));
var result = BasicTest.TestSerialization(dto, s);
Assert.AreEqual(dto.Foo.Item1, result.Foo.Item1);
Assert.AreSame(dto.Foo, dto.Bar);
}
public void TestCustomCollection()
{
var s = new XmSerializerModel();
s.AddType(typeof(CustomCollectionTestClass));
s.AddType(typeof(CustomCollection <>));
var obj = new CustomCollectionTestClass();
obj.CollectionField = new CustomCollection <int> {
125, 132, 164
};
var result = BasicTest.TestSerialization(obj, s);
Assert.AreEqual(3, result.CollectionField.Count);
Assert.AreEqual(obj.CollectionField[0], result.CollectionField[0]);
Assert.AreEqual(obj.CollectionField[1], result.CollectionField[1]);
Assert.AreEqual(obj.CollectionField[2], result.CollectionField[2]);
}
public void TestCircularReference()
{
var s = new XmSerializerModel();
s.AddType(typeof(ReferenceTestClass));
var dto = new ReferenceTestClass();
var dto2 = new ReferenceTestClass();
var dto3 = new ReferenceTestClass();
dto.RefernceField = dto2;
dto2.RefernceField = dto3;
dto3.RefernceField = dto;
var result = BasicTest.TestSerialization(dto, s);
Assert.AreSame(result, ((ReferenceTestClass)((ReferenceTestClass)result.RefernceField).RefernceField).RefernceField);
}
public void TestInitializeAfterDeserialization()
{
var s = new XmSerializerModel();
s.AddType(typeof(InitializeAfterDeserializationTestClass));
s.AddType(typeof(InitializeAfterDeserializationTestClass1));
s.AddType(typeof(InitializeAfterDeserializationTestClass2));
s.AddType(typeof(InitializeAfterDeserializationTestClass3));
var obj = new InitializeAfterDeserializationTestClass();
var result = BasicTest.TestSerialization(obj, s);
Assert.IsNotNull(result.foo);
Assert.IsNotNull(result.bar);
Assert.ThrowsException <Exception>(() => BasicTest.TestSerialization(new InitializeAfterDeserializationTestClass1(), s));
Assert.ThrowsException <Exception>(() => BasicTest.TestSerialization(new InitializeAfterDeserializationTestClass2(), s));
Assert.ThrowsException <Exception>(() => BasicTest.TestSerialization(new InitializeAfterDeserializationTestClass3(), s));
}
public void TestCustomReference()
{
var s = new XmSerializerModel();
s.AddType(typeof(ReferenceTestClass));
var d = new Dictionary <int, string> {
{ 1, "s" }
};
var dto = new ReferenceTestClass()
{
RefernceField = d,
RefernceField2 = d
};
var result = BasicTest.TestSerialization(dto, s);
Assert.AreSame(result.RefernceField, result.RefernceField2);
}
public void TestListOfArray()
{
var s = new XmSerializerModel();
var obj = new List <int[]>();
obj.Add(new[] { 1, 2 });
obj.Add(new[] { 3, 4 });
var result = BasicTest.TestSerialization(obj, s);
Assert.AreEqual(2, result.Count);
Assert.AreEqual(2, result[0].Length);
Assert.AreEqual(2, result[1].Length);
Assert.AreEqual(obj[0][0], result[0][0]);
Assert.AreEqual(obj[0][1], result[0][1]);
Assert.AreEqual(obj[1][0], result[1][0]);
Assert.AreEqual(obj[1][1], result[1][1]);
}
public void TestGeneric()
{
var s = new XmSerializerModel();
s.AddType(typeof(GenericTestClass <, ,>));
var obj = new GenericTestClass <string, int, bool>
{
Field1 = "test",
Field2 = 5,
Field3 = true
};
var result = BasicTest.TestSerialization(obj, s);
Assert.AreEqual(result.Field1, obj.Field1);
Assert.AreEqual(result.Field2, obj.Field2);
Assert.AreEqual(result.Field3, obj.Field3);
}
public void TestReference()
{
var s = new XmSerializerModel();
s.AddType(typeof(ReferenceTestClass));
s.AddType(typeof(ReferencedClass));
var dto = new ReferenceTestClass {
RefernceField = new ReferencedClass {
FooBar = "foobar"
}
};
dto.RefernceField2 = dto.RefernceField;
var result = BasicTest.TestSerialization(dto, s);
Assert.AreEqual(((ReferencedClass)result.RefernceField).FooBar, ((ReferencedClass)result.RefernceField2).FooBar);
Assert.AreSame(result.RefernceField, result.RefernceField2);
}
public void TestObfuscate()
{
var dto = new ObfuscationTestClass
{
FooBar = "FooBar",
BarFoo = "BarFoo"
};
var s = new XmSerializerModel();
s.AddType(typeof(ObfuscationTestClass));
var xml = s.Serialize(dto);
Assert.IsTrue(xml.ToString().Contains("BarFoo"));
Assert.IsFalse(xml.ToString().Contains("FooBar"));
var result = BasicTest.TestSerialization(dto, s);
Assert.AreEqual(result.FooBar, "FooBar");
Assert.AreEqual(result.BarFoo, "BarFoo");
}
public void TestLegacyName()
{
var s = new XmSerializerModel();
s.AddType(typeof(OldTestClass));
var s2 = new XmSerializerModel();
s2.AddType(typeof(NewTestClass));
var dto = new OldTestClass {
Foobar = "foobar"
};
var xml = s.Serialize(dto);
var dto2 = s2.Deserialize <NewTestClass>(xml);
Assert.IsNotNull(dto2);
Assert.AreEqual(dto.Foobar, dto2.Barfoo);
var dto3 = BasicTest.TestSerialization(dto2, s2);
Assert.IsNotNull(dto3);
Assert.AreEqual(dto.Foobar, dto3.Barfoo);
}
public void TestCompactArray()
{
var dto = new CompactArrayDto();
var s = new XmSerializerModel();
s.AddType(typeof(CompactArrayDto));
_ = new CompactArraySerializer(s);
var result = BasicTest.TestSerialization(dto, s);
Assert.AreEqual(dto.IntArray[0], result.IntArray[0]);
Assert.AreEqual(dto.IntArray[1], result.IntArray[1]);
Assert.AreEqual(dto.IntArray[2], result.IntArray[2]);
Assert.AreEqual(dto.IntArray[3], result.IntArray[3]);
Assert.AreEqual(dto.ByteArray[0], result.ByteArray[0]);
Assert.AreEqual(dto.ByteArray[1], result.ByteArray[1]);
Assert.AreEqual(dto.ByteArray[2], result.ByteArray[2]);
Assert.AreEqual(dto.ByteArray[3], result.ByteArray[3]);
Assert.AreEqual(dto.DoubleArray[0], result.DoubleArray[0]);
Assert.AreEqual(dto.DoubleArray[1], result.DoubleArray[1]);
Assert.AreEqual(dto.DoubleArray[2], result.DoubleArray[2]);
Assert.AreEqual(dto.DoubleArray[3], result.DoubleArray[3]);
}
