public static void Assert_StructsAreEqual(Struct s, Struct sCopy)
{
// values are same and then are not the same
Assert.AreEqual(s.GetItem1(), sCopy.GetItem1());
sCopy.IncrementItem1();
Assert.AreNotEqual(s.GetItem1(), sCopy.GetItem1());
sCopy.DecrementItem1();
// Item23 and Item32 in struct should be the same instance (see constructor of Struct)
Assert.AreSame(sCopy._item23, sCopy._item32);
// reference field test
if (s._item23 != null)
{
SimpleClassTests.Assert_AreEqualButNotSame(s._item23, sCopy._item23);
}
// reference field test
if (s._item32 != null)
{
SimpleClassTests.Assert_AreEqualButNotSame(s._item32, sCopy._item32);
}
// readonly reference field test
if (s._item4 != null)
{
SimpleClassTests.Assert_AreEqualButNotSame(s._item4, sCopy._item4);
}
}
public static void Assert_DeeperStructsAreEqual(DeeperStruct s, DeeperStruct sCopy)
{
// values are same and then are not the same
Assert.AreEqual(s.GetItem1(), sCopy.GetItem1());
sCopy.IncrementItem1();
Assert.AreNotEqual(s.GetItem1(), sCopy.GetItem1());
sCopy.DecrementItem1();
// test that deep hidden class in structure of structs was copied well
if (s.GetItem2() != null)
{
SimpleClassTests.Assert_AreEqualButNotSame(s.GetItem2(), sCopy.GetItem2());
}
}
public static void Assert_AreEqualButNotSame(ModerateClass m, ModerateClass mCopy)
{
if (m == null && mCopy == null)
{
return;
}
// original and copy are different instances
Assert.AreNotSame(m, mCopy);
// the same values in fields
Assert.AreEqual(m._fieldPublic2, mCopy._fieldPublic2);
Assert.AreEqual(m.PropertyPublic2, mCopy.PropertyPublic2);
Assert.AreEqual(m._fieldPublic, mCopy._fieldPublic);
Assert.AreEqual(m.GetPrivateField2(), mCopy.GetPrivateField2());
Assert.AreEqual(m.GetPrivateProperty2(), mCopy.GetPrivateProperty2());
Assert.AreEqual(m.GetPrivateField(), mCopy.GetPrivateField());
Assert.AreEqual(m.GetPrivateProperty(), mCopy.GetPrivateProperty());
Assert.AreEqual((string)m.ObjectTextProperty, (string)mCopy.ObjectTextProperty);
// check that structs copied well (but with different instances of subclasses)
Assert_StructsAreEqual(m._structField, mCopy._structField);
// chech that classes in structs in structs are copied well
Assert_DeeperStructsAreEqual(m._deeperStructField, mCopy._deeperStructField);
// generic classes are well copied
Assert_GenericClassesAreEqual(m._genericClassField, mCopy._genericClassField);
// subclass in property copied well
SimpleClassTests.Assert_AreEqualButNotSame(m.SimpleClassProperty, mCopy.SimpleClassProperty);
// subclass in readonly field copied well
SimpleClassTests.Assert_AreEqualButNotSame(m._readonlySimpleClassField, mCopy._readonlySimpleClassField);
// array of subclasses copied well
if (m.SimpleClassArray != null)
{
Assert.AreEqual(m.SimpleClassArray.Length, mCopy.SimpleClassArray.Length);
for (var i = 0; i < m.SimpleClassArray.Length; i++)
{
SimpleClassTests.Assert_AreEqualButNotSame(m.SimpleClassArray[i], mCopy.SimpleClassArray[i]);
}
}
}
public static void Assert_GenericClassesAreEqual(GenericClass <SimpleClass> s, GenericClass <SimpleClass> sCopy)
{
if (s == null && sCopy == null)
{
return;
}
// test that subclass is equal but different instance
if (s._item1 != null)
{
SimpleClassTests.Assert_AreEqualButNotSame(s._item1, sCopy._item1);
}
// readonly reference field test
if (s._item2 != null)
{
SimpleClassTests.Assert_AreEqualButNotSame(s._item2, sCopy._item2);
}
}
public static void Assert_AreEqualButNotSame_ChooseForType(ISimpleClass s, ISimpleClass sCopy)
{
if (s == null && sCopy == null)
{
return;
}
if (s is ComplexClass)
{
Assert_AreEqualButNotSame((ComplexClass)s, (ComplexClass)sCopy);
}
else if (s is ModerateClass)
{
ModerateClassTests.Assert_AreEqualButNotSame((ModerateClass)s, (ModerateClass)sCopy);
}
else
{
SimpleClassTests.Assert_AreEqualButNotSame((SimpleClass)s, (SimpleClass)sCopy);
}
}
