示例#1
0
        public void DeepPropertyBasedClonesOfValueTypesCanBeMade()
        {
            HierarchicalValueType original = CreateValueType();
            HierarchicalValueType clone    = this.cloneFactory.DeepPropertyClone(original);

            VerifyClone(ref original, ref clone, isDeepClone: true, isPropertyBasedClone: true);
        }
示例#2
0
        public void ShallowFieldBasedClonesOfValueTypesCanBeMade()
        {
            HierarchicalValueType original = CreateValueType();
            HierarchicalValueType clone    = this.cloneFactory.ShallowFieldClone(original);

            VerifyClone(ref original, ref clone, isDeepClone: false, isPropertyBasedClone: false);
        }
        public void DeepFieldBasedClonesOfValueTypesCanBeMade()
        {
            HierarchicalValueType original = CreateValueType();
            HierarchicalValueType clone    = this.cloneFactory.DeepFieldClone(original);

            VerifyClone(ref original, ref clone, true, false);
        }
        /// <summary>
        ///   Verifies that a cloned object exhibits the expected state for the type of
        ///   clone that has been performed
        /// </summary>
        /// <param name="original">Original instance the clone was created from</param>
        /// <param name="clone">Cloned instance that will be checked for correctness</param>
        /// <param name="isDeepClone">Whether the cloned instance is a deep clone</param>
        /// <param name="isPropertyBasedClone">
        ///   Whether a property-based clone was performed
        /// </param>
        protected static void VerifyClone(
      ref HierarchicalValueType original, ref HierarchicalValueType clone,
      bool isDeepClone, bool isPropertyBasedClone
    )
        {
            if(isPropertyBasedClone) {
            Assert.AreEqual(0, clone.TestField);
            Assert.AreEqual(0, clone.ValueTypeField.TestField);
            Assert.AreEqual(0, clone.ValueTypeField.TestProperty);
            Assert.AreEqual(0, clone.ValueTypeProperty.TestField);
            Assert.IsNull(clone.ReferenceTypeField);
            Assert.IsNull(clone.DerivedField);

            if(isDeepClone) {
              Assert.AreNotSame(original.ReferenceTypeProperty, clone.ReferenceTypeProperty);
              Assert.AreNotSame(
            original.ReferenceTypeArrayProperty, clone.ReferenceTypeArrayProperty
              );
              Assert.AreNotSame(original.DerivedProperty, clone.DerivedProperty);
              Assert.IsInstanceOf<DerivedReferenceType>(clone.DerivedProperty);

              var originalDerived = (DerivedReferenceType)original.DerivedProperty;
              var clonedDerived = (DerivedReferenceType)clone.DerivedProperty;
              Assert.AreEqual(originalDerived.TestProperty, clonedDerived.TestProperty);
              Assert.AreEqual(originalDerived.DerivedProperty, clonedDerived.DerivedProperty);

              Assert.AreEqual(0, clone.ReferenceTypeProperty.TestField);
              Assert.AreNotSame(
            original.ReferenceTypeArrayProperty[1, 3][0],
            clone.ReferenceTypeArrayProperty[1, 3][0]
              );
              Assert.AreNotSame(
            original.ReferenceTypeArrayProperty[1, 3][2],
            clone.ReferenceTypeArrayProperty[1, 3][2]
              );
              Assert.AreEqual(0, clone.ReferenceTypeArrayProperty[1, 3][0].TestField);
              Assert.AreEqual(0, clone.ReferenceTypeArrayProperty[1, 3][2].TestField);
            } else {
              Assert.AreSame(original.ReferenceTypeProperty, clone.ReferenceTypeProperty);
              Assert.AreSame(original.ReferenceTypeProperty, clone.ReferenceTypeProperty);
              Assert.AreSame(
            original.ReferenceTypeArrayProperty, clone.ReferenceTypeArrayProperty
              );
            }
              } else {
            Assert.AreEqual(original.TestField, clone.TestField);
            Assert.AreEqual(original.ValueTypeField.TestField, clone.ValueTypeField.TestField);
            Assert.AreEqual(original.ValueTypeField.TestProperty, clone.ValueTypeField.TestProperty);
            Assert.AreEqual(
              original.ValueTypeProperty.TestField, clone.ValueTypeProperty.TestField
            );
            Assert.AreEqual(
              original.ReferenceTypeField.TestField, clone.ReferenceTypeField.TestField
            );
            Assert.AreEqual(
              original.ReferenceTypeField.TestProperty, clone.ReferenceTypeField.TestProperty
            );
            Assert.AreEqual(
              original.ReferenceTypeProperty.TestField, clone.ReferenceTypeProperty.TestField
            );

            if(isDeepClone) {
              Assert.AreNotSame(original.ReferenceTypeField, clone.ReferenceTypeField);
              Assert.AreNotSame(original.ReferenceTypeProperty, clone.ReferenceTypeProperty);
              Assert.AreNotSame(original.DerivedField, clone.DerivedField);
              Assert.AreNotSame(original.DerivedProperty, clone.DerivedProperty);
              Assert.IsInstanceOf<DerivedReferenceType>(clone.DerivedField);
              Assert.IsInstanceOf<DerivedReferenceType>(clone.DerivedProperty);

              var originalDerived = (DerivedReferenceType)original.DerivedField;
              var clonedDerived = (DerivedReferenceType)clone.DerivedField;
              Assert.AreEqual(originalDerived.TestField, clonedDerived.TestField);
              Assert.AreEqual(originalDerived.TestProperty, clonedDerived.TestProperty);
              Assert.AreEqual(originalDerived.DerivedField, clonedDerived.DerivedField);
              Assert.AreEqual(originalDerived.DerivedProperty, clonedDerived.DerivedProperty);

              originalDerived = (DerivedReferenceType)original.DerivedProperty;
              clonedDerived = (DerivedReferenceType)clone.DerivedProperty;
              Assert.AreEqual(originalDerived.TestField, clonedDerived.TestField);
              Assert.AreEqual(originalDerived.TestProperty, clonedDerived.TestProperty);
              Assert.AreEqual(originalDerived.DerivedField, clonedDerived.DerivedField);
              Assert.AreEqual(originalDerived.DerivedProperty, clonedDerived.DerivedProperty);

              Assert.AreNotSame(
            original.ReferenceTypeArrayField, clone.ReferenceTypeArrayField
              );
              Assert.AreNotSame(
            original.ReferenceTypeArrayProperty, clone.ReferenceTypeArrayProperty
              );
              Assert.AreNotSame(
            original.ReferenceTypeArrayProperty[1, 3][0],
            clone.ReferenceTypeArrayProperty[1, 3][0]
              );
              Assert.AreNotSame(
            original.ReferenceTypeArrayProperty[1, 3][2],
            clone.ReferenceTypeArrayProperty[1, 3][2]
              );
              Assert.AreEqual(
            original.ReferenceTypeArrayProperty[1, 3][0].TestField,
            clone.ReferenceTypeArrayProperty[1, 3][0].TestField
              );
              Assert.AreEqual(
            original.ReferenceTypeArrayProperty[1, 3][2].TestField,
            clone.ReferenceTypeArrayProperty[1, 3][2].TestField
              );
            } else {
              Assert.AreSame(original.DerivedField, clone.DerivedField);
              Assert.AreSame(original.DerivedProperty, clone.DerivedProperty);
              Assert.AreSame(original.ReferenceTypeField, clone.ReferenceTypeField);
              Assert.AreSame(original.ReferenceTypeProperty, clone.ReferenceTypeProperty);
              Assert.AreSame(
            original.ReferenceTypeArrayField, clone.ReferenceTypeArrayField
              );
              Assert.AreSame(
            original.ReferenceTypeArrayProperty, clone.ReferenceTypeArrayProperty
              );
            }
              }

              Assert.AreEqual(original.TestProperty, clone.TestProperty);
              Assert.AreEqual(
            original.ValueTypeProperty.TestProperty, clone.ValueTypeProperty.TestProperty
              );
              Assert.AreEqual(
            original.ReferenceTypeProperty.TestProperty, clone.ReferenceTypeProperty.TestProperty
              );
              Assert.AreEqual(
            original.ReferenceTypeArrayProperty[1, 3][0].TestProperty,
            clone.ReferenceTypeArrayProperty[1, 3][0].TestProperty
              );
              Assert.AreEqual(
            original.ReferenceTypeArrayProperty[1, 3][2].TestProperty,
            clone.ReferenceTypeArrayProperty[1, 3][2].TestProperty
              );
        }
        /// <summary>
        ///   Verifies that a cloned object exhibits the expected state for the type of
        ///   clone that has been performed
        /// </summary>
        /// <param name="original">Original instance the clone was created from</param>
        /// <param name="clone">Cloned instance that will be checked for correctness</param>
        /// <param name="isDeepClone">Whether the cloned instance is a deep clone</param>
        /// <param name="isPropertyBasedClone">
        ///   Whether a property-based clone was performed
        /// </param>
        protected static void VerifyClone(
            ref HierarchicalValueType original, ref HierarchicalValueType clone,
            bool isDeepClone, bool isPropertyBasedClone
            )
        {
            if (isPropertyBasedClone)
            {
                Assert.AreEqual(0, clone.TestField);
                Assert.AreEqual(0, clone.ValueTypeField.TestField);
                Assert.AreEqual(0, clone.ValueTypeField.TestProperty);
                Assert.AreEqual(0, clone.ValueTypeProperty.TestField);
                Assert.IsNull(clone.ReferenceTypeField);
                Assert.IsNull(clone.DerivedField);

                if (isDeepClone)
                {
                    Assert.AreNotSame(original.ReferenceTypeProperty, clone.ReferenceTypeProperty);
                    Assert.AreNotSame(
                        original.ReferenceTypeArrayProperty, clone.ReferenceTypeArrayProperty
                        );
                    Assert.AreNotSame(original.DerivedProperty, clone.DerivedProperty);
                    Assert.IsInstanceOf <DerivedReferenceType>(clone.DerivedProperty);

                    var originalDerived = (DerivedReferenceType)original.DerivedProperty;
                    var clonedDerived   = (DerivedReferenceType)clone.DerivedProperty;
                    Assert.AreEqual(originalDerived.TestProperty, clonedDerived.TestProperty);
                    Assert.AreEqual(originalDerived.DerivedProperty, clonedDerived.DerivedProperty);

                    Assert.AreEqual(0, clone.ReferenceTypeProperty.TestField);
                    Assert.AreNotSame(
                        original.ReferenceTypeArrayProperty[1, 3][0],
                        clone.ReferenceTypeArrayProperty[1, 3][0]
                        );
                    Assert.AreNotSame(
                        original.ReferenceTypeArrayProperty[1, 3][2],
                        clone.ReferenceTypeArrayProperty[1, 3][2]
                        );
                    Assert.AreEqual(0, clone.ReferenceTypeArrayProperty[1, 3][0].TestField);
                    Assert.AreEqual(0, clone.ReferenceTypeArrayProperty[1, 3][2].TestField);
                }
                else
                {
                    Assert.AreSame(original.ReferenceTypeProperty, clone.ReferenceTypeProperty);
                    Assert.AreSame(original.ReferenceTypeProperty, clone.ReferenceTypeProperty);
                    Assert.AreSame(
                        original.ReferenceTypeArrayProperty, clone.ReferenceTypeArrayProperty
                        );
                }
            }
            else
            {
                Assert.AreEqual(original.TestField, clone.TestField);
                Assert.AreEqual(original.ValueTypeField.TestField, clone.ValueTypeField.TestField);
                Assert.AreEqual(original.ValueTypeField.TestProperty, clone.ValueTypeField.TestProperty);
                Assert.AreEqual(
                    original.ValueTypeProperty.TestField, clone.ValueTypeProperty.TestField
                    );
                Assert.AreEqual(
                    original.ReferenceTypeField.TestField, clone.ReferenceTypeField.TestField
                    );
                Assert.AreEqual(
                    original.ReferenceTypeField.TestProperty, clone.ReferenceTypeField.TestProperty
                    );
                Assert.AreEqual(
                    original.ReferenceTypeProperty.TestField, clone.ReferenceTypeProperty.TestField
                    );

                if (isDeepClone)
                {
                    Assert.AreNotSame(original.ReferenceTypeField, clone.ReferenceTypeField);
                    Assert.AreNotSame(original.ReferenceTypeProperty, clone.ReferenceTypeProperty);
                    Assert.AreNotSame(original.DerivedField, clone.DerivedField);
                    Assert.AreNotSame(original.DerivedProperty, clone.DerivedProperty);
                    Assert.IsInstanceOf <DerivedReferenceType>(clone.DerivedField);
                    Assert.IsInstanceOf <DerivedReferenceType>(clone.DerivedProperty);

                    var originalDerived = (DerivedReferenceType)original.DerivedField;
                    var clonedDerived   = (DerivedReferenceType)clone.DerivedField;
                    Assert.AreEqual(originalDerived.TestField, clonedDerived.TestField);
                    Assert.AreEqual(originalDerived.TestProperty, clonedDerived.TestProperty);
                    Assert.AreEqual(originalDerived.DerivedField, clonedDerived.DerivedField);
                    Assert.AreEqual(originalDerived.DerivedProperty, clonedDerived.DerivedProperty);

                    originalDerived = (DerivedReferenceType)original.DerivedProperty;
                    clonedDerived   = (DerivedReferenceType)clone.DerivedProperty;
                    Assert.AreEqual(originalDerived.TestField, clonedDerived.TestField);
                    Assert.AreEqual(originalDerived.TestProperty, clonedDerived.TestProperty);
                    Assert.AreEqual(originalDerived.DerivedField, clonedDerived.DerivedField);
                    Assert.AreEqual(originalDerived.DerivedProperty, clonedDerived.DerivedProperty);

                    Assert.AreNotSame(
                        original.ReferenceTypeArrayField, clone.ReferenceTypeArrayField
                        );
                    Assert.AreNotSame(
                        original.ReferenceTypeArrayProperty, clone.ReferenceTypeArrayProperty
                        );
                    Assert.AreNotSame(
                        original.ReferenceTypeArrayProperty[1, 3][0],
                        clone.ReferenceTypeArrayProperty[1, 3][0]
                        );
                    Assert.AreNotSame(
                        original.ReferenceTypeArrayProperty[1, 3][2],
                        clone.ReferenceTypeArrayProperty[1, 3][2]
                        );
                    Assert.AreEqual(
                        original.ReferenceTypeArrayProperty[1, 3][0].TestField,
                        clone.ReferenceTypeArrayProperty[1, 3][0].TestField
                        );
                    Assert.AreEqual(
                        original.ReferenceTypeArrayProperty[1, 3][2].TestField,
                        clone.ReferenceTypeArrayProperty[1, 3][2].TestField
                        );
                }
                else
                {
                    Assert.AreSame(original.DerivedField, clone.DerivedField);
                    Assert.AreSame(original.DerivedProperty, clone.DerivedProperty);
                    Assert.AreSame(original.ReferenceTypeField, clone.ReferenceTypeField);
                    Assert.AreSame(original.ReferenceTypeProperty, clone.ReferenceTypeProperty);
                    Assert.AreSame(
                        original.ReferenceTypeArrayField, clone.ReferenceTypeArrayField
                        );
                    Assert.AreSame(
                        original.ReferenceTypeArrayProperty, clone.ReferenceTypeArrayProperty
                        );
                }
            }

            Assert.AreEqual(original.TestProperty, clone.TestProperty);
            Assert.AreEqual(
                original.ValueTypeProperty.TestProperty, clone.ValueTypeProperty.TestProperty
                );
            Assert.AreEqual(
                original.ReferenceTypeProperty.TestProperty, clone.ReferenceTypeProperty.TestProperty
                );
            Assert.AreEqual(
                original.ReferenceTypeArrayProperty[1, 3][0].TestProperty,
                clone.ReferenceTypeArrayProperty[1, 3][0].TestProperty
                );
            Assert.AreEqual(
                original.ReferenceTypeArrayProperty[1, 3][2].TestProperty,
                clone.ReferenceTypeArrayProperty[1, 3][2].TestProperty
                );
        }