Пример #1
0
        public void Dispatch_ShouldTraverseOnHierarchyDownwards()
        {
            IRealComposite
                root  = new RealComposite(),
                child = new RealComposite();

            var mockGrandChild = new Mock <IRealComposite>(MockBehavior.Strict);

            mockGrandChild
            .Setup(i => i.Bar())
            .Returns("cica");

            IRealComposite parent = null;

            mockGrandChild
            .SetupGet(i => i.Parent)
            .Returns(() => parent);

#pragma warning disable CS0618 // Type or member is obsolete
            mockGrandChild
            .SetupSet(i => i.Parent)
#pragma warning restore CS0618
            .Callback(val => parent = val);

            child.Children.Add(mockGrandChild.Object);
            root.Children.Add(child);

            root.Bar();

            mockGrandChild.Verify(i => i.Bar(), Times.Once);
        }
Пример #2
0
        public void Dispatch_ShouldInvokeTheChildMethodsWithTheAppropriateArguments()
        {
            IRealComposite root = new RealComposite();

            Mock <IRealComposite>
            child1     = CreateChild(),
                child2 = CreateChild();

            Mock <IRealComposite> CreateChild()
            {
                var result = new Mock <IRealComposite>(MockBehavior.Strict);

                result
                .Setup(i => i.Bar())
                .Returns("cica");

                result
                .Setup(i => i.Foo(1986));

                IRealComposite parent = null;

                result
                .SetupGet(i => i.Parent)
                .Returns(() => parent);

#pragma warning disable CS0618 // Type or member is obsolete
                result
                .SetupSet(i => i.Parent)
#pragma warning restore CS0618
                .Callback(val => parent = val);

                result
                .Setup(i => i.Dispose())
                .Callback(() => root.Children.Remove(result.Object));

                return(result);
            }

            root.Children.Add(child1.Object);
            root.Children.Add(child2.Object);

            root.Foo(1986);

            child1.Verify(i => i.Foo(1986), Times.Once);
            child2.Verify(i => i.Foo(1986), Times.Once);

            Assert.That(root.Bar(), Is.EqualTo("cica cica"));

            root.Dispose();

            child1.Verify(i => i.Dispose(), Times.Once);
            child2.Verify(i => i.Dispose(), Times.Once);
        }