public void Equals_SameInstance_MustReturnTrue()
        {
            // Arrange
            var testClass = new TestClassChild();

            // Act
            var result = this.testCandidate.Equals(testClass, testClass);

            // Assert
            result.Should().BeTrue();
        }
        public void Copy_WhenAttributeRegistered_MustCopyAttribute()
        {
            // Arrange
            var source = new TestClassChild {
                Value1 = 45
            };
            var target = new TestClassChild();

            // Act
            this.testCandidate.Copy(source, target, new List <IBaseAdditionalProcessing>());

            // Assert
            target.Value1.Should().Be(45);
        }
        public void Equals_DifferentInstancesNotSameAttributesNotRegistered_MustReturnTrue()
        {
            // Arrange
            var testClass = new TestClassChild
            {
                TestValue2 = 1,
            };
            var testClass2 = new TestClassChild
            {
                TestValue2 = 11,
            };

            // Act
            var result = this.testCandidate.Equals(testClass, testClass2);

            // Assert
            result.Should().BeTrue();
        }
        public void Copy_MustExecuteAdditionalProcessings()
        {
            // Arrange
            var source = new TestClassChild();
            var target = new TestClassChild();
            var additionalProcessings = new List <IBaseAdditionalProcessing>
            {
                new GenericCopyPostProcessing <TestClassParent>((sourceX, targetX) => { target.Value1 = 27; }),
                new GenericCopyPostProcessing <TestClassParent>((sourceX, targetX) => { target.Value2 = 39; }),
            };

            // Act
            this.testCandidate.Copy(source, target, additionalProcessings);

            // Assert
            target.Value1.Should().Be(27);
            target.Value2.Should().Be(39);
        }
Exemple #5
0
            public void ShouldOverwritePropertyByExpression()
            {
                // arrange
                var builderMock = new Mock <IDynamicBuilder <TestClassParent> >();
                var child       = new TestClassChild();
                int parentValue = 1;

                builderMock.Setup(e => e.IsOverwritten(nameof(TestClassParent.ParentValueProperty))).Returns(true);
                builderMock.Setup(e => e.GetOverwrittenValue(nameof(TestClassParent.ParentValueProperty))).Returns(parentValue);
                builderMock.Setup(e => e.IsOverwritten(nameof(TestClassParent.Child))).Returns(true);
                builderMock.Setup(e => e.GetOverwrittenValue(nameof(TestClassParent.Child))).Returns(child);
                int expectedChildValue = parentValue + 1;

                // act
                var builder = DynamicBuilderExtensions.WithBuilderDependentChild(builderMock.Object, e => e.Child, (parentBuilder, childBuilder) => childBuilder
                                                                                 .WithValue(c => c.ChildValueProperty, parentBuilder.GetOverwrittenValue(e => e.ParentValueProperty) + 1));

                // assert
                builderMock.Verify(e => e.Overwrite(nameof(TestClassParent.Child), It.Is <TestClassChild>(c => c.ChildValueProperty == expectedChildValue)), Times.Once);
            }
        public void Equals_DifferentInstancesNotSameAttributesButExcludedBySubCompareExclusion_MustReturnTrue()
        {
            // Arrange
            var testClass = new TestClassChild
            {
                TestValue1 = 1,
            };
            var testClass2 = new TestClassChild
            {
                TestValue1 = 11,
            };

            var comparerExclusions = new List <IComparerExclusion>
            {
                new SubInterfaceComparerExclusion <TestClassParent>(),
            };

            // Act
            var result = this.testCandidate.Equals(testClass, testClass2, Array.Empty <IBaseAdditionalProcessing>(), comparerExclusions);

            // Assert
            result.Should().BeTrue();
        }