public void ClonesInt()
{
int original = 42;
int clone = ObjectCloner.DeepClone(original);
Assert.Equal(original, clone);
}
public void ClonesStringWithoutAllocation()
{
string original = "Hello world";
string clone = ObjectCloner.DeepClone(original);
Assert.Same(original, clone);
}
public void HandlesNullFields()
{
TestStruct originalStruct = new TestStruct();
TestStruct result = ObjectCloner.DeepClone(originalStruct);
Assert.Null(result.ClassProp);
}
public void DeepClonesPrivateField()
{
ClassWithAPrivateField original = new ClassWithAPrivateField(42);
ClassWithAPrivateField clone = ObjectCloner.DeepClone(original);
Assert.NotSame(original.GetPrivateField(), clone.GetPrivateField());
Assert.Equal(original.GetPrivateField(), clone.GetPrivateField());
}
public void CopiesArraysOfStructs()
{
DateTime[] originalArray = { new DateTime(1997, 11, 6), new DateTime(2019, 7, 28) };
DateTime[] newArray = ObjectCloner.DeepClone(originalArray);
Assert.NotSame(originalArray, newArray);
Assert.Equal(originalArray, newArray);
}
public void CopiesArraysOfPrimitives()
{
int[] originalArray = { 3, 42, 123 };
int[] newArray = ObjectCloner.DeepClone(originalArray);
Assert.NotSame(originalArray, newArray);
Assert.Equal(originalArray, newArray);
}
public void CopyesReadOnlyClassField()
{
TestStructWithReadOnlyClassField original = new TestStructWithReadOnlyClassField(new TestClass {
SomeValue = 42
});
var clone = ObjectCloner.DeepClone(original);
Assert.Equal(42, clone.ClassField.SomeValue);
}
public void CopiesArraysOfClasses()
{
TestClass[] originalArray = { new TestClass(2), new TestClass(3), new TestClass(5), };
TestClass[] newArray = ObjectCloner.DeepClone(originalArray);
// Assert same values but different objects
Assert.NotSame(originalArray, newArray);
Assert.NotEqual((IEnumerable <TestClass>)originalArray, newArray, ReferenceEqualityComparer <TestClass> .Default);
Assert.Equal(originalArray, newArray, EqualityComparer <TestClass> .Default);
}
public void ClonesPropertyOnBaseClass()
{
var input = new MainTestClass
{
ListClassesBase = new List <SecondClass>()
};
var clone = ObjectCloner.DeepClone(input);
Assert.NotSame(input.ListClassesBase, clone.ListClassesBase);
}
public void DeepClonesByInterface()
{
TestClassTwo innerData = new TestClassTwo(42);
TestClass original = new TestClass(innerData);
TestClass clone = ObjectCloner.DeepClone(original);
Assert.NotSame(clone.TestListPolymorphic, original.TestListPolymorphic);
Assert.NotSame(clone.TestListPolymorphic.Last(), original.TestListPolymorphic.Last());
Assert.Equal(clone.TestListPolymorphic.Last().SomeProp, original.TestListPolymorphic.Last().SomeProp);
}
public void HandlesSameReferenceMultipleTimes()
{
TestClassTwo originalClass = new TestClassTwo(42);
TestClassTwo[] originalArray = new[] { originalClass, originalClass };
var clone = ObjectCloner.DeepClone(originalArray);
Assert.Same(clone[0], clone[1]);
Assert.NotSame(clone[0], originalClass);
}
public void HandlesCircularReferences()
{
TestClassOne original = new TestClassOne();
TestClassTwo originalTwo = new TestClassTwo(42);
original.ClassReference = originalTwo;
originalTwo.CircularReferenceProp = original;
TestClassOne clone = ObjectCloner.DeepClone(original);
Assert.NotSame(original, clone.ClassReference.CircularReferenceProp);
Assert.Same(clone, clone.ClassReference.CircularReferenceProp);
}
public void CopiesStructWithClassInside()
{
TestClass originalClass = new TestClass()
{
SomeValue = 42
};
TestStruct originalStruct = new TestStruct
{
PrimitiveProp = 42,
ClassProp = originalClass
};
TestStruct resultStruct = ObjectCloner.DeepClone(originalStruct);
Assert.Equal(originalStruct.PrimitiveProp, resultStruct.PrimitiveProp);
Assert.NotSame(originalStruct.ClassProp, resultStruct.ClassProp);
Assert.Equal(originalStruct.ClassProp.SomeValue, resultStruct.ClassProp.SomeValue);
}
public void HandlesComplexExample()
{
TestClassOne original = new TestClassOne()
{
ClassReference = null,
NullString = null,
StructProp = new TestStruct()
{
IntegerOne = 4,
IntegerTwo = 2
},
StructArrayProp = new []
{
new TestStruct(6, 9),
new TestStruct(),
},
DictionaryProp = new Dictionary <string, TestClassTwo>
{
{ "ASD", new TestClassTwo(42) },
{ "BSD", new TestClassTwo(99) }
}
};
TestClassOne clone = ObjectCloner.DeepClone(original);
// TODO: break this into multiple smaller tests - the number of asssertions is a code smell itself
Assert.NotSame(original, clone);
Assert.Null(clone.NullString);
Assert.Null(clone.ClassReference);
Assert.Equal(4, clone.StructProp.IntegerOne);
Assert.Equal(2, clone.StructProp.IntegerTwo);
Assert.NotSame(original.StructArrayProp, clone.StructArrayProp);
Assert.Equal((IEnumerable <TestStruct>)original.StructArrayProp, clone.StructArrayProp);
Assert.NotSame(original.DictionaryProp, clone.DictionaryProp);
Assert.NotSame(original.DictionaryProp["BSD"], clone.DictionaryProp["BSD"]);
Assert.Equal(99, original.DictionaryProp["BSD"].PrimitiveProp);
}
/// <summary>
/// <para>Performs a deep clone on <paramref name="original" />.</para>
/// <seealso cref="ObjectCloner.DeepClone{T}"/>
/// </summary>
/// <remarks>
/// Equivalent with <code>ObjectCloner.DeepClone(original)</code>.
/// </remarks>
/// <param name="original">The object to clone.</param>
public static T DeepClone <T>(this T original) => ObjectCloner.DeepClone(original);
public void HandlesNull()
{
string clone = ObjectCloner.DeepClone <string>(null);
Assert.Null(clone);
}
public void HandlesNull()
{
TestClassOne clone = ObjectCloner.DeepClone <TestClassOne>(null);
Assert.Null(clone);
}
public object ObjectClonerDeepClone()
{
return(ObjectCloner.DeepClone(Original));
}
