public ValueTupleSerializer(XmSerializerModel serializerModel) : base(serializerModel)
{
foreach (var tupleType in TupleTypes)
{
serializerModel.AddType(new TypeSerializingSettings(tupleType));
}
}
public PrimitivesSerializer(XmSerializerModel serializerModel) : base(serializerModel)
{
foreach (var primitive in Primitives)
{
serializerModel.AddType(new TypeSerializingSettings(primitive.Key, primitive.Value));
}
}
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 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 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 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 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 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 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 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 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 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 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 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 static T TestSerialization <T>(T dto, XmSerializerModel serializer)
{
var xml = serializer.Serialize(dto);
var ret = serializer.Deserialize <T>(xml);
var xml2 = serializer.Serialize(ret);
Assert.AreEqual(xml.ToString(), xml2.ToString());
Assert.AreEqual(dto.GetType(), ret.GetType());
Directory.CreateDirectory(@"output\");
File.WriteAllText($@"output\{typeof(T).Name}.csv", xml2.ToString());
return(ret);
}
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 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 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 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 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 CompactArraySerializer(XmSerializerModel serializerModel) : base(serializerModel)
{
for (var i = 0; i < serializerModel.ExclusiveSerializers.Count; i++)
{
// make sure we have higher priority than a regular ArraySerializer
if (serializerModel.ExclusiveSerializers[i] is ArraySerializer)
{
serializerModel.ExclusiveSerializers.Remove(this);
serializerModel.ExclusiveSerializers.Insert(i, this);
break;
}
}
}
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 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 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);
}
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);
}
