public void XmlSerializationWithXmlMappings()
{
var originalObject = ModelBaseTestHelper.CreateComputerSettingsWithXmlMappingsObject();
var clonedObject = SerializationTestHelper.SerializeAndDeserialize(originalObject, SerializationFactory.GetXmlSerializer());
Assert.AreEqual(originalObject, clonedObject);
}
public void CanSerializeCustomDataObject()
{
var countrylist = new List <Country>();
countrylist.Add(new Country {
IsoCode = "AF", Description = "Afghanistan"
});
countrylist.Add(new Country {
IsoCode = "AG", Description = "Agypt"
});
var dataSourceResult = new DataSourceResult();
dataSourceResult.Total = 243;
dataSourceResult.Data = countrylist;
TestSerializationOnAllSerializers((serializer, config, description) =>
{
var deserializedObject = SerializationTestHelper.SerializeAndDeserialize(dataSourceResult, serializer, config);
Assert.AreEqual(243, deserializedObject.Total, description);
int counter = 0;
foreach (var country in dataSourceResult.Data)
{
var existingCountry = countrylist[counter++];
Assert.AreEqual(existingCountry.IsoCode, ((Country)country).IsoCode, description);
Assert.AreEqual(existingCountry.Description, ((Country)country).Description, description);
}
});
}
public void CorrectlySerializesObjectsImplementingICustomXmlSerializable_Nested()
{
var serviceLocator = ServiceLocator.Default;
var serializer = serviceLocator.ResolveType <IXmlSerializer>();
var model = new CustomXmlSerializationModelWithNesting
{
Name = "Test model with nesting",
NestedModel = new CustomXmlSerializationModel
{
FirstName = "Geert"
}
};
var clonedModel = SerializationTestHelper.SerializeAndDeserialize(model, serializer, null);
Assert.IsNotNull(clonedModel.NestedModel);
// Note: yes, the *model* is serialized, the *clonedModel* is deserialized
Assert.IsTrue(model.NestedModel.IsCustomSerialized);
Assert.IsTrue(clonedModel.NestedModel.IsCustomDeserialized);
Assert.AreEqual(model.Name, clonedModel.Name);
Assert.AreEqual(model.NestedModel.FirstName, clonedModel.NestedModel.FirstName);
}
public void CanSerializeCollection()
{
var countrylist = new List <Country>();
countrylist.Add(new Country {
IsoCode = "AF", Description = "Afghanistan"
});
countrylist.Add(new Country {
IsoCode = "AG", Description = "Agypt"
});
TestSerializationOnAllSerializers((serializer, config, description) =>
{
var deserializedObject = SerializationTestHelper.SerializeAndDeserialize(countrylist, serializer, config);
Assert.AreEqual(countrylist.Count, deserializedObject.Count, description);
for (int i = 0; i < deserializedObject.Count; i++)
{
var expectedItem = countrylist[i];
var actualItem = deserializedObject[i];
Assert.AreEqual(expectedItem.IsoCode, actualItem.IsoCode, description);
Assert.AreEqual(expectedItem.Description, actualItem.Description, description);
}
});
}
public void CorrectlySerializesCustomizedModels()
{
var testModel = new TestModel();
testModel._excludedField = "excluded";
testModel._includedField = "included";
testModel.ExcludedRegularProperty = "excluded";
testModel.IncludedRegularProperty = "included";
testModel.ExcludedCatelProperty = "excluded";
testModel.IncludedCatelProperty = "included";
testModel.SetValue(TestModel.ExcludedProtectedCatelPropertyProperty, "excluded");
TestSerializationOnAllSerializers((serializer, config, description) =>
{
var clonedModel = SerializationTestHelper.SerializeAndDeserialize(testModel, serializer, config);
Assert.AreEqual(null, clonedModel._excludedField, description);
Assert.AreEqual("included", clonedModel._includedField, description);
Assert.AreEqual(null, clonedModel.ExcludedRegularProperty, description);
Assert.AreEqual("included", clonedModel.IncludedRegularProperty, description);
Assert.AreEqual(null, clonedModel.ExcludedCatelProperty, description);
Assert.AreEqual("included", clonedModel.IncludedCatelProperty, description);
Assert.AreEqual(null, clonedModel.GetValue(TestModel.ExcludedProtectedCatelPropertyProperty.Name), description);
});
}
public void CorrectlyHandlesSameInstancesInGraphUsingCollections()
{
var testModel = new TestModelWithNestedListMembers();
var level2_1 = new TestModelWithNestedListMembers_Level2
{
Name = "John Doe"
};
var level1_1 = new TestModelWithNestedListMembers_Level1
{
Name = "A",
};
level1_1.Children.Add(level2_1);
var level1_2 = new TestModelWithNestedListMembers_Level1
{
Name = "B",
};
level1_2.Children.Add(level2_1);
testModel.Children.Add(level1_1);
testModel.Children.Add(level1_2);
TestSerializationOnXmlSerializer((serializer, config, description) =>
{
var clonedGraph = SerializationTestHelper.SerializeAndDeserialize(testModel, serializer, config);
Assert.IsNotNull(clonedGraph, description);
Assert.IsTrue(ReferenceEquals(clonedGraph.Children[0].Children[0], clonedGraph.Children[1].Children[0]), description);
}, false);
}
public void CanSerializeArray()
{
var countrylist = new[]
{
new Country {
IsoCode = "AF", Description = "Afghanistan"
},
new Country {
IsoCode = "AG", Description = "Agypt"
},
};
TestSerializationOnAllSerializers((serializer, config, description) =>
{
var deserializedObject = SerializationTestHelper.SerializeAndDeserialize(countrylist, serializer, config);
Assert.AreEqual(countrylist.GetType(), deserializedObject.GetType(), description);
Assert.AreEqual(countrylist.Length, deserializedObject.Length, description);
for (var i = 0; i < deserializedObject.Length; i++)
{
var expectedItem = countrylist[i];
var actualItem = deserializedObject[i];
Assert.AreEqual(expectedItem.IsoCode, actualItem.IsoCode, description);
Assert.AreEqual(expectedItem.Description, actualItem.Description, description);
}
});
}
public void RespectsTheXmlAttributeAttributeOnRootElements(XmlSerializerOptimalizationMode mode)
{
var family = new XmlFamily();
family.LastName = "van Horrik";
family.Persons.Add(new XmlPerson
{
FirstName = "Geert",
LastName = family.LastName,
Gender = Gender.Male
});
var newFamily = SerializationTestHelper.SerializeAndDeserialize(family, SerializationTestHelper.GetXmlSerializer(),
new XmlSerializationConfiguration
{
OptimalizationMode = mode
});
Assert.AreEqual(family.LastName, newFamily.LastName);
Assert.AreEqual(1, newFamily.Persons.Count);
var newPerson = newFamily.Persons.First();
Assert.AreEqual(family.Persons[0].FirstName, newPerson.FirstName);
Assert.AreEqual(family.Persons[0].LastName, newPerson.LastName);
Assert.AreEqual(family.Persons[0].Gender, newPerson.Gender);
}
public void CanSerializeBasicTypes <T>(T value)
{
TestSerializationOnAllSerializers((serializer, config, description) =>
{
var deserializedObject = SerializationTestHelper.SerializeAndDeserialize(value, serializer, config);
Assert.AreEqual(value, deserializedObject);
});
}
public void MembersIgnoredViaModifier()
{
var modelC = new TestModels.ModelC();
modelC.IgnoredMember = "test is a value";
var clonedModelC = SerializationTestHelper.SerializeAndDeserialize(modelC, SerializationFactory.GetXmlSerializer());
Assert.AreEqual(null, clonedModelC.IgnoredMember);
}
public void SerializationComplexGraphWithInheritance()
{
var originalObject = ModelBaseTestHelper.CreateHierarchicalGraphWithInheritance();
TestSerializationOnAllSerializers((serializer, config, description) =>
{
var clonedObject = SerializationTestHelper.SerializeAndDeserialize(originalObject, serializer, config);
Assert.AreEqual(originalObject, clonedObject, description);
}, false);
}
public void SerializationLevel3()
{
var originalObject = ModelBaseTestHelper.CreateComputerSettingsObject();
TestSerializationOnAllSerializers((serializer, config, description) =>
{
var clonedObject = SerializationTestHelper.SerializeAndDeserialize(originalObject, serializer, config);
Assert.AreEqual(originalObject, clonedObject, description);
});
}
public void CanSerializeAndDeserializeComplexHierarchies()
{
var complexHierarchy = ComplexSerializationHierarchy.CreateComplexHierarchy();
TestSerializationOnAllSerializers((serializer, config, description) =>
{
var deserializedObject = SerializationTestHelper.SerializeAndDeserialize(complexHierarchy, serializer, config);
Assert.IsTrue(complexHierarchy == deserializedObject, description);
});
}
public void SerializesAndDeserializesKeyValuePairs()
{
var originalObject = new TestModelWithKeyValuePair();
TestSerializationOnAllSerializers((serializer, config, description) =>
{
var clonedObject = SerializationTestHelper.SerializeAndDeserialize(originalObject, serializer, config);
Assert.AreEqual(originalObject.KeyValuePair, clonedObject.KeyValuePair, description);
Assert.AreEqual(originalObject.KeyValuePairAsObject, clonedObject.KeyValuePairAsObject, description);
});
}
public void CorrectlyHandlesSameInstancesInGraph()
{
var graph = SerializationTestHelper.CreateComplexCircularTestModelGraph();
TestSerializationOnAllSerializers((serializer, config, description) =>
{
var clonedGraph = SerializationTestHelper.SerializeAndDeserialize(graph, serializer, config);
Assert.IsNotNull(clonedGraph, description);
Assert.IsTrue(ReferenceEquals(clonedGraph, clonedGraph.CircularModel.CircularModel), description);
}, false);
}
public void SerializationWithPrivateMembers()
{
var originalObject = new ObjectWithPrivateMembers("My private member");
originalObject.PublicMember = "My public member";
TestSerializationOnAllSerializers((serializer, config, description) =>
{
var clonedObject = SerializationTestHelper.SerializeAndDeserialize(originalObject, serializer, config);
Assert.AreEqual(originalObject, clonedObject, description);
});
}
public void CorrectlyIncludesNonSerializablePropertiesIncludedWithAttributes()
{
var model = new CTL550Model();
model.Color = Colors.Red;
TestSerializationOnAllSerializers((serializer, config, description) =>
{
var clonedModel = SerializationTestHelper.SerializeAndDeserialize(model, serializer, config);
Assert.AreEqual(Colors.Red, clonedModel.Color, description);
});
}
public void TestGenericSerialization()
{
var a = new A(3);
var b = new B <A>(a);
TestSerializationOnAllSerializers((serializer, config, description) =>
{
var clonedObject = SerializationTestHelper.SerializeAndDeserialize(b, serializer, config);
Assert.IsNotNull(clonedObject?.Item);
Assert.That(clonedObject.Item.Count, Is.EqualTo(a.Count));
});
}
public void ComplexInheritanceWorksWithBinary()
{
var modelC = new TestModels.ModelC();
Assert.IsNull(modelC.ModelAProperty);
Assert.IsNull(modelC.ModelBProperty);
Assert.IsNull(modelC.ModelCProperty);
var clonedModelC = SerializationTestHelper.SerializeAndDeserialize(modelC, SerializationFactory.GetBinarySerializer());
Assert.AreEqual("ModifiedA", clonedModelC.ModelAProperty);
Assert.AreEqual("ModifiedB", clonedModelC.ModelBProperty);
Assert.AreEqual("ModifiedC", clonedModelC.ModelCProperty);
}
public void SerializationWithCustomTypes()
{
var originalObject = new ObjectWithCustomType();
originalObject.FirstName = "Test";
originalObject.Gender = Gender.Female;
TestSerializationOnAllSerializers((serializer, config, description) =>
{
var clonedObject = SerializationTestHelper.SerializeAndDeserialize(originalObject, serializer, config);
Assert.AreEqual(originalObject, clonedObject, description);
});
}
public void SerializeSimpleModels()
{
var originalObject = new NonCatelTestModel();
originalObject.FirstName = "Test";
originalObject.LastName = "Subject";
TestSerializationOnAllSerializers((serializer, config, description) =>
{
var clonedObject = SerializationTestHelper.SerializeAndDeserialize(originalObject, serializer, config);
Assert.AreEqual(originalObject.FirstName, clonedObject.FirstName, description);
Assert.AreEqual(originalObject.LastName, clonedObject.LastName, description);
});
}
public void CorrectlyHandlesSerializationOfCollectionsWithAbstractClasses()
{
var collection = new CatelModelAdvancedSerializationFacts.ContainerClass();
collection.Items.Add(new CatelModelAdvancedSerializationFacts.DerivedClass {
Name = "item 1"
});
TestSerializationOnAllSerializers((serializer, config, description) =>
{
var clonedGraph = SerializationTestHelper.SerializeAndDeserialize(collection, serializer, config);
Assert.AreEqual(collection, clonedGraph, description);
}, false);
}
public void SerializesModelsWithParsableObjectsWithoutAttributes()
{
var originalObject = new TestModelWithParsableMembersWithoutAttributes();
originalObject.Vector = new Vector(1, 2, 3);
TestSerializationOnAllSerializers((serializer, config, description) =>
{
var clonedObject = SerializationTestHelper.SerializeAndDeserialize(originalObject, serializer, config);
Assert.IsFalse(clonedObject.Vector.UsedParse);
Assert.AreEqual(originalObject.Vector.X, clonedObject.Vector.X, description);
Assert.AreEqual(originalObject.Vector.Y, clonedObject.Vector.Y, description);
Assert.AreEqual(originalObject.Vector.Z, clonedObject.Vector.Z, description);
});
}
public void SerializesAndDeserializesCompletelyDifferentType()
{
var changingType = new ChangingType();
for (int i = 0; i < 10; i++)
{
changingType.CustomizedCollection.Add(i);
}
var clone = SerializationTestHelper.SerializeAndDeserialize(changingType, SerializationFactory.GetXmlSerializer());
Assert.AreEqual(10, clone.CustomizedCollection.Count);
for (int i = 0; i < 10; i++)
{
Assert.AreEqual(i, clone.CustomizedCollection[i]);
}
}
public void SerializeDictionaryWithPocoClassAsKey()
{
var originalObject = new FailToSerialize();
originalObject.Lookup.Add(new PocoKeyClass {
X = 1.0, Y = 2.0, Z = 3.0
}, "test me");
Assert.AreEqual(1, originalObject.Lookup.Count);
TestSerializationOnXmlSerializer((serializer, config, description) =>
{
var clonedObject = SerializationTestHelper.SerializeAndDeserialize(originalObject, serializer, config);
Assert.IsNotNull(clonedObject);
Assert.AreEqual(1, clonedObject.Lookup.Count);
});
}
[TestCase] // CTL-550
public void CorrectlyHandlesSameInstancesOfNonCatelObjectsInGraph()
{
var graph = new ReusedCollectionsModel();
TestSerializationOnAllSerializers((serializer, config, description) =>
{
var clonedGraph = SerializationTestHelper.SerializeAndDeserialize(graph, serializer, config);
Assert.IsNotNull(clonedGraph.Collection1, description);
Assert.IsNotNull(clonedGraph.Collection2, description);
Assert.AreEqual(5, clonedGraph.Collection1.Count, description);
Assert.AreEqual(5, clonedGraph.Collection2.Count, description);
Assert.IsTrue(ReferenceEquals(clonedGraph.Collection1, clonedGraph.Collection2), description);
}, false);
}
public void CanSerializeModelBaseAndCollectionAsCollection()
{
var b1 = new BuildingAsCollection {
Name = "B1"
};
b1.Floors.Add(new Floor {
Name = "F1"
});
b1.Floors.Add(new Floor {
Name = "F2"
});
b1.Floors.Add(new Floor {
Name = "F3"
});
var b2 = new BuildingAsCollection {
Name = "B2"
};
var b3 = new BuildingAsCollection {
Name = "B3"
};
var bc = new BuildingCollectionAsCollection();
bc.Add(b1);
bc.Add(b2);
bc.Add(b3);
TestSerializationOnAllSerializers((serializer, config, description) =>
//TestSerializationOnJsonSerializer((serializer, config, description) =>
{
var deserializedObject = SerializationTestHelper.SerializeAndDeserialize(bc, serializer, config);
Assert.AreEqual(bc.Count, deserializedObject.Count, description);
Assert.AreEqual(3, deserializedObject.Count, description);
Assert.AreEqual("B1", deserializedObject[0].Name, description);
Assert.AreEqual("F1", deserializedObject[0].Floors[0].Name, description);
Assert.AreEqual("F2", deserializedObject[0].Floors[1].Name, description);
Assert.AreEqual("F3", deserializedObject[0].Floors[2].Name, description);
Assert.AreEqual("B2", deserializedObject[1].Name, description);
Assert.AreEqual("B3", deserializedObject[2].Name, description);
});
}
public void SerializeWithIPropertySerializable()
{
var originalObject = new NonCatelTestModelWithIPropertySerializable();
originalObject.FirstName = "Test";
originalObject.LastName = "Subject";
TestSerializationOnAllSerializers((serializer, config, description) =>
{
var clonedObject = SerializationTestHelper.SerializeAndDeserialize(originalObject, serializer, config);
Assert.IsTrue(originalObject.GetViaInterface, description);
Assert.IsTrue(clonedObject.SetViaInterface, description);
Assert.AreEqual(originalObject.FirstName, clonedObject.FirstName, description);
Assert.AreEqual(originalObject.LastName, clonedObject.LastName, description);
});
}
public void MyCatelModel_SerializationTest()
{
var input = new IsDirtyModelTestModel
{
MyDecimal = 123.4567m,
MyInteger = 98765,
MyString = "This is a serialization test."
};
// Round-trip the instance: Serialize and de-serialize with a BinaryFormatter
var actual = SerializationTestHelper.SerializeAndDeserialize(input, SerializationFactory.GetXmlSerializer());
// Double-check that the internal values are preserved
Assert.AreEqual(input.MyDecimal, actual.MyDecimal, "MyDecimal values do not match.");
Assert.AreEqual(input.MyInteger, actual.MyInteger, "MyInteger values do not match.");
Assert.AreEqual(input.MyString, actual.MyString, "MyString values do not match.");
//Assert.AreEqual(input.IsDirty, actual.IsDirty, "IsDirty values do not match.");
Assert.IsFalse(actual.IsDirty);
}
public void CorrectlyDeserializesEnumsFromString()
{
var serviceLocator = ServiceLocator.Default;
var serializer = serviceLocator.ResolveType <IJsonSerializer>();
var model = new CustomJsonSerializationModelWithEnum
{
Name = "Test model with enum",
EnumWithAttribute = CustomSerializationEnum.SecondValue,
EnumWithoutAttribute = CustomSerializationEnum.SecondValue,
};
var clonedModel = SerializationTestHelper.SerializeAndDeserialize(model, serializer, null);
// Note: yes, the *model* is serialized, the *clonedModel* is deserialized
Assert.AreEqual(model.EnumWithAttribute, clonedModel.EnumWithAttribute);
Assert.AreEqual(model.EnumWithoutAttribute, clonedModel.EnumWithoutAttribute);
}
