public void MockedReturnStringReturnsJohnThenJohnnyThenJohnson()
        {
            //Arrange
            MockSamplesHelper mock = new MockSamplesHelper();

            Mock.Arrange(() => mock.ReturnString(Arg.AnyString)).Returns("John").InSequence();
            Mock.Arrange(() => mock.ReturnString(Arg.AnyString)).Returns("Johnny").InSequence();
            Mock.Arrange(() => mock.ReturnString(Arg.AnyString)).Returns("Johnson").InSequence();
            
            //Act
            string result1 = mock.ReturnString("");
            string result2 = mock.ReturnString("");
            string result3 = mock.ReturnString("");
            
            //Assert
            Assert.AreEqual("John",result1);
            Assert.AreEqual("Johnny",result2);
            Assert.AreEqual("Johnson", result3);
        }
        public void MockedAddReturnsOneThenTwoThenThree()
        {
            //Arrange
            MockSamplesHelper mock = new MockSamplesHelper();

            Mock.Arrange(() => mock.Add(Arg.AnyInt, Arg.AnyInt)).Returns(1).InSequence();
            Mock.Arrange(() => mock.Add(Arg.AnyInt, Arg.AnyInt)).Returns(2).InSequence();
            Mock.Arrange(() => mock.Add(Arg.AnyInt, Arg.AnyInt)).Returns(3).InSequence();
            
            //Act
            int result1 = mock.Add(3, 56);
            int result2 = mock.Add(234, 234);
            int result3 = mock.Add(254, 987);
            
            //Assert
            Assert.AreEqual(1,result1);
            Assert.AreEqual(2,result2);
            Assert.AreEqual(3,result3);
            Mock.Assert(mock);
        }
 public void MockedAddReturnsOnlyMockedResultsWhenTheFirstNumberIsBiggerThanTenAndOriginalMustBeCalled()
 {
     //Arrange
     MockSamplesHelper mock = new MockSamplesHelper();
     Mock.Arrange(() => mock.Add(Arg.Matches<int>(x => x > 10), Arg.AnyInt)).Returns(1).InSequence();
     Mock.Arrange(() => mock.Add(Arg.Matches<int>(x => x > 10), Arg.AnyInt)).Returns(2).InSequence();
     
     //Test fails if mock.Add(Arg.AnyInt,Arg.AnyInt) is mocked with CallOriginal()
     Mock.Arrange(() => mock.Add(Arg.Matches<int>(x => x < 10), Arg.AnyInt)).CallOriginal().MustBeCalled(); 
     
     //Act
     int firstMockedResult = mock.Add(234, 54);
     int notMockedResult = mock.Add(3, 54);
     int secondMockedResult = mock.Add(45, 23);
     
     //Assert
     Assert.AreEqual(1, firstMockedResult);
     Assert.AreNotEqual(1, notMockedResult);
     Assert.AreNotEqual(2, notMockedResult);
     Assert.AreEqual(2,secondMockedResult);
 }
        public void MockedAddReturns7IfCalledWithArguments1And1()
        {
            //Arrange
            MockSamplesHelper mock = new MockSamplesHelper();
            Mock.Arrange(() => mock.Add(1, 1))
                .Returns(7)
                .OccursOnce();
            
            //Act
            var result = mock.Add(1, 1);
            
            //Assert
            Assert.AreEqual(7,result);

            Mock.Assert(mock);
        }
 public void MockedDummyGetsCalledFromAdd()
 {
     //Arrange
     MockSamplesHelper mock = new MockSamplesHelper();
     Mock.Arrange(() => mock.Dummy(Arg.AnyString))
         .OccursOnce();
     
     //Act
     mock.Add(4, 3);
     
     //Assert
     Mock.Assert(mock);
 }
 public void MockedAddArgumentsAreInRangeFrom20To30()
 {
     //Arrange
     MockSamplesHelper mock = new MockSamplesHelper();
     Mock.Arrange(
         () => mock.Add(Arg.IsInRange(20, 30, RangeKind.Inclusive), Arg.IsInRange(20, 30, RangeKind.Inclusive)))
         .Returns(2)
         .OccursOnce();
    
     //Act
     var result = mock.Add(29, 27);
     
     //Assert
     Assert.AreEqual(2,result);
     Mock.Assert(mock);
 }
        public void MockedAddThrowsArgumentException()
        {
            //Arrange
            MockSamplesHelper mock = new MockSamplesHelper();
            Mock.Arrange(() => mock.Add(Arg.IsAny<int>(), Arg.IsAny<int>()))
                .Throws(new ArgumentException())
                .OccursOnce();
            
            //Act
            mock.Add(2, 2);

            // Assert
            Mock.Assert(mock);
        }
        public void MockedAddReturns4()
        {
            //Arrange
            int result = 0;
            MockSamplesHelper mock = new MockSamplesHelper();
            Mock.Arrange(() => mock.Add(Arg.IsAny<int>(), Arg.IsAny<int>()))
                .DoInstead(() => result = 4)
                .OccursOnce();
            
            //Act
            mock.Add(3, 3);
            
            //Assert
            Assert.AreEqual(result, 4);

            Mock.Assert(mock);
        }
        public void MockedDummySetsCalled()
        {
            //Arrange
            MockSamplesHelper mock = new MockSamplesHelper();
            Mock.Arrange(() => mock.Dummy(""))
                .DoInstead(() => _called = true)
                .OccursOnce();
            
            //Act
            mock.Dummy("");
           
            //Assert
            Assert.IsTrue(_called);

            Mock.Assert(mock);
        }