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 TestOverriddedCallbacks() { var serializer = new XmSerializerModel(); serializer.AddType(typeof(OverriddenCallbackTestClass1)); serializer.AddType(typeof(OverriddenCallbackTestClass2)); var instance = new OverriddenCallbackTestClass2(); var xml = serializer.Serialize(instance); var result = serializer.Deserialize <OverriddenCallbackTestClass2>(xml); Assert.AreEqual(11, result.FooCounter); Assert.AreEqual(11, result.BarCounter); Assert.AreEqual(22, result.FooBarCounter); }
public void TestIdenticalStructs() { var serializer = new XmSerializerModel(); serializer.AddType(typeof(StructDto)); serializer.AddType(typeof(IdenticalStructsDto)); var dto = new IdenticalStructsDto(); dto.Struct1.TestString = "foobar"; dto.Struct2.TestString = "foobar"; var result = TestSerialization(dto, serializer); Assert.AreEqual(result.Struct1.TestString, dto.Struct2.TestString); }
public void TestEnum() { var serializer = new XmSerializerModel(); serializer.AddType(typeof(EnumDto)); serializer.AddType(typeof(FooBar)); var dto = new EnumDto { EnumField = FooBar.Bar, EnumFieldSt = FooBar.Foo }; var result = TestSerialization(dto, serializer); Assert.AreEqual(result.EnumField, dto.EnumField); Assert.AreEqual(result.EnumFieldSt, dto.EnumFieldSt); }
public ValueTupleSerializer(XmSerializerModel serializerModel) : base(serializerModel) { foreach (var tupleType in TupleTypes) { serializerModel.AddType(new TypeSerializingSettings(tupleType)); } }
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 TestReducedNumberOfTypeParametersParsing() { var s = new XmSerializerModel(); s.AddType(typeof(Foo <, ,>)); var s2 = new XmSerializerModel(); s2.AddType(typeof(Foo <,>)); var s3 = new XmSerializerModel(); s3.AddType(typeof(Foo)); var obj = new Foo <string, int, bool> { Field1 = "foobar", Field2 = 42, Field3 = true }; var xml = s.Serialize(obj); var result = (Foo <string, int>)s2.Deserialize <object>(xml); Assert.AreEqual(result.Field1, obj.Field1); Assert.AreEqual(result.Field2, obj.Field2); Assert.AreEqual(result.Field3, obj.Field3); var result2 = s3.Deserialize <Foo>(xml); Assert.AreEqual(result2.Field1, obj.Field1); Assert.AreEqual(result2.Field2, obj.Field2); Assert.AreEqual(result2.Field3, obj.Field3); }
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 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 TestValueConversion() { var s = new XmSerializerModel(); s.AddType(typeof(ValueConversionTestClass1)); var s2 = new XmSerializerModel(); s2.AddType(typeof(ValueConversionTestClass2)); var dto = new ValueConversionTestClass1() { V1 = 5, V2 = 6, V3 = 7, V4 = 8, V5 = 9, V6 = 10, V7 = 11, }; var xml = s.Serialize(dto); var result = s2.Deserialize <ValueConversionTestClass2>(xml); Assert.AreEqual(result.V1, dto.V1); Assert.AreEqual(result.V2, dto.V2); Assert.AreEqual(result.V3, dto.V3); Assert.AreEqual(result.V4, dto.V4); Assert.AreEqual(result.V5, dto.V5); Assert.AreEqual(result.V6, dto.V6); Assert.AreEqual(result.V7, dto.V7); }
public void TestDeactivation() { var s1 = new XmSerializerModel(); s1.AddType(typeof(DeactivationTestClass1)); var s2 = new XmSerializerModel(); s2.AddType(typeof(DeactivationTestClass2)); var dto1 = new DeactivationTestClass1 { Foobar = "foo" }; var dto2 = new DeactivationTestClass2 { Foobar = "bar" }; var xml1 = s1.Serialize(dto1); var result1 = s2.Deserialize <DeactivationTestClass2>(xml1); var result2 = s1.Deserialize <DeactivationTestClass1>(xml1); Assert.AreEqual(result1.Foobar, dto1.Foobar); Assert.IsNull(result2.Foobar); var xml2 = s2.Serialize(dto2); var result3 = s2.Deserialize <DeactivationTestClass2>(xml2); var result4 = s1.Deserialize <DeactivationTestClass1>(xml2); Assert.IsNull(result3.Foobar); Assert.IsNull(result4.Foobar); }
public void TestDefaultValue() { var s = new XmSerializerModel(); s.AddType(typeof(CompatibilityTest3)); var s2 = new XmSerializerModel(); s2.AddType(typeof(CompatibilityTest2)); var s3 = new XmSerializerModel(); s3.AddType(typeof(CompatibilityTest1)); var dto = new CompatibilityTest2(); var xml = s2.Serialize(dto); var dto2 = s.Deserialize <CompatibilityTest3>(xml); Assert.IsNotNull(dto2); Assert.AreEqual("barfoo", dto2.Foobar); var dto3 = new CompatibilityTest1 { Foobar = "foobar" }; var xml2 = s3.Serialize(dto3); var dto4 = s.Deserialize <CompatibilityTest3>(xml2); Assert.AreEqual("foobar", dto4.Foobar); }
public PrimitivesSerializer(XmSerializerModel serializerModel) : base(serializerModel) { foreach (var primitive in Primitives) { serializerModel.AddType(new TypeSerializingSettings(primitive.Key, primitive.Value)); } }
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 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 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 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 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 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 TestDeserializingPriority() { var serializer = new XmSerializerModel(); serializer.AddType(typeof(PriorityCallbackTestClass)); var instance = new PriorityCallbackTestClass(); var xml = serializer.Serialize(instance); var result = serializer.Deserialize <PriorityCallbackTestClass>(xml); Assert.AreEqual("-1,0,1,2,9", result.DeserializeOrder); }
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 TestStruct() { var serializer = new XmSerializerModel(); serializer.AddType(typeof(StructDto)); var dto = new StructDto { TestString = "foobar" }; var result = TestSerialization(dto, serializer); Assert.AreEqual(result.TestString, dto.TestString); }
public void TestDerivedCallbacks() { var serializer = new XmSerializerModel(); serializer.AddType(typeof(DerivedCallbackTestClass)); serializer.AddType(typeof(CallbackTestClass)); var instance = new DerivedCallbackTestClass(); instance.DeSerializeTestValue3 = "test"; var xml = serializer.Serialize(instance); var result = serializer.Deserialize <DerivedCallbackTestClass>(xml); Assert.AreEqual("DerivedOnSerialized", instance.SerializeTestValue); Assert.AreEqual("DerivedOnSerialized", instance.SerializeTestValue2); Assert.AreEqual("DerivedOnSerializing", result.SerializeTestValue); Assert.AreEqual("DerivedOnSerializing", result.SerializeTestValue2); Assert.AreEqual("test", result.DeSerializeTestValue3); Assert.IsNull(result.DeSerializeTestValue4); Assert.AreEqual("DerivedOnDeserialized", result.DeSerializeTestValue); Assert.AreEqual("DerivedOnDeserialized", result.DeSerializeTestValue2); }
public void TestSkipConstructor() { var s = new XmSerializerModel(); s.AddType(typeof(ConstructorTestClass2)); var obj = new ConstructorTestClass2(); var xml = s.Serialize(obj); var result = s.Deserialize <ConstructorTestClass2>(xml); Assert.IsNull(result.TestField); Assert.IsNull(result.TestField2); }
public void TestConstructor() { var s = new XmSerializerModel(); s.AddType(typeof(ConstructorTestClass)); var obj = new ConstructorTestClass(); var xml = s.Serialize(obj); var result = s.Deserialize <ConstructorTestClass>(xml); Assert.AreEqual(obj.TestField, result.TestField); Assert.AreEqual(obj.TestField2, result.TestField2); }
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 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 TestNested() { var serializer = new XmSerializerModel(); serializer.AddType(typeof(PrimitivesDto)); var dto = new PrimitivesDto { SubObject = new PrimitivesDto { TestString = "dfsads" } }; var result = TestSerialization(dto, serializer); Assert.AreEqual(result.SubObject.TestString, dto.SubObject.TestString); }
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 TestBackwardCompatibility() { var s = new XmSerializerModel(); s.AddType(typeof(CompatibilityTest1)); var s2 = new XmSerializerModel(); s2.AddType(typeof(CompatibilityTest2)); var dto = new CompatibilityTest2(); var xml = s2.Serialize(dto); var dto2 = s.Deserialize <CompatibilityTest1>(xml); Assert.IsNotNull(dto2); }