Example #1
0
        public void ChecksCallCountToAssertThatItHasBeenMet()
        {
            var irrelevant = Is.Anything;
            var mock       = new ReflectiveInterceptor(null, null, "name", MockStyle.Default);

            var expectation = BuildExpectation(
                "description",
                Is.AtLeast(2),
                Is.AtMost(4),
                mock,
                irrelevant,
                irrelevant,
                irrelevant,
                irrelevant);

            AssertHasNotBeenMet(expectation, "should not have been met after no invocations");

            expectation.Perform(invocation);
            AssertHasNotBeenMet(expectation, "should not have been met after 1 invocation");

            expectation.Perform(invocation);
            AssertHasBeenMet(expectation, "should have been met after 2 invocations");

            expectation.Perform(invocation);
            AssertHasBeenMet(expectation, "should have been met after 3 invocations");

            expectation.Perform(invocation);
            AssertHasBeenMet(expectation, "should have been met after 4 invocations");
        }
Example #2
0
        public void MatchesCallCountWhenMatchingInvocation()
        {
            Matcher irrelevant = Is.Anything;

            BuildableExpectation expectation = (BuildableExpectation)BuildExpectation(
                "description",
                Is.AtLeast(0),
                Is.AtMost(4),
                receiver.MockObject,
                irrelevant,
                irrelevant,
                irrelevant,
                irrelevant);

            AssertIsActive(expectation, "should be active before any invocation");
            Assert.IsTrue(expectation.Matches(invocation), "should match 1st invocation");
            expectation.Perform(invocation);

            AssertIsActive(expectation, "should be active before 2nd invocation");
            Assert.IsTrue(expectation.Matches(invocation), "should match 2nd invocation");
            expectation.Perform(invocation);

            AssertIsActive(expectation, "should be active before 3rd invocation");
            Assert.IsTrue(expectation.Matches(invocation), "should match 3rd invocation");
            expectation.Perform(invocation);

            AssertIsActive(expectation, "should be active before 4th invocation");
            Assert.IsTrue(expectation.Matches(invocation), "should match 4th invocation");
            expectation.Perform(invocation);

            AssertIsNotActive(expectation, "should not be active after 4th invocation");
            Assert.IsFalse(expectation.Matches(invocation), "should not match 5th invocation");
        }
Example #3
0
 public IExpectMatchSyntax Arrange(Action <T> expression)
 {
     return(new ExpectationBuilder <T>("1 time", Is.AtLeast(1), Is.AtMost(1), _proxy).Parse(expression));
 }
Example #4
0
 public IExpectMatchSyntax <TResult> Arrange <TResult>(Func <T, TResult> expression)
 {
     return(new ExpectationBuilder <T>("1 time", Is.AtLeast(1), Is.AtMost(1), _proxy).Parse(expression));
 }
Example #5
0
 /// <summary>
 /// Creates an expectation for exactly <c>count</c> number of calls for the referenced member.
 /// </summary>
 /// <param name="count">The exact number of calls expect</param>
 /// <returns>An <see cref="IMethodSyntax{T}"/> to reference the expected call.</returns>
 public IMethodSyntax <T> Exactly(int count)
 {
     return(GetExpectationBuilder(count.Times(), Is.AtLeast(count), Is.AtMost(count), _proxy));
 }
Example #6
0
 /// <summary>
 /// Creates an expectation for a range from <c>minCount</c> to <c>maxCount</c> number of calls for the referenced member.
 /// </summary>
 /// <param name="minCount">The minimum number of expected calls.</param>
 /// <param name="maxCount">The maximum number of expected calls.</param>
 /// <returns>An <see cref="IMethodSyntax{T}"/> to reference the expected call.</returns>
 public IMethodSyntax <T> Between(int minCount, int maxCount)
 {
     return(GetExpectationBuilder(minCount + " to " + maxCount + " times", Is.AtLeast(minCount), Is.AtMost(maxCount), _proxy));
 }
Example #7
0
 /// <summary>
 /// Creates an expectation for at most <c>count</c> number of calls for the referenced member.
 /// </summary>
 /// <param name="count">The maximum number of calls expect</param>
 /// <returns>An <see cref="IMethodSyntax{T}"/> to reference the expected call.</returns>
 public IMethodSyntax <T> AtMost(int count)
 {
     return(GetExpectationBuilder("at most " + count.Times(), Is.Anything, Is.AtMost(count), _proxy));
 }
Example #8
0
        private void WithArgumentsTest1(Mock <IParentInterface> mock)
        {
            var expectations = new Expectations(4);

            using (Factory.Ordered())
            {
                expectations[0] = mock.Expects.One.Method(_ => _.MethodVoid(0, 0, 0)).With(1, 2, 3);
                expectations[1] = mock.Expects.One.Method(_ => _.MethodVoid(0, 0, 0)).With(Is.EqualTo(4), Is.AtLeast(5), Is.AtMost(6));
                expectations[2] = mock.Expects.One.Method(_ => _.MethodVoid(0, 0, 0)).With(7, Is.AtLeast(8), 9);
                expectations[3] = mock.Expects.One.Method(_ => _.MethodVoid(0, 0, 0)).With(
                    new PredicateMatcher <int>(parameter => parameter == 10),
                    Is.Match <int>(parameter => parameter == 11),
                    Is.Anything);
            }

            mock.MockObject.MethodVoid(1, 2, 3);
            mock.MockObject.MethodVoid(4, 5, 6);
            mock.MockObject.MethodVoid(7, 8, 9);
            mock.MockObject.MethodVoid(10, 11, 12);

            expectations.ForEach(_ => _.Assert());
        }
Example #9
0
        private void WithArgumentsTest(IParentInterface instance)
        {
            using (Factory.Ordered())
            {
                Expect.On(instance).One.Method(_ => _.MethodVoid(0, 0, 0)).With(1, 2, 3);
                Expect.On(instance).One.Method(_ => _.MethodVoid(0, 0, 0)).With(Is.EqualTo(4), Is.AtLeast(5), Is.AtMost(6));
                Expect.On(instance).One.Method(_ => _.MethodVoid(0, 0, 0)).With(7, Is.AtLeast(8), 9);
                Expect.On(instance).One.Method(_ => _.MethodVoid(0, 0, 0)).With(
                    new PredicateMatcher <int>(parameter => parameter == 10),
                    Is.Match <int>(parameter => parameter == 11),
                    Is.Anything);
            }

            instance.MethodVoid(1, 2, 3);
            instance.MethodVoid(4, 5, 6);
            instance.MethodVoid(7, 8, 9);
            instance.MethodVoid(10, 11, 12);
        }