public static void RoundTrip___Supported_scenarios___Works()
{
// Arrange
var serializationConfigurationType1 = typeof(PropertyBagConfigIncludingAssemblyQualifiedNameForInheritTypeBase);
var serializationConfigurationType2 = typeof(PropertyBagConfigExcludingAssemblyQualifiedNameForInheritTypeBase);
var serializer1 = new ObcPropertyBagSerializer(serializationConfigurationType1.ToPropertyBagSerializationConfigurationType());
var serializer2 = new ObcPropertyBagSerializer(serializationConfigurationType2.ToPropertyBagSerializationConfigurationType());
var expected = new ComplicatedObject
{
NullableDecimal = 29m,
BaseVersion = new InheritTypeDerive(),
DeriveVersion = new InheritTypeDerive(),
DeriveVersionArray = new[] { new InheritTypeDerive(), },
DeriveVersionCollection = new[] { new InheritTypeDerive(), }.ToList(),
String = A.Dummy <string>(),
Int = A.Dummy <int>(),
TimeSpan = A.Dummy <TimeSpan>(),
DateTime = A.Dummy <DateTime>(),
DateTimeNullable = A.Dummy <DateTime>(),
CustomWithoutInterface = new CustomWithoutInterface(),
CustomWithInterface = new CustomWithInterface(),
StringArray = new[] { A.Dummy <string>(), },
StringCollection = new[] { A.Dummy <string>(), }.ToList(),
IntCollection = new[] { A.Dummy <int>(), }.ToList(),
TimeSpanCollection = new[] { A.Dummy <TimeSpan>(), }.ToList(),
DateTimeCollection = new[] { A.Dummy <DateTime>(), }.ToList(),
CustomWithoutInterfaceCollection = new[] { new CustomWithoutInterface(), new CustomWithoutInterface(), }.ToList(),
CustomWithInterfaceCollection = new[] { new CustomWithInterface(), new CustomWithInterface(), }.ToList(),
EnumParseCollection = new[] { EnumParse.Default, EnumParse.Value, },
EnumParse = EnumParse.Value,
StringCollectionWithSingleEmptyString = new[] { string.Empty },
StringCollectionWithNulls = new[] { string.Empty, A.Dummy <string>(), null, string.Empty, null, A.Dummy <string>() },
};
void ThrowIfObjectsDiffer(DescribedSerializationBase describedSerialization, ComplicatedObject deserialized)
{
deserialized.NullableDecimal.Should().Be(expected.NullableDecimal);
deserialized.NullableDecimalDefault.Should().BeNull();
deserialized.BaseVersion.Should().NotBeNull();
deserialized.DeriveVersion.Should().NotBeNull();
deserialized.DeriveVersionArray.Count().Should().Be(expected.DeriveVersionArray.Count());
deserialized.DeriveVersionCollection.Count().Should().Be(expected.DeriveVersionCollection.Count());
deserialized.String.Should().Be(expected.String);
deserialized.Int.Should().Be(expected.Int);
deserialized.TimeSpan.Should().Be(expected.TimeSpan);
deserialized.DateTime.Should().Be(expected.DateTime);
deserialized.DateTimeNullable.Should().Be(expected.DateTimeNullable);
deserialized.CustomWithoutInterface.Should().NotBeNull();
deserialized.CustomWithInterface.Should().NotBeNull();
deserialized.StringDefault.Should().BeNull();
deserialized.IntDefault.Should().Be(default(int));
deserialized.TimeSpanDefault.Should().Be(default(TimeSpan));
deserialized.DateTimeDefault.Should().Be(default(DateTime));
deserialized.DateTimeNullableDefault.Should().BeNull();
deserialized.CustomWithoutInterfaceDefault.Should().BeNull();
deserialized.CustomWithInterfaceDefault.Should().BeNull();
deserialized.StringArray.Should().Equal(expected.StringArray);
deserialized.StringCollection.Should().Equal(expected.StringCollection);
deserialized.IntCollection.Should().Equal(expected.IntCollection);
deserialized.TimeSpanCollection.Should().Equal(expected.TimeSpanCollection);
deserialized.DateTimeCollection.Should().Equal(expected.DateTimeCollection);
deserialized.CustomWithoutInterfaceCollection.Should().HaveCount(expected.CustomWithoutInterfaceCollection.Count());
deserialized.CustomWithInterfaceCollection.Should().HaveCount(expected.CustomWithInterfaceCollection.Count());
deserialized.EnumParseCollection.Should().Equal(expected.EnumParseCollection);
deserialized.EnumDefault.Should().Be(EnumParse.Default);
deserialized.EnumParse.Should().Be(expected.EnumParse);
deserialized.StringCollectionDefault.Should().BeNull();
deserialized.StringCollectionWithSingleEmptyString.Should().Equal(expected.StringCollectionWithSingleEmptyString);
deserialized.StringCollectionWithNulls.Should().Equal(expected.StringCollectionWithNulls);
}
var serializedPropertyBag1a = serializer1.SerializeToNamedPropertyBagWithStringValues(expected);
var serializedPropertyBag1b = serializer1.SerializeToNamedPropertyBagWithObjectValues(expected);
var serializedPropertyBag1c = serializer1.SerializeToOrdinalPropertyBagWithStringValues(expected);
var serializedPropertyBag1d = serializer1.SerializeToOrdinalPropertyBagWithObjectValues(expected);
var serializedPropertyBag2a = serializer2.SerializeToNamedPropertyBagWithStringValues(expected);
var serializedPropertyBag2b = serializer2.SerializeToNamedPropertyBagWithObjectValues(expected);
var serializedPropertyBag2c = serializer2.SerializeToOrdinalPropertyBagWithStringValues(expected);
var serializedPropertyBag2d = serializer2.SerializeToOrdinalPropertyBagWithObjectValues(expected);
// Act, Assert
expected.RoundtripSerializeViaPropertyBagWithCallbackVerification(ThrowIfObjectsDiffer, serializationConfigurationType1);
expected.RoundtripSerializeViaPropertyBagWithCallbackVerification(ThrowIfObjectsDiffer, serializationConfigurationType2);
var actualPropertyBag1a = serializer1.Deserialize <ComplicatedObject>(serializedPropertyBag1a);
var actualPropertyBag1b = serializer1.Deserialize <ComplicatedObject>(serializedPropertyBag1b);
var actualPropertyBag1c = serializer1.Deserialize <ComplicatedObject>(serializedPropertyBag1c);
var actualPropertyBag1d = serializer1.Deserialize <ComplicatedObject>(serializedPropertyBag1d);
var actualPropertyBag2a = serializer1.Deserialize <ComplicatedObject>(serializedPropertyBag2a);
var actualPropertyBag2b = serializer1.Deserialize <ComplicatedObject>(serializedPropertyBag2b);
var actualPropertyBag2c = serializer1.Deserialize <ComplicatedObject>(serializedPropertyBag2c);
var actualPropertyBag2d = serializer1.Deserialize <ComplicatedObject>(serializedPropertyBag2d);
ThrowIfObjectsDiffer(null, actualPropertyBag1a);
ThrowIfObjectsDiffer(null, actualPropertyBag1b);
ThrowIfObjectsDiffer(null, actualPropertyBag1c);
ThrowIfObjectsDiffer(null, actualPropertyBag1d);
ThrowIfObjectsDiffer(null, actualPropertyBag2a);
ThrowIfObjectsDiffer(null, actualPropertyBag2b);
ThrowIfObjectsDiffer(null, actualPropertyBag2c);
ThrowIfObjectsDiffer(null, actualPropertyBag2d);
}
public static void RoundTrip___Supported_scenarios___Works()
{
// Arrange
var serializer = new NaosPropertyBagSerializer();
var input = new ComplicatedObject
{
NullableDecimal = 29m,
BaseVersion = new InheritTypeDerive(),
DeriveVersion = new InheritTypeDerive(),
DeriveVersionArray = new[] { new InheritTypeDerive(), },
DeriveVersionCollection = new[] { new InheritTypeDerive(), }.ToList(),
String = A.Dummy <string>(),
Int = A.Dummy <int>(),
TimeSpan = A.Dummy <TimeSpan>(),
DateTime = A.Dummy <DateTime>(),
DateTimeNullable = A.Dummy <DateTime>(),
StringAttributed = A.Dummy <string>(),
CustomWithAttribute = new CustomWithAttribute(),
CustomWithoutInterface = new CustomWithoutInterface(),
CustomWithInterface = new CustomWithInterface(),
StringArray = new[] { A.Dummy <string>(), },
StringCollection = new[] { A.Dummy <string>(), }.ToList(),
IntCollection = new[] { A.Dummy <int>(), }.ToList(),
TimeSpanCollection = new[] { A.Dummy <TimeSpan>(), }.ToList(),
DateTimeCollection = new[] { A.Dummy <DateTime>(), }.ToList(),
CustomWithoutInterfaceCollection = new[] { new CustomWithoutInterface(), new CustomWithoutInterface(), }.ToList(),
CustomWithInterfaceCollection = new[] { new CustomWithInterface(), new CustomWithInterface(), }.ToList(),
CustomElementArray = new[] { new CustomElement(), new CustomElement(), },
CustomElementCollection = new[] { new CustomElement(), new CustomElement(), }.ToList(),
EnumParseCollection = new[] { EnumParse.Default, EnumParse.Value, },
EnumAttributeCollection = new[] { EnumAttribute.Default, EnumAttribute.Value, },
EnumAttributePropertyCollection = new[] { EnumAttributeProperty.Default, EnumAttributeProperty.Value, },
EnumParse = EnumParse.Value,
EnumAttribute = EnumAttribute.Value,
EnumAttributeProperty = EnumAttributeProperty.Value,
StringCollectionWithSingleEmptyString = new[] { string.Empty },
StringCollectionWithNulls = new[] { string.Empty, A.Dummy <string>(), null, string.Empty, null, A.Dummy <string>() },
};
// Act
var serializedPropertyBag = serializer.SerializeToPropertyBag(input);
var serializedString = serializer.SerializeToString(input);
var serializedBytes = serializer.SerializeToBytes(input);
var actualPropertyBag = serializer.Deserialize <ComplicatedObject>(serializedPropertyBag);
var actualString = serializer.Deserialize <ComplicatedObject>(serializedString);
var actualBytes = serializer.Deserialize <ComplicatedObject>(serializedBytes);
// Assert
void AssertCorrect(ComplicatedObject actual)
{
actual.NullableDecimal.Should().Be(input.NullableDecimal);
actual.NullableDecimalDefault.Should().BeNull();
actual.BaseVersion.Should().NotBeNull();
actual.DeriveVersion.Should().NotBeNull();
actual.DeriveVersionArray.Count().Should().Be(input.DeriveVersionArray.Count());
actual.DeriveVersionCollection.Count().Should().Be(input.DeriveVersionCollection.Count());
actual.String.Should().Be(input.String);
actual.Int.Should().Be(input.Int);
actual.TimeSpan.Should().Be(input.TimeSpan);
actual.DateTime.Should().Be(input.DateTime);
actual.DateTimeNullable.Should().Be(input.DateTimeNullable);
actual.StringAttributed.Should().Be(CustomStringSerializer.CustomReplacementString);
actual.CustomWithAttribute.Should().NotBeNull();
actual.CustomWithoutInterface.Should().NotBeNull();
actual.CustomWithInterface.Should().NotBeNull();
actual.StringDefault.Should().BeNull();
actual.IntDefault.Should().Be(default(int));
actual.TimeSpanDefault.Should().Be(default(TimeSpan));
actual.DateTimeDefault.Should().Be(default(DateTime));
actual.DateTimeNullableDefault.Should().BeNull();
actual.CustomWithoutInterfaceDefault.Should().BeNull();
actual.CustomWithInterfaceDefault.Should().BeNull();
actual.StringArray.Should().Equal(input.StringArray);
actual.StringCollection.Should().Equal(input.StringCollection);
actual.IntCollection.Should().Equal(input.IntCollection);
actual.TimeSpanCollection.Should().Equal(input.TimeSpanCollection);
actual.DateTimeCollection.Should().Equal(input.DateTimeCollection);
actual.CustomWithoutInterfaceCollection.Should().HaveCount(input.CustomWithoutInterfaceCollection.Count());
actual.CustomWithInterfaceCollection.Should().HaveCount(input.CustomWithInterfaceCollection.Count());
actual.CustomElementArray.Length.Should().Be(input.CustomElementArray.Length);
actual.CustomElementArray.Any(_ => _ == null).Should().BeFalse();
actual.CustomElementCollection.Count().Should().Be(input.CustomElementCollection.Count());
actual.CustomElementCollection.Any(_ => _ == null).Should().BeFalse();
actual.EnumParseCollection.Should().Equal(input.EnumParseCollection);
actual.EnumAttributeCollection.Should().BeEquivalentTo(Enumerable.Range(0, input.EnumAttributeCollection.Count).Select(_ => EnumAttributeProperty.Replaced));
actual.EnumAttributePropertyCollection.Should().BeEquivalentTo(Enumerable.Range(0, input.EnumAttributePropertyCollection.Count).Select(_ => EnumAttributeProperty.Replaced));
actual.EnumDefault.Should().Be(EnumParse.Default);
actual.EnumParse.Should().Be(input.EnumParse);
actual.EnumAttribute.Should().Be(EnumAttribute.Replaced);
actual.EnumAttributeProperty.Should().Be(EnumAttributeProperty.Replaced);
actual.StringCollectionDefault.Should().BeNull();
actual.StringCollectionWithSingleEmptyString.Should().Equal(input.StringCollectionWithSingleEmptyString);
actual.StringCollectionWithNulls.Should().Equal(input.StringCollectionWithNulls);
}
AssertCorrect(actualPropertyBag);
AssertCorrect(actualString);
AssertCorrect(actualBytes);
}
