+ namespace TestWithCpp
+ {
+ int globalFunction(int a) {return a;}
+ }
+
+ And the test
+
+ [Test]
+ void Global() {
+ Mock* mock = MockManager::Mock(__typeof(GlobalType));
+ mock->ExpectAndReturn("TestWithCpp.globalFunction",__box(5));
+ Assert::AreEqual(__box(5), __box(globalFunction(4)));
+ }
+
+
+ [Test]
+ public void Test()
+ {
+ // Start mocking TestedClass
+ Mock mock = MockManager.Mock(typeof(TestedClass));
+ // first time passInt will be called, arguments must be 10
+ mock.ExpectCall("passInt").Args(10);
+ // second time 1
+ mock.ExpectCall("passInt").Args(1);
+ TestedClass t = new TestedClass();
+ // This will pass
+ t.passInt(10);
+ // This will fail
+ t.passInt(3);
+ MockManager.Verify();
+ }
+
+
+ <Test()> _
+ Public Sub Test()
+ ' Start mocking TestedClass
+ Dim mock As Mock = MockManager.Mock(GetType(TestedClass))
+ ' first time passInt will be called, arguments must be 10
+ mock.ExpectCall("passInt").Args(10)
+ ' second time 1
+ mock.ExpectCall("passInt").Args(1)
+ Dim t As TestedClass = New TestedClass
+ ' This will pass
+ t.passInt(10)
+ ' This will fail
+ t.passInt(3)
+ MockManager.Verify()
+ End Sub
+
+
+ [Test]
+ public void Test()
+ {
+ // Start mocking
+ using (RecordExpectations recorder = RecorderManager.StartRecording())
+ {
+ // CAUTION: ALL calls here are mocked!!!
+ // make all future instances mocked and all statements repeat
+ recorder.DefaultBehavior.RepeatAlways();
+ // Mock (all) new instance of TestedClass
+ TestedClass mockedTestedClass = new TestedClass();
+ // DoSomething to be mocked.
+ mockedTestedClass.GetSomething().DoSomething();
+ // always return 10
+ recorder.Return(10);
+ }
+ }
+
+
+ ' Visual Basic .NET 2.0
+ <Test()> _
+ Public Sub Test()
+ ' Start mocking
+ Using recorder As New RecordExpectations
+ ' CAUTION: ALL calls here are mocked!!!
+ ' make all future instances mocked and all statements repeat
+ recorder.DefaultBehavior.RepeatAlways()
+ ' Mock (all) new instance of TestedClass
+ Dim mockedTestedClass As TestedClass = New TestedClass
+ ' DoSomething to be mocked.
+ mockedTestedClass.GetSomething().DoSomething()
+ ' always return 10
+ recorder.Return(10)
+ End Using
+ End Sub
+
+ For VB .NET 1.1 see
+ [Test]
+ public void Test()
+ {
+ // Start mocking
+ using (RecordExpectations recorder = RecorderManager.StartRecording())
+ {
+ // CAUTION: ALL calls here are mocked!!!
+ recorder.DefaultBehavior.CheckArguments();
+ // Mock (all) new instance of TestedClass
+ TestedClass mockedTestedClass = new TestedClass();
+ // DoSomething to be mocked.
+ mockedTestedClass.GetSomething("TypeMock").DoSomething("magic");
+ }
+ }
+
+
+ ' Visual Basic .NET 2.0
+ <Test()> _
+ Public Sub Test()
+ ' Start mocking
+ Using recorder As New RecordExpectations
+ ' CAUTION: ALL calls here are mocked!!!
+ recorder.DefaultBehavior.CheckArguments()
+ ' Mock (all) new instance of TestedClass
+ Dim mockedTestedClass As TestedClass = New TestedClass
+ ' DoSomething to be mocked.
+ mockedTestedClass.GetSomething("TypeMock").DoSomething("magic")
+ End Using
+ End Sub
+
+ For VB .NET 1.1 see
+ [Test]
+ public void Test()
+ {
+ // Start mocking
+ using (RecordExpectations recorder = RecorderManager.StartRecording())
+ {
+ // CAUTION: ALL calls here are mocked!!!
+ recorder.DefaultBehavior.CheckArguments();
+ // Mock (all) new instance of TestedClass
+ TestedClass mockedTestedClass = new TestedClass();
+ // DoSomething to be mocked.
+ mockedTestedClass.GetSomething(null).DoSomething(null);
+ recorder.CheckArguments(Check.IsIn("TypeMock", "NaturalMock"),Check.StartsWith("s"));
+ }
+ }
+
+
+ ' Visual Basic .NET 2.0
+ <Test()> _
+ Public Sub Test()
+ ' Start mocking
+ Using recorder As New RecordExpectations
+ ' CAUTION: ALL calls here are mocked!!!
+ recorder.DefaultBehavior.CheckArguments()
+ ' Mock (all) new instance of TestedClass
+ Dim mockedTestedClass As TestedClass = New TestedClass
+ ' DoSomething to be mocked.
+ mockedTestedClass.GetSomething(null).DoSomething(null);
+ recorder.CheckArguments(Check.IsIn("TypeMock","NaturalMock"),Check.StartsWith("s"))
+ End Using
+ End Sub
+
+ For VB .NET 1.1 see
+ [TestFixture]
+ [ClearMocks] // clear all mocks between tests
+ public TestClass
+ {
+ [Test]
+ public void MyTest1()
+ {
+ // the test code
+ }
+ }
+
+
+ < TestFixture >_
+ < ClearMocks >_ ' clear all mocks between tests
+ Public class TestClass
+ < Test >_
+ Public Sub MyTest1()
+ ' the test code
+ End Sub
+ End Class
+
+
+ [Test]
+ public void GetMockOfSpecificInstance()
+ {
+ using(RecordExpectations rec = RecorderManager.StartRecording())
+ {
+ TestClass instance1 = new TestClass();
+ TestClass instance2 = new TestClass();
+ TestClass instance3 = new TestClass();
+
+ Mock mock2 = RecorderManager.GetMockOf(instance2);
+ mock2.ExpectAndReturn("SomeMethod", null);
+ }
+ }
+
+
+ [Test]
+ public void Test()
+ {
+ // Create Mock Object
+ ITestClass mockTestClass = RecorderManager.CreateMockedObject(typeof(ITestClass)) as ITestClass;
+ using (RecordExpectations recorder = RecorderManager.StartRecording())
+ {
+ // CAUTION: ALL calls here are mocked!!!
+ // Set expectations on mocked object.
+ recorder.ExpectAndReturn(mockTestClass.MyMethod().MyProperty, 5);
+ }
+ }
+
+
+ ' Visual Basic .NET 2.0
+ <Test()> _
+ Public Sub Test()
+ ' Create Mock Object
+ Dim mockTestClass As ITestClass = RecorderManager.CreateMockedObject(GetType(ITestClass))
+ ' Start mocking
+ Using recorder As New RecordExpectations
+ ' CAUTION: ALL calls here are mocked!!!
+ ' Set expectations on mocked object.
+ recorder.ExpectAndReturn(mockTestClass.MyMethod().MyProperty, 5)
+ End Using
+ End Sub
+
+ For VB .NET 1.1 see
+ [Test]
+ public void MockTestedClass()
+ {
+ TestedClass mockedInstance = RecorderManager.CreateMockedObject<TestedClass>();
+ // Start mocking
+ using (RecordExpectations recorder = RecorderManager.StartRecording())
+ {
+ mockedInstance.SomeMethod(10); // SomeMethod will be mocked.
+ }
+
+ mockedInstance.SomeMethod(); // the method is not called
+
+ MockManager.Verify(); // Make sure that all expected calls where made
+ }
+
+
+ <Test()> _
+ Public Sub MockTestedClass()
+ Dim mockedInstance As TestedClass = RecorderManager.CreateMockedObject(Of TestedClass)
+ ' Start mocking
+ Using recorder As New RecordExpectations
+ TestedClass.SomeMethod(10) ' SomeMethod will be mocked.
+ End Using
+
+ mockedInstance.SomeMethod() ' the method is not called
+
+ MockManager.Verify() ' Make sure that all expected calls where made
+ End Sub
+
+
+ [Test]
+ public void SimulateFiringClickOnManyButtons()
+ {
+ // Mock all Click Events of the all Buttons
+ Mock buttonMock = MockManager.MockAll(typeof(Button));
+ MockedEvent handle = buttonMock.ExpectAddEventAlways("Click");
+
+ // create 2 buttons and register to the Click Event
+ Button button1 = new Button();
+ Button button2 = new Button();
+ button1.Click += new EventHandler(button_Click);
+ button2.Click += new EventHandler(button_Click);
+
+ // Simulate firing Click of button1
+ handle.Instance[0].Fire(this, EventArgs.Empty);
+ // Simulate firing Click of button2
+ handle.Instance[1].Fire(this, EventArgs.Empty);
+ // Check that system works...
+
+ MockManager.Verify()
+ }
+
+
+ <Test()> _
+ Public Sub SimulateFiringClickOnManyButtons()
+ 'Mock all Click Events of the all Buttons
+ Dim buttonMock As Mock = MockManager.MockAll(GetType(Button))
+ Dim handle As MockedEvent = buttonMock.ExpectAddEventAlways("Click")
+
+ ' create 2 buttons and register to the Click Event
+ Dim button1 As Button = New Button
+ Dim button2 As Button = New Button
+
+ AddHandler button1.Click, AddressOf button_Click
+ AddHandler button2.Click, AddressOf button_Click
+
+ ' Simulate firing Click of button1
+ handle.Instance(0).Fire(Me, EventArgs.Empty)
+ ' Simulate firing Click of button2
+ handle.Instance(1).Fire(Me, EventArgs.Empty)
+ ' Check that system works...
+
+ MockManager.Verify()
+ End Sub
+
+ Since Version 3.7
+
+ public void DoSomething()
+ {
+ button1.Click += delegate
+ {
+ MessageBox.Show("Click!");
+ };
+ }
+ public void FireClick()
+ {
+ button1.PerformClick();
+ }
+
+ We can Mock the button1.Click Anonymous Method as follows:
+
+ [Test]
+ public void AnonymousTest()
+ {
+ // Mock TestedClass
+ Mock mock = MockManager.Mock(typeof(TestedClass));
+ // set up our expectations for anonymous method called in DoSomething
+ // check that the delegate will be called without displaying the message box
+ mock.ExpectCall(mock.AnonymousMethod("DoSomething"));
+
+ // create the instances
+ TestedClass tested = new TestedClass();
+ // Test the code
+ tested.DoSomething();
+ tested.FireClick();
+ // Verify that all calls were made (This can be done in the [Teardown])
+ MockManager.Verify();
+ }
+
+
+ [Test]
+ [VerifyMocks]
+ public void MockInstanceField()
+ {
+ // mock next instance creation of ClassWithField
+ Mock mock = MockManager.Mock(typeof(ClassWithField));
+ // mock the "field" field and set the expectation on it
+ Mock mockedField = mock.MockField("field");
+ mockedField.ExpectAndReturn("ReturnFive", 6);
+
+ ClassWithField target = new ClassWithField();
+ int actual = target.field.ReturnFive();
+ // ReturnFive call is mocked and should return 6
+ Assert.AreEqual(6, actual);
+ }
+
+
+ <Test(), VerifyMocks() > _
+ Public Sub MockInstanceField()
+ ' mock next instance creation of ClassWithField
+ Dim mock As Mock = MockManager.Mock(GetType(ClassWithField))
+ ' mock the "field" field and set the expectaion on it
+ Dim MockedField As Mock = mock.MockField("field")
+ MockedField.ExpectAndReturn("ReturnFive", 6)
+
+ Dim target As New ClassWithField
+ Dim actual As Integer = target.field.ReturnFive
+ ' ReturnFive call is mocked and should return 6
+ Assert.AreEqual(6, actual)
+ End Sub
+
+
+ [Test]
+ [VerifyMocks]
+ public void AssignField()
+ {
+ // create the new value we will assign to the field
+ FieldClass replacement = new FieldClass();
+ // create the mock object
+ Mock mock = MockManager.Mock<ClassWithField>();
+ // if the field wont be assigned accessing it will yield a null reference exception
+ mock.AssignField("privateField", replacement);
+
+ // verify that the replacement was assigned to the newly crated instance
+ ClassWithField target = new ClassWithField();
+ int actual = target.GetPrivate().GetHashCode();
+ Assert.AreEqual(replacement.GetHashCode(), actual);
+ }
+
+
+ //VB
+ <Test(), VerifyMocks() > _
+ Public Sub AssignField()
+ ' create the new value we will assign to the field
+ Dim Replacement As New FieldClass
+ 'create the mock object
+ Dim mock As Mock = MockManager.Mock(GetType(ClassWithField))
+ ' if the field wont be assigned accessing it will yield a null reference exception
+ mock.AssignField("privateField", Replacement)
+
+ ' verify that the replacement was assigned to the newly crated instance
+ Dim field As New ClassWithField
+ Dim hashCode As Integer = field.GetPrivate().GetHashCode()
+ Assert.AreEqual(Replacement.GetHashCode, hashCode)
+ End Sub
+
+
+ public class BaseClass
+ {
+ public virtual int SomeMethod()
+ {
+ return 1;
+ }
+ }
+
+ public class DerivedClass() : BaseClass
+ {
+ public override int SomeMethod()
+ {
+ return base.SomeMethod() + 1;
+ }
+ }
+
+ [Test]
+ public void Test()
+ {
+ Mock mock = MockManager.Mock(typeof(DerivedClass))
+ // mock only BaseClass.SomeMethod when called from a DerivedClass Type.
+ mock.CallBase.ExpectAndReturn("SomeMethod", 100);
+ DerivedClass d = new DerivedClass();
+ Assert.AreEqual(101, d.SomeMethod());
+ }
+
+
+ Public Class BaseClass
+ Public Overridable Function SomeMethod() As Integer
+ Return 1
+ End Function
+ End Class
+
+ Public Class DerivedClass
+ Inherits BaseClass
+ Public Overrides Function SomeMethod() As Integer
+ Return 1
+ End Function
+ End Class
+
+ <Test()> _
+ Public Sub Test()
+ Dim mock As Mock = MockManager.Mock(GetType(DerivedClass))
+ ' mock only BaseClass.SomeMethod when called from a DerivedClass Type.
+ mock.CallBase.ExpectAndReturn("SomeMethod", 100)
+ Dim d As DerivedClass = New DerivedClass
+ Assert.AreEqual(101, d.SomeMethod())
+ End Sub
+
+
+ [Test]
+ [VerifyMocks]
+ public void MockInstanceField()
+ {
+ // mock next instance creation of ClassWithField
+ Mock mock = MockManager.Mock(typeof(ClassWithField));
+ // mock the "member" field and set the expectation on it
+ Mock mockedField = mock.MockField("member");
+ mockedField.ExpectAndReturn("ReturnFive", 6);
+
+ ClassWithField target = new ClassWithField();
+ int actual = target.member.ReturnFive();
+ // ReturnFive call is mocked and should return 6
+ Assert.AreEqual(6, actual);
+ }
+
+
+ //VB
+ <Test(), VerifyMocks() > _
+ Public Sub MockInstanceField()
+ ' mock next instance creation of ClassWithField
+ Dim mock As Mock = MockManager.Mock(GetType(ClassWithField))
+ ' mock the "member" field and set the expectaion on it
+ Dim MockedField As Mock = mock.MockField("member")
+ MockedField.ExpectAndReturn("ReturnFive", 6)
+
+ Dim target As New ClassWithField
+ Dim actual As Integer = target.member.ReturnFive
+ ' ReturnFive call is mocked and should return 6
+ Assert.AreEqual(6, actual)
+ End Sub
+
+
+ [Test]
+ [VerifyMocks]
+ public void AssignField()
+ {
+ // create the new value we will assign to the field
+ FieldClass replacement = new FieldClass();
+ // create the mock object
+ Mock mock = MockManager.Mock<ClassWithField>();
+ // if the field wont be assigned accessing it will yield a null reference exception
+ mock.AssignField("privateMember", replacement);
+
+ // verify that the replacement was assigned to the newly crated instance
+ ClassWithField target = new ClassWithField();
+ int actual = target.GetPrivate().GetHashCode();
+ Assert.AreEqual(replacement.GetHashCode(), actual);
+ }
+
+
+ //VB
+ <Test(), VerifyMocks() > _
+ Public Sub AssignField()
+ ' create the new value we will assign to the field
+ Dim Replacement As New FieldClass
+ 'create the mock object
+ Dim mock As Mock = MockManager.Mock(GetType(ClassWithField))
+ ' if the field wont be assigned accessing it will yield a null reference exception
+ mock.AssignField("privateMember", Replacement)
+
+ ' verify that the replacement was assigned to the newly crated instance
+ Dim field As New ClassWithField
+ Dim hashCode As Integer = field.GetPrivate().GetHashCode()
+ Assert.AreEqual(Replacement.GetHashCode, hashCode)
+ End Sub
+
+
+ [Test]
+ public void SimulateFiringClickOnManyButtons()
+ {
+ // Mock all Click Events of the all Buttons
+ Mock buttonMock = MockManager.MockAll(typeof(Button));
+ MockedEvent handle = buttonMock.ExpectAddEventAlways("Click");
+
+ // create 2 buttons and register to the Click Event
+ Button button1 = new Button();
+ Button button2 = new Button();
+ button1.Click += new EventHandler(button_Click);
+ button2.Click += new EventHandler(button_Click);
+
+ // Simulate firing Click of button1
+ handle.Instance[0].Fire(this, EventArgs.Empty);
+ // Simulate firing Click of button2
+ handle.Instance[1].Fire(this, EventArgs.Empty);
+ // Check that system works...
+
+ MockManager.Verify()
+ }
+
+
+ <Test()> _
+ Public Sub SimulateFiringClickOnManyButtons()
+ 'Mock all Click Events of the all Buttons
+ Dim buttonMock As Mock = MockManager.MockAll(GetType(Button))
+ Dim handle As MockedEvent = buttonMock.ExpectAddEventAlways("Click")
+
+ ' create 2 buttons and register to the Click Event
+ Dim button1 As Button = New Button
+ Dim button2 As Button = New Button
+
+ AddHandler button1.Click, AddressOf button_Click
+ AddHandler button2.Click, AddressOf button_Click
+
+ ' Simulate firing Click of button1
+ handle.Instance(0).Fire(Me, EventArgs.Empty)
+ ' Simulate firing Click of button2
+ handle.Instance(1).Fire(Me, EventArgs.Empty)
+ ' Check that system works...
+
+ MockManager.Verify()
+ End Sub
+
+ Since Version 3.7
+
+ public void DoSomething()
+ {
+ button1.Click += delegate
+ {
+ MessageBox.Show("Click!");
+ };
+ }
+ public void FireClick()
+ {
+ button1.PerformClick();
+ }
+
+ We can Mock the button1.Click Anonymous Method as follows:
+
+ [Test]
+ public void AnonymousTest()
+ {
+ // Mock TestedClass
+ Mock mock = MockManager.Mock(typeof(TestedClass));
+ // set up our expectations for anonymous method called in DoSomething
+ // check that the delegate will be called without displaying the message box
+ mock.ExpectCall(mock.AnonymousMethod("DoSomething"));
+
+ // create the instances
+ TestedClass tested = new TestedClass();
+ // Test the code
+ tested.DoSomething();
+ tested.FireClick();
+ // Verify that all calls were made (This can be done in the [Teardown])
+ MockManager.Verify();
+ }
+
+
+ [Test]
+ public void TestCallsInOtherThread ()
+ {
+ // Let mock the product - it will not mock constructors;
+ Mock productMock = MockManager.Mock(typeof(Product),Constructor.NotMocked);
+ // CalculatePrice will return 10 - expect 10 as argument
+ productMock.ExpectAndReturn("CalculatePrice",10F).Args(10);
+ // our method will be called in a new thread
+ Thread theThread = new Thread(new ThreadStart(RunWithWait));
+ theThread.Start();
+ // If we use Verify we dont know when the thread will actually be called
+ // Here we WAIT for the mocked methods to be called, or the timeout.
+ // Default timeout is 5000 milliseconds
+ productMock.VerifyWithTimeout();
+ }
+
+
+ <Test()> _
+ Public Sub TestCallsInOtherThread()
+ ' Let mock the product - this will mock the next invocation of Product,
+ ' it will mock constructors too so our price will be 0
+ Dim productMock As Mock = MockManager.Mock(GetType(Product), Constructor.NotMocked)
+ ' CalculatePrice will return 10 - expect 10 as argument
+ productMock.ExpectAndReturn("CalculatePrice", 10.0F).Args(10)
+ ' our method will be called in a new thread
+ Dim theThread As Thread = New Thread(AddressOf RunWithWait)
+ theThread.Start()
+ ' If we use Verify we dont know when the thread will actually be called
+ ' Here we WAIT for the mocked methods to be called, or the timeout.
+ ' Default timeout is 5000 milliseconds
+ productMock.VerifyWithTimeout()
+ End Sub
+
+
+ [Test]
+ public void TestCallsInOtherThread ()
+ {
+ // Let mock the product - it will not mock constructors;
+ Mock productMock = MockManager.Mock(typeof(Product),Constructor.NotMocked);
+ // CalculatePrice will return 10 - expect 10 as argument
+ productMock.ExpectAndReturn("CalculatePrice",10F).Args(10);
+ // our method will be called in a new thread
+ Thread theThread = new Thread(new ThreadStart(RunWithWait));
+ theThread.Start();
+ // If we use Verify we dont know when the thread will actually be called
+ // Here we WAIT 1000 milliseconds for the mocked methods to be called, or the timeout.
+ productMock.VerifyWithTimeout(1000);
+ }
+
+ <Test()> _
+ Public Sub TestCallsInOtherThread()
+ ' Let mock the product - this will mock the next invocation of Product,
+ ' it will mock constructors too so our price will be 0
+ Dim productMock As Mock = MockManager.Mock(GetType(Product), Constructor.NotMocked)
+ ' CalculatePrice will return 10 - expect 10 as argument
+ productMock.ExpectAndReturn("CalculatePrice", 10.0F).Args(10)
+ ' our method will be called in a new thread
+ Dim theThread As Thread = New Thread(AddressOf RunWithWait)
+ theThread.Start()
+ ' If we use Verify we dont know when the thread will actually be called
+ ' Here we WAIT 1000 milliseconds for the mocked methods to be called, or the timeout.
+ productMock.VerifyWithTimeout(1000)
+ End Sub
+
+
+ [Test]
+ public void Test()
+ {
+ Mock mock = MockManager.Mock(typeof(TestedClass));
+ TestedClass t = new TestedClass();
+ t.doSomething();
+ t.doSomething();
+ t.doSomething();
+ Assert.AreEqual(3,mock.GetCallCount("doSomething"));
+ }
+
+
+ <Test()> _
+ Public Sub Test()
+ Dim mock As Mock = MockManager.Mock(GetType(TestedClass))
+ Dim t As TestedClass = New TestedClass()
+ t.doSomething()
+ t.doSomething()
+ t.doSomething()
+ Assert.AreEqual(3,mock.GetCallCount("doSomething"))
+ End Sub
+
+ For Properties and Indexers see
+ private Mock SetupExpectations()
+ {
+ //Mock all invocation of AccessController,
+ Mock mock = MockManager.MockAll(typeof(AccessController));
+
+ // start a block called loginLabel, this will be verified normally
+ mock.StartBlock("loginLabel",VerifyMode.Normal);
+ // We expect that the login method will be called and we will return
+ // AccessStatus.INVALID_USER the first time and AccessStatus.VALIDATED the
+ // second time
+ mock.ExpectAndReturn("Login", AccessStatus.INVALID_USER);
+ mock.ExpectAndReturn("Login", AccessStatus.VALIDATED);
+ mock.EndBlock();
+
+ // expect another call and return validated.
+ mock.ExpectAndReturn("Login", AccessStatus.VALIDATED);
+ return mock;
+ }
+ [Test]
+ public void TestSomething()
+ {
+ Mock mock = SetupExpectations();
+
+ // In this test we need to add an expectation before our block
+ mock.StartBlockBefore(mock.GetBlock("loginLabel"));
+ mock.ExpectAndReturn("Login", AccessStatus.VALIDATED);
+ mock.EndBlock();
+
+ // continue with test
+ }
+ [Test]
+ public void TestSomething2()
+ {
+ Mock mock = SetupExpectations();
+
+ // In this test we need to remove the expectation our block
+ mock.Clear(mock.GetBlock("loginLabel"));
+
+ // continue with test
+ }
+
+
+ Private Function SetupExpectations() As Mock
+ 'Mock all invocation of AccessController,
+ Dim mock As Mock = MockManager.Mock(GetType(AccessController))
+
+ ' start a block called loginLabel, this will be verified normally
+ mock.StartBlock("loginLabel",VerifyMode.Normal)
+ ' We expect that the login method will be called and we will return
+ ' AccessStatus.INVALID_USER the first time and AccessStatus.VALIDATED the
+ ' second time
+ mock.ExpectAndReturn("Login", AccessStatus.INVALID_USER)
+ mock.ExpectAndReturn("Login", AccessStatus.VALIDATED)
+ mock.EndBlock()
+
+ ' expect another call and return validated.
+ mock.ExpectAndReturn("Login", AccessStatus.VALIDATED)
+ SetupExpectations = mock
+ End Function
+ <Test()> _
+ Public Sub TestSomething()
+ Dim mock As Mock = SetupExpectations()
+
+ ' In this test we need to add an expectation before our block
+ mock.StartBlockBefore(mock.GetBlock("loginLabel"))
+ mock.ExpectAndReturn("Login", AccessStatus.VALIDATED)
+ mock.EndBlock()
+
+ ' continue with test
+ End Sub
+ <Test()> _
+ Public Sub TestSomething2()
+ Dim mock As Mock = SetupExpectations()
+
+ ' In this test we need to remove the expectation our block
+ mock.Clear(mock.GetBlock("loginLabel"))
+
+ ' continue with test
+ End Sub
+
+
+ private Mock SetupExpectations()
+ {
+ //Mock all invocation of AccessController,
+ Mock mock = MockManager.MockAll(typeof(AccessController));
+
+ // start a block called loginLabel, this will be verified normally
+ mock.StartBlock("loginLabel",VerifyMode.Normal);
+ // We expect that the login method will be called and we will return
+ // AccessStatus.INVALID_USER the first time and AccessStatus.VALIDATED the
+ // second time
+ mock.ExpectAndReturn("Login", AccessStatus.INVALID_USER);
+ mock.ExpectAndReturn("Login", AccessStatus.VALIDATED);
+ mock.EndBlock();
+
+ // expect another call and return validated.
+ mock.ExpectAndReturn("Login", AccessStatus.VALIDATED);
+ return mock;
+ }
+ [Test]
+ public void TestSomething()
+ {
+ Mock mock = SetupExpectations();
+
+ // In this test we need to add an expectation before our block
+ mock.StartBlockBefore(mock.GetBlock("loginLabel"));
+ mock.ExpectAndReturn("Login", AccessStatus.VALIDATED);
+ mock.EndBlock();
+
+ // continue with test
+ }
+ [Test]
+ public void TestSomething2()
+ {
+ Mock mock = SetupExpectations();
+
+ // In this test we need to remove the expectation our block
+ mock.Clear(mock.GetBlock("loginLabel"));
+
+ // continue with test
+ }
+
+
+ Private Function SetupExpectations() As Mock
+ 'Mock all invocation of AccessController,
+ Dim mock As Mock = MockManager.Mock(GetType(AccessController))
+
+ ' start a block called loginLabel, this will be verified normally
+ mock.StartBlock("loginLabel",VerifyMode.Normal)
+ ' We expect that the login method will be called and we will return
+ ' AccessStatus.INVALID_USER the first time and AccessStatus.VALIDATED the
+ ' second time
+ mock.ExpectAndReturn("Login", AccessStatus.INVALID_USER)
+ mock.ExpectAndReturn("Login", AccessStatus.VALIDATED)
+ mock.EndBlock()
+
+ ' expect another call and return validated.
+ mock.ExpectAndReturn("Login", AccessStatus.VALIDATED)
+ SetupExpectations = mock
+ End Function
+ <Test()> _
+ Public Sub TestSomething()
+ Dim mock As Mock = SetupExpectations()
+
+ ' In this test we need to add an expectation before our block
+ mock.StartBlockBefore(mock.GetBlock("loginLabel"))
+ mock.ExpectAndReturn("Login", AccessStatus.VALIDATED)
+ mock.EndBlock()
+
+ ' continue with test
+ End Sub
+ <Test()> _
+ Public Sub TestSomething2()
+ Dim mock As Mock = SetupExpectations()
+
+ ' In this test we need to remove the expectation our block
+ mock.Clear(mock.GetBlock("loginLabel"))
+
+ ' continue with test
+ End Sub
+
+
+ [Test]
+ public void Test()
+ {
+ // Start mocking TestedClass
+ Mock mock = MockManager.Mock(typeof(TestedClass));
+ TestedClass t = new TestedClass();
+ // No expectations, the following will run normal passInt if Strict=false
+ // and will fail if Strict=true
+ t.passInt(10);
+ MockManager.Verify();
+ }
+
+
+ <Test()> _
+ Public Sub Test()
+ {
+ ' Start mocking TestedClass
+ Dim mock As Mock = MockManager.Mock(GetType(TestedClass))
+ Dim t As TestedClass = New TestedClass
+ ' No expectations, the following will run normal passInt if Strict=false
+ ' and will fail if Strict=true
+ t.passInt(10)
+ MockManager.Verify()
+ End Sub
+
+
+ public static void CreateAnObject()
+ {
+ TestClass theClass = new TestClass();
+ theClass.field = 5;
+ ...
+ }
+ [Test]
+ public void VerifyFutureObject()
+ {
+ //Create new Mock for a future Object, no expectations
+ Mock mock = MockManager.Mock(typeof(TestClass));
+
+ // Call our code
+ TheClass.CreateAnObject();
+
+ // get the mocked object and test the field
+ TestClass theClass = mock.MockedInstance as TestClass;
+ Assert.AreEqual(5, theClass.field);
+
+ // Verify that all the expected calls have actually been called.
+ MockManager.Verify();
+ }
+
+
+ Public Shared Sub CreateAnObject()
+ Dim theClass As TestClass = New TestClass()
+ theClass.field = 5
+ ...
+ End Sub
+
+ <Test()> _
+ Public Sub ValidateValidUser()
+ ' Create new Mock for a future Object, no expectations
+ Dim mock As Mock = MockManager.Mock(GetType(TestClass))
+
+ ' call our code
+ TheClass.CreateAnObject()
+ ' Get the mocked object and test the field
+ Dim theClass As TestClass = mock.MockedInstance
+ Assert.AreEqual(5, theClass.field)
+
+ ' Verify that all the expected calls have actually been called.
+ MockManager.Verify()
+ End Sub
+
+
+ public class BaseClass
+ {
+ public virtual int SomeMethod()
+ {
+ return 1;
+ }
+ }
+
+ public class DerivedClass : BaseClass
+ {
+ public override int SomeMethod()
+ {
+ return base.SomeMethod() + 1;
+ }
+ }
+
+ [Test]
+ public void Test()
+ {
+ Mock mock = MockManager.Mock(typeof(DerivedClass))
+ // mock only BaseClass.SomeMethod when called from a DerivedClass Type.
+ mock.CallBase.ExpectAndReturn("SomeMethod", 100);
+ DerivedClass d = new DerivedClass();
+ Assert.AreEqual(101, d.SomeMethod());
+ }
+
+
+ Public Class BaseClass
+ Public Overridable Function SomeMethod() As Integer
+ Return 1
+ End Function
+ End Class
+
+ Public Class DerivedClass
+ Inherits BaseClass
+ Public Overrides Function SomeMethod() As Integer
+ Return 1
+ End Function
+ End Class
+
+ <Test()> _
+ Public Sub Test()
+ Dim mock As Mock = MockManager.Mock(GetType(DerivedClass))
+ ' mock only BaseClass.SomeMethod when called from a DerivedClass Type.
+ mock.CallBase.ExpectAndReturn("SomeMethod", 100)
+ Dim d As DerivedClass = New DerivedClass
+ Assert.AreEqual(101, d.SomeMethod())
+ End Sub
+
+
+ [Test]
+ public void Test()
+ {
+ // Start mocking
+ using (RecordExpectations recorder = RecorderManager.StartRecording())
+ {
+ // CAUTION: ALL calls here are mocked!!!
+ // Mock new instance of TestedClass
+ TestedClass mockedTestedClass = new TestedClass();
+ // First time PassInt to be called.
+ mockedTestedClass.PassInt(10);
+ // check that 10 has been passed
+ recorder.CheckArguments();
+
+ // Second time PassInt to be called.
+ mockedTestedClass.PassInt(10);
+ // check that 1 or 2 is passed
+ recorder.CheckArguments(Check.IsIn(1,2)));
+ }
+
+ // run our code
+ TestedClass t = new TestedClass();
+ // This will pass
+ t.passInt(10);
+ // This will fail
+ t.passInt(3);
+ MockManager.Verify();
+ }
+
+
+ ' Visual Basic .NET 2.0
+ <Test()> _
+ Public Sub Test()
+ ' Start mocking
+ Using recorder As New RecordExpectations
+ ' CAUTION: ALL calls here are mocked!!!
+ ' Mock new instance of TestedClass
+ Dim mockedTestedClass As TestedClass = New TestedClass
+ ' First time PassInt to be called.
+ mockedTestedClass.PassInt(10)
+ ' check that 10 has been passed
+ recorder.CheckArguments()
+
+ ' Second time PassInt to be called.
+ mockedTestedClass.PassInt(10);
+ ' check that 1 or 2 is passed
+ recorder.CheckArguments(Check.IsIn(1,2)))
+ End Using
+
+ ' run our code
+ Dim t As TestedClass = New TestedClass
+ ' This will pass
+ t.passInt(10)
+ ' This will fail
+ t.passInt(3)
+ MockManager.Verify()
+ End Sub
+
+ For VB .NET 1.1 see
+ [Test]
+ public void Test()
+ {
+ // Start mocking
+ using (RecordExpectations recorder = RecorderManager.StartRecording())
+ {
+ // CAUTION: ALL calls here are mocked!!!
+ // Mock new instance of TestedClass
+ TestedClass mockedTestedClass = new TestedClass();
+ // always return "one" when 1 was passed
+ mockedTestedClass.PassInt(1);
+ recorder.Return("one").RepeatAlways().WhenArgumentsMatch();
+
+ // always return "two" when 2 or 3 is passed
+ mockedTestedClass.PassInt(2);
+ recorder.Return("two").RepeatAlways().WhenArgumentsMatch(Check.IsIn(1,2));
+ }
+
+ // run our code
+ TestedClass t = new TestedClass();
+ // This will pass
+ Assert.AreEqual("one",t.passInt(1));
+ Assert.AreEqual("two",t.passInt(3));
+ MockManager.Verify();
+ }
+
+
+ ' Visual Basic .NET 2.0
+ <Test()> _
+ Public Sub Test()
+ ' Start mocking
+ Using recorder As New RecordExpectations
+ ' CAUTION: ALL calls here are mocked!!!
+ ' Mock new instance of TestedClass
+ Dim mockedTestedClass As TestedClass = New TestedClass
+ ' always return "one" when 1 was passed
+ mockedTestedClass.PassInt(1)
+ recorder.Return("one").RepeatAlways().WhenArgumentsMatch()
+
+ ' always return "two" when 2 or 3 is passed
+ mockedTestedClass.PassInt(2);
+ recorder.Return("two").RepeatAlways().WhenArgumentsMatch(Check.IsIn(1,2))
+ End Using
+
+ ' run our code
+ Dim t As TestedClass = New TestedClass
+ ' This will pass
+ Assert.AreEqual("one",t.passInt(1))
+ Assert.AreEqual("two",t.passInt(3))
+ MockManager.Verify()
+ End Sub
+
+ For VB .NET 1.1 see
+ [Test]
+ public void Test()
+ {
+ // Start mocking
+ using (RecordExpectations recorder = RecorderManager.StartRecording())
+ {
+ // CAUTION: ALL calls here are mocked!!!
+ // Mock new instance of TestedClass
+ TestedClass mockedTestedClass = new TestedClass();
+ // First time PassInt to be called.
+ mockedTestedClass.PassInt(10);
+ // don't check that 10 has been passed
+ recorder.IgnoreArguments();
+
+ // Second time PassInt to be called.
+ mockedTestedClass.PassInt(10);
+ // check that 1 or 2 is passed
+ recorder.CheckArguments(Check.IsIn(1,2)));
+ }
+
+ // run our code
+ TestedClass t = new TestedClass();
+ // This will pass (ignored)
+ t.passInt(1);
+ // This will fail
+ t.passInt(3);
+ MockManager.Verify();
+ }
+
+
+ ' Visual Basic .NET 2.0
+ <Test()> _
+ Public Sub Test()
+ ' Start mocking
+ Using recorder As New RecordExpectations]
+ ' CAUTION: ALL calls here are mocked!!!
+ ' Mock new instance of TestedClass
+ Dim mockedTestedClass As TestedClass = New TestedClass
+ ' First time PassInt to be called.
+ mockedTestedClass.PassInt(10)
+ ' don't check that 10 has been passed
+ recorder.IgnoreArguments()
+
+ ' Second time PassInt to be called.
+ mockedTestedClass.PassInt(10);
+ ' check that 1 or 2 is passed
+ recorder.CheckArguments(Check.IsIn(1,2)))
+ End Using
+
+ ' run our code
+ Dim t As TestedClass = New TestedClass
+ ' This will pass (ignored)
+ t.passInt(1)
+ ' This will fail
+ t.passInt(3)
+ MockManager.Verify()
+ End Sub
+
+
+ [Test]
+ public void Test()
+ {
+ // Start mocking
+ using (RecordExpectations recorder = RecorderManager.StartRecording())
+ {
+ // CAUTION: ALL calls here are mocked!!!
+ // Mock new instance of TestedClass
+ TestedClass mockedTestedClass = new TestedClass();
+ // DoSomething to be called.
+ mockedTestedClass.DoSomething();
+ // return 10, 3 times
+ recorder.Return(10).Repeat(3);
+ }
+
+ // run our code
+ TestedClass t = new TestedClass();
+ int actual = t.DoSomething();
+ Assert.AreEqual(10,actual);
+ int actual = t.DoSomething();
+ Assert.AreEqual(10,actual);
+ // This will fail as we have one more expectation
+ MockManager.Verify();
+ }
+
+
+ ' Visual Basic .NET 2.0
+ <Test()> _
+ Public Sub Test()
+ ' Start mocking
+ Using recorder As New RecordExpectations
+ ' CAUTION: ALL calls here are mocked!!!
+ ' Mock new instance of TestedClass
+ Dim mockedTestedClass As TestedClass = New TestedClass
+ ' DoSomething to be called.
+ mockedTestedClass.DoSomething()
+ ' return 10, 3 times
+ recorder.Return(10).Repeat(3)
+ End Using
+
+ ' run our code
+ Dim t As TestedClass = New TestedClass
+ Dim actual As Integer = t.DoSomething()
+ Assert.AreEqual(10,actual);
+ actual = t.DoSomething()
+ Assert.AreEqual(10,actual);
+ ' This will fail as we have one more expectation
+ MockManager.Verify()
+ End Sub
+
+ For VB .NET 1.1 see
+ [Test]
+ public void Test()
+ {
+ // Start mocking
+ using (RecordExpectations recorder = RecorderManager.StartRecording())
+ {
+ // CAUTION: ALL calls here are mocked!!!
+ // Mock new instance of TestedClass
+ TestedClass mockedTestedClass = new TestedClass();
+ // DoSomething to be called.
+ mockedTestedClass.DoSomething();
+ // always return 10
+ recorder.Return(10).RepeatAlways();
+ }
+
+ // run our code
+ TestedClass t = new TestedClass();
+ int actual = t.DoSomething();
+ Assert.AreEqual(10,actual);
+ int actual = t.DoSomething();
+ Assert.AreEqual(10,actual);
+ MockManager.Verify();
+ }
+
+
+ ' Visual Basic .NET 2.0
+ <Test()> _
+ Public Sub Test()
+ ' Start mocking
+ Using recorder As New RecordExpectations
+ ' CAUTION: ALL calls here are mocked!!!
+ ' Mock new instance of TestedClass
+ Dim mockedTestedClass As TestedClass = New TestedClass
+ ' DoSomething to be called.
+ mockedTestedClass.DoSomething()
+ ' always return 10
+ recorder.Return(10).RepeatAlways()
+ End Using
+
+ ' run our code
+ Dim t As TestedClass = New TestedClass
+ Dim actual As Integer = t.DoSomething()
+ Assert.AreEqual(10,actual);
+ actual = t.DoSomething()
+ Assert.AreEqual(10,actual);
+ MockManager.Verify()
+ End Sub
+
+ For VB .NET 1.1 see
+ [TestFixture]
+ [ClearMocks] // clear all mocks between tests
+ public TestClass
+ {
+ [Test]
+ [VerifyMocks] // verify the mocks after this tests
+ void test1()
+ {
+ // Set Expectations
+
+ // the test code
+ }
+ }
+
+ < TestFixture >_
+ < ClearMocks >_ ' clear all mocks between tests
+ Public class TestClass
+ < Test >_
+ < VerifyMocks >_ ' verify the mocks after this tests
+ Public Sub test1()
+ ' Set expectations
+
+ ' the test code
+ End Sub
+ End Class
+ [Test]
+ public void Test()
+ {
+ // Start mocking
+ using (RecordExpectations recorder = RecorderManager.StartRecording())
+ {
+ // CAUTION: ALL calls here are mocked!!!
+ // MyMethod will be mocked.
+ TestedClass.MyMethod(10);
+ }
+
+ // run our code, This will be mocked
+ TestedClass.MyMethod(10);
+ MockManager.Verify();
+ }
+
+
+ ' Visual Basic .NET 2.0
+ <Test()> _
+ Public Sub Test()
+ ' Start mocking
+ Using recorder As New RecordExpectations
+ ' CAUTION: ALL calls here are mocked!!!
+ ' MyMethod will be mocked.
+ TestedClass.MyMethod(10)
+ End Using
+
+ ' run our code, This will be mocked
+ TestedClass.MyMethod(10)
+ MockManager.Verify()
+ End Sub
+
+
+ ' Visual Basic .NET 1.1
+ <Test()> _
+ Public Sub Test()
+ ' Start mocking
+ Dim recorder As New RecordExpectations
+ ' CAUTION: ALL calls here are mocked!!!
+ Try
+ ' MyMethod will be mocked.
+ TestedClass.MyMethod(10)
+ Finally
+ recorder.Dispose()
+ End Try
+
+ ' run our code, This will be mocked
+ TestedClass.MyMethod(10)
+ MockManager.Verify()
+ End Sub
+
+
+ [Test]
+ public void Test()
+ {
+ // Start mocking
+ using (RecordExpectations recorder = RecorderManager.StartRecording())
+ {
+ // CAUTION: ALL calls here are mocked!!!
+ // MyMethod will be mocked.
+ TestedClass.MyMethod();
+ recorder.Return(5);
+ }
+
+ // run our code, This will be mocked
+ int actual = TestedClass.MyMethod();
+ Assert.AreEqual(5,actual);
+ MockManager.Verify();
+ }
+
+
+ ' Visual Basic .NET 2.0
+ <Test()> _
+ Public Sub Test()
+ ' Start mocking
+ Using recorder As New RecordExpectations
+ ' CAUTION: ALL calls here are mocked!!!
+ ' MyMethod will be mocked.
+ TestedClass.MyMethod()
+ recorder.Return(5)
+ End Using
+
+ ' run our code, This will be mocked
+ Dim actual as Integer = TestedClass.MyMethod()
+ Assert.AreEqual(5,actual)
+ MockManager.Verify()
+ End Sub
+
+ For VB .NET 1.1 see
+ [Test]
+ public void Test()
+ {
+ // Start mocking
+ using (RecordExpectations recorder = RecorderManager.StartRecording())
+ {
+ // CAUTION: ALL calls here are mocked!!!
+ // MyMethod will be mocked.
+ TestedClass.MyMethod();
+ recorder.ReturnDefaultImplementation();
+ }
+
+ // run our code, This will be mocked
+ int actual = TestedClass.MyMethod();
+ Assert.AreEqual(0,actual);
+ MockManager.Verify();
+ }
+
+
+ ' Visual Basic .NET 2.0
+ <Test()> _
+ Public Sub Test()
+ ' Start mocking
+ Using recorder As New RecordExpectations
+ ' CAUTION: ALL calls here are mocked!!!
+ ' MyMethod will be mocked.
+ TestedClass.MyMethod()
+ recorder.ReturnDefaultImplementation()
+ End Using
+
+ ' run our code, This will be mocked
+ Dim actual as Integer = TestedClass.MyMethod()
+ Assert.AreEqual(0,actual)
+ MockManager.Verify()
+ End Sub
+
+ For VB .NET 1.1 see
+ [Test]
+ public void Test()
+ {
+ // Start mocking
+ using (RecordExpectations recorder = RecorderManager.StartRecording())
+ {
+ // CAUTION: ALL calls here are mocked!!!
+ // MyMethod will be mocked.
+ TestedClass.MyMethod();
+ recorder.Do(delegate(object[] parameters, object context)
+ {
+ return 5;
+ });
+ }
+
+ // run our code, This will be mocked
+ int actual = TestedClass.MyMethod();
+ Assert.AreEqual(5,actual);
+ MockManager.Verify();
+ }
+
+
+ ' Visual Basic .NET 2.0
+ Public Function ReturnValue(ByVal parameters() As Object, ByVal context As Object) As Object
+ ReturnValue = 5
+ End function
+ End Class
+ <Test()> _
+ Public Sub Test()
+ ' Start mocking
+ Using recorder As New RecordExpectations
+ ' CAUTION: ALL calls here are mocked!!!
+ ' MyMethod will be mocked.
+ TestedClass.MyMethod()
+ recorder.Do(AddressOf ReturnValue)
+ End Using
+
+ ' run our code, This will be mocked
+ Dim actual as Integer = TestedClass.MyMethod()
+ Assert.AreEqual(5,actual)
+ MockManager.Verify()
+ End Sub
+
+ For VB .NET 1.1 see
+ [Test]
+ public void Test()
+ {
+ // Start mocking
+ using (RecordExpectations recorder = RecorderManager.StartRecording())
+ {
+ // CAUTION: ALL calls here are mocked!!!
+ // MyMethod will be mocked.
+ recorder.ExpectAndReturn(TestedClass.MyMethod(),5);
+ }
+
+ // run our code, This will be mocked
+ int actual = TestedClass.MyMethod();
+ Assert.AreEqual(5,actual);
+ MockManager.Verify();
+ }
+
+
+ ' Visual Basic .NET 2.0
+ <Test()> _
+ Public Sub Test()
+ ' Start mocking
+ Using recorder As New RecordExpectations
+ ' CAUTION: ALL calls here are mocked!!!
+ ' MyMethod will be mocked.
+ recorder.ExpectAndReturn(TestedClass.MyMethod(),5)
+ End Using
+
+ ' run our code, This will be mocked
+ Dim actual as Integer = TestedClass.MyMethod()
+ Assert.AreEqual(5,actual)
+ MockManager.Verify()
+ End Sub
+
+ For VB .NET 1.1 see
+ [Test]
+ public void Test()
+ {
+ // Start mocking
+ using (RecordExpectations recorder = RecorderManager.StartRecording())
+ {
+ // CAUTION: ALL calls here are mocked!!!
+ // MyMethod will be mocked.
+ TestedClass.MyMethod();
+ recorder.CallOriginal();
+ }
+
+ // run our code, This will not be mocked but we verify that it was called
+ TestedClass.MyMethod();
+ MockManager.Verify();
+ }
+
+
+ ' Visual Basic .NET 2.0
+ <Test()> _
+ Public Sub Test()
+ ' Start mocking
+ Using recorder As New RecordExpectations
+ ' CAUTION: ALL calls here are mocked!!!
+ ' MyMethod will be mocked.
+ TestedClass.MyMethod()
+ recorder.CallOriginal()
+ End Using
+
+ ' run our code, This will not be mocked but we verify that it was called
+ TestedClass.MyMethod()
+ MockManager.Verify()
+ End Sub
+
+ For VB .NET 1.1 see
+ [Test]
+ public void Test()
+ {
+ // Start mocking
+ using (RecordExpectations recorder = RecorderManager.StartRecording())
+ {
+ // CAUTION: ALL calls here are mocked!!!
+ // MyMethod will be mocked.
+ recorder.ExpectAndCallOriginal(TestedClass.MyMethod());
+ }
+
+ // run our code, This will not be mocked but we verify that it was called
+ TestedClass.MyMethod();
+ MockManager.Verify();
+ }
+
+
+ ' Visual Basic .NET 2.0
+ <Test()> _
+ Public Sub Test()
+ ' Start mocking
+ Using recorder As New RecordExpectations
+ ' CAUTION: ALL calls here are mocked!!!
+ ' MyMethod will be mocked.
+ recorder.ExpectAndCallOriginal(TestedClass.MyMethod())
+ End Using
+
+ ' run our code, This will not be mocked but we verify that it was called
+ TestedClass.MyMethod()
+ MockManager.Verify()
+ End Sub
+
+ For VB .NET 1.1 see
+ [Test]
+ public void Test()
+ {
+ // Start mocking
+ using (RecordExpectations recorder = RecorderManager.StartRecording())
+ {
+ // CAUTION: ALL calls here are mocked!!!
+ // MyMethod cannot be called.
+ recorder.FailWhenCalled(TestedClass.MyMethod());
+ }
+
+ // run our code, This will fail
+ int actual = TestedClass.MyMethod();
+ MockManager.Verify();
+ }
+
+
+ ' Visual Basic .NET 2.0
+ <Test()> _
+ Public Sub Test()
+ ' Start mocking
+ Using recorder As New RecordExpectations
+ ' CAUTION: ALL calls here are mocked!!!
+ ' MyMethod cannot be called.
+ recorder.FailWhenCalled(TestedClass.MyMethod())
+ End Using
+
+ ' run our code, This will fail
+ Dim actual as Integer = TestedClass.MyMethod()
+ MockManager.Verify()
+ End Sub
+
+ For VB .NET 1.1 see
+ [Test]
+ public void Test()
+ {
+ // Start mocking
+ using (RecordExpectations recorder = RecorderManager.StartRecording())
+ {
+ // CAUTION: ALL calls here are mocked!!!
+ // MyMethod cannot be called.
+ TestedClass.MyMethod()
+ recorder.FailWhenCalled();
+ }
+
+ // run our code, This will fail
+ int actual = TestedClass.MyMethod();
+ MockManager.Verify();
+ }
+
+
+ ' Visual Basic .NET 2.0
+ <Test()> _
+ Public Sub Test()
+ ' Start mocking
+ Using recorder As New RecordExpectations
+ ' CAUTION: ALL calls here are mocked!!!
+ ' MyMethod cannot be called.
+ TestedClass.MyMethod()
+ recorder.FailWhenCalled()
+ End Using
+
+ ' run our code, This will fail
+ Dim actual as Integer = TestedClass.MyMethod()
+ MockManager.Verify()
+ End Sub
+
+ For VB .NET 1.1 see
+ [Test]
+ [VerifyMocks]
+ public void FieldAssignmentNatural()
+ {
+ FieldClass replacement = new FieldClass();
+ using (RecordExpectations recorder = new RecordExpectations())
+ {
+ //create a mock and assign a future value to the intMember
+ TestedClass mock = new TestedClass();
+ recorder.AssignField(ref mock.classField, replacement);
+ }
+ //verify that the replaced value was assigned to the newly created instance
+ TestedClass target = new TestedClass();
+ int actual = target.classField.GetHashCode();
+ Assert.AreEqual(replacement.GetHashCode(), actual);
+ }
+
+
+ //VB
+ <Test(), VerifyMocks() > _
+ Public Sub FieldAssignmentNatural()
+ Dim replacement As new FieldClass
+ Using recorder As New RecordExpectations
+ ' CAUTION: ALL calls here are mocked!!!
+ ' make all future instances mocked
+ Dim mockedTestedClass As TestedClass = New TestedClass
+ ' DoSomething to be mocked.
+ ' always return 10
+ recorder.AssignField(ref mock.classField, replacement)
+ End Using
+ ' verify that the replaced value was assigned to the newly crated instance
+ Dim target As New TestedClass
+ Dim actual As Integer = target.classField.GetHashCode()
+ Assert.AreEqual(Replacement.GetHashCode, actual)
+ End Sub
+
+
+ [Test]
+ [VerifyMocks]
+ public void FieldAssignmentNatural()
+ {
+ using (RecordExpectations recorder = new RecordExpectations())
+ {
+ //create a mock and assign a future value to the intMember
+ TestedClass mock = new TestedClass();
+ recorder.AssignField(ref mock.intMember, 7);
+ }
+ //verify that the replaced value was assigned to the newly created instance
+ TestedClass target = new TestedClass();
+ Assert.AreEqual(7, target.intMember);
+ }
+
+
+ <Test(), VerifyMocks() > _
+ Public Sub FieldAssignmentNatural()
+ Using recorder As New RecordExpectations
+ ' CAUTION: ALL calls here are mocked!!!
+ ' make all future instances mocked
+ Dim mockedTestedClass As TestedClass = New TestedClass
+ ' DoSomething to be mocked.
+ mockedTestedClass.DoSomething()
+ ' always return 10
+ recorder.AssignField(ref mock.intMember, 7)
+ End Using
+ ' verify that the replaced value was assigned to the newly crated instance
+ Dim target As New TestedClass
+ Assert.AreEqual(7, target.intMember)
+ End Sub
+
+
+ [Test]
+ public void Test()
+ {
+ // Start mocking
+ using (RecordExpectations recorder = RecorderManager.StartRecording())
+ {
+ // CAUTION: ALL calls here are mocked!!!
+ // make all future instances mocked
+ recorder.MockAllInstances = true;
+ // Mock (all) new instance of TestedClass
+ TestedClass mockedTestedClass = new TestedClass();
+ // DoSomething to be mocked.
+ mockedTestedClass.DoSomething();
+ // always return 10
+ recorder.Return(10).RepeatAlways();
+ }
+ }
+
+
+ ' Visual Basic .NET 2.0
+ <Test()> _
+ Public Sub Test()
+ ' Start mocking
+ Using recorder As New RecordExpectations
+ ' CAUTION: ALL calls here are mocked!!!
+ ' make all future instances mocked
+ recorder.MockAllInstances = True
+ ' Mock (all) new instance of TestedClass
+ Dim mockedTestedClass As TestedClass = New TestedClass
+ ' DoSomething to be mocked.
+ mockedTestedClass.DoSomething()
+ ' always return 10
+ recorder.Return(10).RepeatAlways()
+ End Using
+ End Sub
+
+ For VB .NET 1.1 see
+ [Test]
+ public void Test()
+ {
+ // Start mocking
+ using (RecordExpectations recorder = RecorderManager.StartRecording())
+ {
+ // CAUTION: ALL calls here are mocked!!!
+ // make all future instances mocked and all statements repeat
+ recorder.DefaultBehavior.RepeatAlways();
+ // Mock (all) new instance of TestedClass
+ TestedClass mockedTestedClass = new TestedClass();
+ // DoSomething to be mocked.
+ mockedTestedClass.GetSomething().DoSomething();
+ // always return 10
+ recorder.Return(10);
+ }
+ }
+
+
+ ' Visual Basic .NET 2.0
+ <Test()> _
+ Public Sub Test()
+ ' Start mocking
+ Using recorder As New RecordExpectations
+ ' CAUTION: ALL calls here are mocked!!!
+ ' make all future instances mocked and all statements repeat
+ recorder.DefaultBehavior.RepeatAlways()
+ ' Mock (all) new instance of TestedClass
+ Dim mockedTestedClass As TestedClass = New TestedClass
+ ' DoSomething to be mocked.
+ mockedTestedClass.GetSomething().DoSomething()
+ ' always return 10
+ recorder.Return(10)
+ End Using
+ End Sub
+
+ For VB .NET 1.1 see
+ [Test]
+ public void SimulateFiringClick()
+ {
+ // Mock the Click Event of the next Button
+ Mock mockButton = MockManager.Mock(typeof(Button));
+ MockedEvent handler = mockButton.ExpectAddEvent("Click");
+
+ // Create the button and register to the Event
+ Button button = new(Button);
+ button.Click += new EventHandler(button_Click);
+
+ // Simulate firing the event
+ handler.Fire(this, EventArgs.Empty);
+ // Check that system works...
+
+ MockManager.Verify()
+ }
+
+
+ <Test()> _
+ Public Sub SimulateFiringClick()
+ 'Mock all Click Events of the next Button
+ Dim buttonMock As Mock = MockManager.Mock(GetType(Button))
+ Dim handle As MockedEvent = buttonMock.ExpectAddEvent("Click")
+
+ ' Create the button and register to the Event
+ Dim button As Button = New Button
+ AddHandler button.Click, AddressOf button_Click
+
+ ' Simulate firing the event
+ handle.Fire(Me, EventArgs.Empty)
+ ' Check that system works...
+
+ MockManager.Verify()
+ End Sub
+ ///
+ When more than one instance of the event published is mocked, use the MockedEvent.
+ [Test]
+ public void SimulateFiringClickOnManyButtons()
+ {
+ // Mock all Click Events of the all Buttons
+ Mock buttonMock = MockManager.MockAll(typeof(Button));
+ MockedEvent handle = buttonMock.ExpectAddEventAlways("Click");
+
+ // create 2 buttons and register to the Click Event
+ Button button1 = new Button();
+ Button button2 = new Button();
+ button1.Click += new EventHandler(button_Click);
+ button2.Click += new EventHandler(button_Click);
+
+ // Simulate firing Click of button1
+ handle.Instance[0].Fire(this, EventArgs.Empty);
+ // Simulate firing Click of button2
+ handle.Instance[1].Fire(this, EventArgs.Empty);
+ // Check that system works...
+
+ MockManager.Verify()
+ }
+
+
+ <Test()> _
+ Public Sub SimulateFiringClickOnManyButtons()
+ 'Mock all Click Events of the all Buttons
+ Dim buttonMock As Mock = MockManager.MockAll(GetType(Button))
+ Dim handle As MockedEvent = buttonMock.ExpectAddEventAlways("Click")
+
+ ' create 2 buttons and register to the Click Event
+ Dim button1 As Button = New Button
+ Dim button2 As Button = New Button
+
+ AddHandler button1.Click, AddressOf button_Click
+ AddHandler button2.Click, AddressOf button_Click
+
+ ' Simulate firing Click of button1
+ handle.Instance(0).Fire(Me, EventArgs.Empty)
+ ' Simulate firing Click of button2
+ handle.Instance(1).Fire(Me, EventArgs.Empty)
+ ' Check that system works...
+
+ MockManager.Verify()
+ End Sub
+
+
+ EventHandler fire = handle.GetEventHandle() as EventHandler;
+ fire(this, EventArgs.Empty);
+
+
+ Dim fire As EventHandler = handle.GetEventHandle()
+ fire(Me, EventArgs.Empty)
+
+
+ [Test]
+ public void Test()
+ {
+ // Start mocking TestedClass
+ Mock mock = MockManager.Mock(typeof(TestedClass));
+ TestedClass t = new TestedClass();
+ // No expectations, the following will fail because passInt() is
+ // set to Strict
+ mock.MethodSettings("passInt").IsStrict = true;
+ t.passInt(10);
+ MockManager.Verify();
+ }
+
+
+ <Test()> _
+ Public Sub Test()
+ {
+ ' Start mocking TestedClass
+ Dim mock As Mock = MockManager.Mock(GetType(TestedClass))
+ Dim t As TestedClass = New TestedClass
+ ' No expectations, the following will fail because passInt() is
+ ' set to Strict
+ mock.MethodSettings("passInt").IsStrict = True
+ t.passInt(10)
+ MockManager.Verify()
+ End Sub
+
+
+ // This will be called when a mocked method is called
+ private void SuccessEvent(object sender,MockMethodCallEventArgs e)
+ {
+ Assert.AreEqual(typeof(TestedClass),e.CalledType);
+ Assert.AreEqual("getVar",e.CalledMethodName);
+ Assert.AreEqual(0,e.SentArguments.Length);
+ Assert.AreEqual(0,e.ExpectedArguments.Length);
+ Assert.AreEqual(false,e.WillThrowException);
+ Assert.AreEqual(null,e.Exception);
+ Assert.AreEqual(5,e.ReturnValue);
+ Assert.AreEqual(true,e.HasPassedValidation);
+ }
+ [Test]
+ public void SimpleEventSuccess()
+ {
+ Mock mock = MockManager.Mock(typeof(TestedClass),false);
+ TestedClass t = new TestedClass();
+
+ mock.ExpectAndReturn("getVar",5);
+ // set event listener
+ mock.MethodSettings("getVar").MockMethodCalled += new MockMethodCalledEventHandler(SuccessEvent);
+ // the event will be called
+ Assert.AreEqual(5,t.getVar());
+ mock.Verify();
+ }
+
+
+ ' This will be called when a mocked method is called
+ Public Shared Sub SuccessEvent(ByVal sender As Object, ByVal e As MockMethodCallEventArgs)
+ Assert.AreEqual(GetType(TestedClass),e.CalledType)
+ Assert.AreEqual("getVar",e.CalledMethodName)
+ Assert.AreEqual(0,e.SentArguments.Length)
+ Assert.AreEqual(0,e.ExpectedArguments.Length)
+ Assert.AreEqual(False,e.WillThrowException)
+ Assert.AreEqual(Nothing,e.Exception)
+ Assert.AreEqual(5,e.ReturnValue)
+ Assert.AreEqual(True,e.HasPassedValidation)
+ End Sub
+
+ <Test()> _
+ Public Sub SimpleEventSuccess()
+ Dim t As TestedClass = new TestedClass
+ Dim mock As Mock = MockManager.Mock(GetType(TestedClass))
+
+ mock.ExpectAndReturn("getVar",5)
+ ' set event listener
+ AddHandler mock.MethodSettings("getVar").MockMethodCalled, AddressOf SuccessEvent
+
+ ' the event will be called
+ Assert.AreEqual(5,t.getVar())
+ mock.Verify()
+ End Sub
+
+
+ [Test]
+ public void MockGenericMethod()
+ {
+ Mock mock = Mock<MockedClass>.MockNextInstance();
+ mock.AlwaysReturn("Method", 11, Generic.Method<int>());
+ MockedClass test = new MockedClass();
+ Assert.AreEqual(11, test.Method<int>(1));
+ }
+
+
+ <Test()> _
+ Public Sub MockGenericMethod()
+ Dim mock As Mock = Mock(Of MockedClass).MockNextInstance()
+ mock.AlwaysReturn("Method", 11, Generic.Method(Of Integer)());
+ Assert.AreEqual(11, test.Method(Of Integer)(1));
+ End Sub
+
+
+ [Test]
+ void TestMethod1()
+ {
+ using (new MockScope())
+ {
+ //The Test code
+ }
+ }
+
+ <Test()> _
+ Public Sub TestMethod1()
+ Using Scope As New MockScope
+ ' The Test code
+ End Using
+ End Sub
+
+
+ [Test]
+ void TestMethod1()
+ {
+ using (new MockScope())
+ {
+ //The Test code
+ }
+ }
+
+ <Test()> _
+ Public Sub TestMethod1()
+ Using Scope As New MockScope
+ ' The Test code
+ End Using
+ End Sub
+
+
+ [Test]
+ void TestMethod1()
+ {
+ using (new MockScope(1000))
+ {
+ //The Test code
+ }
+ }
+
+ <Test()> _
+ Public Sub TestMethod1()
+ Using Scope As New MockScope(1000)
+ ' The Test code
+ End Using
+ End Sub
+
+
+ public string Validate()
+ {
+ AccessController controller = new AccessController();
+ AccessStatus status = controller.Login(m_UserID,m_Password);
+ switch (status)
+ {
+ case USER_VALID:
+ ...
+ }
+ return returnStatus;
+ }
+
+
+ Public Function Validate() As String
+ Dim controller As AccessController = New AccessController
+ Dim status As AccessStatus = controller.Login(m_UserID,m_Password)
+ Select Case status
+ Case USER_VALID
+ ...
+ End Select
+ Validate = returnStatus
+ }
+ {
+
+ [Test]
+ public void ValidateValidUser()
+ {
+ //Mock all invocation of AccessController, all calls to this class, are
+ //intercepted.
+ Mock mock = MockManager.Mock(typeof(AccessController));
+
+ //We expect that the login method will be called (once) and we will return
+ //AccessStatus.INVALID_USER.
+ mock.ExpectAndReturn("Login", AccessStatus.INVALID_USER);
+
+ LoginView view = new LoginView();
+ view.setUserID("jane");
+ view.setPassword("passAugust");
+ // run the method being tested
+ view.Validate();
+ Assert.AreEqual("login successful", view.Status);
+
+ // Verify that all the expected calls have actually been called.
+ MockManager.Verify();
+ }
+
+
+ <Test()> _
+ Public Sub ValidateValidUser()
+ ' Mock all invocation of AccessController, all calls to this class, are
+ ' intercepted.
+ Dim mock As Mock = MockManager.Mock(GetType(AccessController))
+
+ ' We expect that the login method will be called (once) and we will return
+ ' AccessStatus.INVALID_USER.
+ mock.ExpectAndReturn("Login", AccessStatus.INVALID_USER)
+
+ Dim view As LoginView = New LoginView
+ view.setUserID("jane")
+ view.setPassword("passAugust")
+ ' run the method being tested
+ view.Validate()
+ Assert.AreEqual("login successful", view.Status)
+
+ ' Verify that all the expected calls have actually been called.
+ MockManager.Verify()
+ End Sub
+
+
+ [Test]
+ public void MockTestedClass()
+ {
+ Mock mock = MockManager.Mock<TestedClass>();
+ mock.ExpectCall("SomeMethod");
+
+ TestedClass test = new TestedClass(); // This instance is mocked
+ test.SomeMethod(); // the method is not called
+
+ MockManager.Verify(); // Make sure that all expected calls where made
+ }
+
+
+ <Test()> _
+ Public Sub MockTestedClass()
+ Dim mock As Mock = MockManager.Mock(Of TestedClass)()
+ mock.ExpectCall("SomeMethod")
+
+ Dim test As TestedClass = New TestedClass ' This instance is mocked
+ test.SomeMethod() ' the method is not called
+
+ MockManager.Verify() ' Make sure that all expected calls where made
+ End Sub
+
+
+ [Test]
+ public void MockTestedClass()
+ {
+ Mock mock = MockManager.MockAll<TestedClass>();
+ mock.AlwaysExpect("SomeMethod");
+
+ TestedClass test = new TestedClass(); // all instances are mocked
+ test.SomeMethod(); // the method is not really called
+
+ MockManager.Verify(); // Make sure that all expected calls where made
+ }
+
+
+ <Test()> _
+ Public Sub MockTestedClass()
+ Dim mock As Mock = MockManager.MockAll(Of TestedClass)()
+ mock.AlwaysExpect("SomeMethod")
+
+ Dim test As TestedClass = New TestedClass ' all instances are mocked
+ test.SomeMethod() ' the method is not really called
+
+ MockManager.Verify() ' Make sure that all expected calls where made
+ End Sub
+
+
+ [Test]
+ public void GetMockOfSpecificInstance()
+ {
+ using(RecordExpectations rec = RecorderManager.StartRecording())
+ {
+ TestClass instance1 = new TestClass();
+ TestClass instance2 = new TestClass();
+ TestClass instance3 = new TestClass();
+
+ Mock mock2 = MockManager.GetMockOf(instance2);
+ mock2.ExpectAndReturn("SomeMethod", null);
+ }
+ }
+
+
+ [Test]
+ public void ValidateValidUser()
+ {
+ //Create new Mock Object for IList, all calls to this class, are
+ //intercepted.
+ MockObject mock = MockManager.MockObject(typeof(IList));
+
+ // We expect that the Count parameter will be called (once) and we will return 4
+ mock.ExpectGet("Count", 4);
+ // Get our mocked OBJECT
+ IList list = mock.Object as IList;
+
+ // lets just run it, normally the Object will be passes as a parameter to a tested class
+ Assert.AreEqual(4, list.Count);
+
+ // Verify that all the expected calls have actually been called.
+ MockManager.Verify();
+ }
+
+
+ <Test()> _
+ Public Sub ValidateValidUser()
+ ' Create new Mock Object for IList, all calls to this class, are
+ ' intercepted.
+ Dim mock As MockObject = MockManager.MockObject(GetType(IList))
+
+ ' We expect that the Count parameter will be called (once) and we will return 4
+ mock.ExpectGet("Count", 4)
+ ' Get our mocked OBJECT
+ Dim list As IList = mock.Object
+
+ ' lets just run it, normally the Object will be passes as a parameter to a tested class
+ Assert.AreEqual(4, list.Count)
+
+ ' Verify that all the expected calls have actually been called.
+ MockManager.Verify()
+ End Sub
+
+
+ [Test]
+ public void MockTestedClass()
+ {
+ MockObject<TestedClass> mockControl = MockManager.MockObject<TestedClass>.Create();
+ mockControl.ExpectCall("SomeMethod");
+
+ TestedClass mockedInstance = mockControl.Object; // grab actual instance
+ mockedInstance.SomeMethod(); // the method is not called
+
+ MockManager.Verify(); // Make sure that all expected calls where made
+ }
+
+
+ <Test()> _
+ Public Sub MockTestedClass()
+ Dim mockControl As MockObject(Of TestedClass) = MockManager.MockObject(Of TestedClass)()
+ mockControl.ExpectCall("SomeMethod")
+
+ Dim mockedInstance As TestedClass = mockControl.Object ' grab actual instance
+ mockedInstance.SomeMethod() ' the method is not called
+
+ MockManager.Verify() ' Make sure that all expected calls where made
+ End Sub
+
+
+ // Managed C++
+ namespace TestWithCpp
+ {
+ int globalFunction(int a) {return a;}
+ }
+
+ And the test
+
+ // Managed C++
+ [Test]
+ void Global() {
+ Mock* mock = MockManager::MockGlobalFunctions();
+ // Notice the '.' and NOT '::' !!!
+ mock->ExpectAndReturn("TestWithCpp.globalFunction",__box(5));
+ Assert::AreEqual(__box(5), __box(globalFunction(4)));
+ }
+
+
+ [Test]
+ public void TestCallsInOtherThread ()
+ {
+ // Let mock the product - it will not mock constructors;
+ Mock productMock = MockManager.Mock(typeof(Product),Constructor.NotMocked);
+ // CalculatePrice will return 10 - expect 10 as argument
+ productMock.ExpectAndReturn("CalculatePrice",10F).Args(10);
+ // our method will be called in a new thread
+ Thread theThread = new Thread(new ThreadStart(RunWithWait));
+ theThread.Start();
+ // If we use Verify we dont know when the thread will actually be called
+ // Here we WAIT for the mocked methods to be called, or the timeout.
+ // Default timeout is 5000 milliseconds
+ MockManager.VerifyWithTimeout();
+ }
+
+
+ <Test()> _
+ Public Sub TestCallsInOtherThread()
+ ' Let mock the product - this will mock the next invocation of Product,
+ ' it will mock constructors too so our price will be 0
+ Dim productMock As Mock = MockManager.Mock(GetType(Product), Constructor.NotMocked)
+ ' CalculatePrice will return 10 - expect 10 as argument
+ productMock.ExpectAndReturn("CalculatePrice", 10.0F).Args(10)
+ ' our method will be called in a new thread
+ Dim theThread As Thread = New Thread(AddressOf RunWithWait)
+ theThread.Start()
+ ' If we use Verify we dont know when the thread will actually be called
+ ' Here we WAIT for the mocked methods to be called, or the timeout.
+ ' Default timeout is 5000 milliseconds
+ MockManager.VerifyWithTimeout()
+ End Sub
+
+
+ [Test]
+ public void TestCallsInOtherThread ()
+ {
+ // Let mock the product - it will not mock constructors;
+ Mock productMock = MockManager.Mock(typeof(Product),Constructor.NotMocked);
+ // CalculatePrice will return 10 - expect 10 as argument
+ productMock.ExpectAndReturn("CalculatePrice",10F).Args(10);
+ // our method will be called in a new thread
+ Thread theThread = new Thread(new ThreadStart(RunWithWait));
+ theThread.Start();
+ // If we use Verify we dont know when the thread will actually be called
+ // Here we WAIT 1000 milliseconds for the mocked methods to be called, or the timeout.
+ MockManager.VerifyWithTimeout(1000);
+ }
+
+
+ <Test()> _
+ Public Sub TestCallsInOtherThread()
+ ' Let mock the product - this will mock the next invocation of Product,
+ ' it will mock constructors too so our price will be 0
+ Dim productMock As Mock = MockManager.Mock(GetType(Product), Constructor.NotMocked)
+ ' CalculatePrice will return 10 - expect 10 as argument
+ productMock.ExpectAndReturn("CalculatePrice", 10.0F).Args(10)
+ ' our method will be called in a new thread
+ Dim theThread As Thread = New Thread(AddressOf RunWithWait)
+ theThread.Start()
+ ' If we use Verify we dont know when the thread will actually be called
+ ' Here we WAIT 1000 milliseconds for the mocked methods to be called, or the timeout.
+ MockManager.VerifyWithTimeout(1000)
+ End Sub
+
+
+ [Test]
+ public void Test()
+ {
+ // init collecting on
+ MockManager.Init(true);
+ TestedClass t = new TestedClass();
+ t.doSomething();
+ t.doSomething();
+ t.doSomething();
+ Assert.AreEqual(3,MockManager.CalledCounter("TestClassLibrary.TestedClass","doSomething"));
+ }
+
+
+ <Test()> _
+ Public Sub Test()
+ ' init collecting on
+ MockManager.Init(true)
+ Dim t As TestedClass = New TestedClass
+ t.doSomething()
+ t.doSomething()
+ t.doSomething()
+ Assert.AreEqual(3,MockManager.CalledCounter("TestClassLibrary.TestedClass","doSomething"))
+ End Sub
+
+ For Properties and Indexers see
+ public static bool CheckRange(ParameterCheckerEventArgs data)
+ {
+ return (int)data.ArgumentValue > 10;
+ }
+
+
+ Public Shared Function CheckRange(ByVal data As ParameterCheckerEventArgs) As Boolean
+ CheckRange = data.ArgumentValue > 10;
+ End Function
+
+ We can then use it in out test
+
+ [Test]
+ public void Test()
+ {
+ TestedClass t = new TestedClass();
+ // Start mocking TestedClass
+ Mock mock = MockManager.Mock(typeof(TestedClass));
+ // passInt will be called, arguments must agree with MyChecker
+ mock.ExpectAlways("passInt").Args(new ParameterCheckerEx(CheckRange));
+ // This will pass
+ t.passInt(16);
+ // This will fail
+ t.passInt(3);
+ MockManager.Verify();
+ }
+
+
+ <Test()> _
+ Public Sub Test()
+ Dim t As TestedClass = new TestedClass
+ ' Start mocking TestedClass
+ Dim mock As Mock = MockManager.Mock(GetType(TestedClass))
+ ' passInt will be called, arguments must agree with MyChecker
+ mock.ExpectAlways("passInt").Args(New ParameterCheckerEx(AddressOf CheckRange))
+ // This will pass
+ t.passInt(16)
+ // This will fail
+ t.passInt(3)
+ MockManager.Verify()
+ }
+
+
+ public static bool CheckRange(object parameter)
+ {
+ return (int)parameter > 10;
+ }
+
+
+ Public Shared Function CheckRange(ByVal parameter As Object) As Boolean
+ CheckRange = parameter > 10;
+ End Function
+
+ We can then use it in out test
+
+ [Test]
+ public void Test()
+ {
+ TestedClass t = new TestedClass();
+ // Start mocking TestedClass
+ Mock mock = MockManager.Mock(typeof(TestedClass));
+ // passInt will be called, arguments must agree with MyChecker
+ mock.ExpectAlways("passInt").Args(new ParameterChecker(CheckRange));
+ // This will pass
+ t.passInt(16);
+ // This will fail
+ t.passInt(3);
+ MockManager.Verify();
+ }
+
+
+ <Test()> _
+ Public Sub Test()
+ Dim t As TestedClass = new TestedClass
+ ' Start mocking TestedClass
+ Dim mock As Mock = MockManager.Mock(GetType(TestedClass))
+ ' passInt will be called, arguments must agree with MyChecker
+ mock.ExpectAlways("passInt").Args(New ParameterChecker(AddressOf CheckRange))
+ // This will pass
+ t.passInt(16)
+ // This will fail
+ t.passInt(3)
+ MockManager.Verify()
+ End Sub
+
+
+ public static object MyReturnValue(object[] parameters, object context)
+ {
+ if ((int)parameters[0]==0)
+ {
+ throw new Exception();
+ }
+ return parameters[0];
+ }
+
+
+ Public Shared Function MyReturnValue(ByVal parameters() As Object, ByVal that As Object) As Object
+ If parameters(0)=0 Then
+ Throw New Exception
+ End If
+ MyReturnValue = parameters(0)
+ End Function
+
+ We can then use it in our test
+
+ [Test]
+ public void Test()
+ {
+ // Start mocking TestedClass
+ Mock mock = MockManager.Mock(typeof(TestedClass));
+ // getInt will be called, it will return our dynamic values
+ mock.AlwaysReturn("getInt",new DynamicReturnValue(MyReturnValue));
+ TestedClass t = new TestedClass();
+ // This will pass
+ Assert.AreEqual(10,t.getVar(10));
+ // so will this
+ Assert.AreEqual(1,t.getVar(1));
+ // this will throw an exception
+ t.getVar(0);
+ MockManager.Verify();
+ }
+
+
+ <Test()> _
+ Public Sub Test()
+ ' Start mocking TestedClass
+ Dim mock As Mock = MockManager.Mock(GetType(TestedClass))
+ ' getInt will be called, it will return our dynamic values
+ mock.AlwaysReturn("getInt",New DynamicReturnValue(AddressOf MyReturnValue))
+ Dim t As TestedClass = New TestedClass()
+ ' This will pass
+ Assert.AreEqual(10,t.getVar(10))
+ ' so will this
+ Assert.AreEqual(1,t.getVar(1))
+ ' this will throw an exception
+ t.getVar(0)
+ MockManager.Verify()
+ End Sub
+
+
+ // This will be called when a mocked method is called
+ private void SuccessEvent(object sender,MockMethodCallEventArgs e)
+ {
+ Assert.AreEqual(typeof(TestedClass),e.CalledType);
+ Assert.AreEqual("getVar",e.CalledMethodName);
+ Assert.AreEqual(0,e.SentArguments.Length);
+ Assert.AreEqual(0,e.ExpectedArguments.Length);
+ Assert.AreEqual(false,e.WillThrowException);
+ Assert.AreEqual(null,e.Exception);
+ Assert.AreEqual(5,e.ReturnValue);
+ Assert.AreEqual(true,e.HasPassedValidation);
+ }
+ [Test]
+ public void SimpleEventSuccess()
+ {
+ Mock mock = MockManager.Mock(typeof(TestedClass),false);
+ TestedClass t = new TestedClass();
+
+ mock.ExpectAndReturn("getVar",5);
+ // set event listener
+ mock.MockMethodCalled += new MockMethodCalledEventHandler(SuccessEvent);
+ // the event will be called
+ Assert.AreEqual(5,t.getVar());
+ mock.Verify();
+ }
+
+
+
+ ' This will be called when a mocked method is called
+ Public Shared Sub SuccessEvent(ByVal sender As Object, ByVal e As MockMethodCallEventArgs)
+ Assert.AreEqual(GetType(TestedClass),e.CalledType)
+ Assert.AreEqual("getVar",e.CalledMethodName)
+ Assert.AreEqual(0,e.SentArguments.Length)
+ Assert.AreEqual(0,e.ExpectedArguments.Length)
+ Assert.AreEqual(False,e.WillThrowException)
+ Assert.AreEqual(Nothing,e.Exception)
+ Assert.AreEqual(5,e.ReturnValue)
+ Assert.AreEqual(True,e.HasPassedValidation)
+ End Sub
+
+ <Test()> _
+ Public Sub SimpleEventSuccess()
+ Dim t As TestedClass = new TestedClass
+ Dim mock As Mock = MockManager.Mock(GetType(TestedClass))
+
+ mock.ExpectAndReturn("getVar",5)
+ ' set event listener
+ AddHandler mock.MockMethodCalled, AddressOf SuccessEvent
+ ' the event will be called
+ Assert.AreEqual(5,t.getVar())
+ mock.Verify()
+ End Sub
+
+
+ [Test]
+ public void CheckParameters()
+ {
+ Mock mock = MockManager.Mock(typeof(TestedClass));
+ TestedClass t = new TestedClass();
+ mock.ExpectCall("SomeMethod").Args(Check.IsNull(),null);
+ t.SomeMethod(null,null);
+ MockManager.Verify();
+ }
+
+
+ <Test()> _
+ Public Sub CheckParameters()
+ Dim mock As Mock = MockManager.Mock(GetType(TestedClass))
+ Dim t As TestedClass = New TestedClass
+ mock.ExpectCall("SomeMethod").Args(Check.IsNull(),Nothing)
+ t.SomeMethod(Nothing,Nothing)
+ MockManager.Verify()
+ End Sub
+
+
+ [Test]
+ public void CheckParameters()
+ {
+ Mock mock = MockManager.Mock(typeof(TestedClass));
+ TestedClass t = new TestedClass();
+ mock.ExpectCall("SomeMethod").Args(Check.IsNull(),null);
+ t.SomeMethod(null,null);
+ MockManager.Verify();
+ }
+
+
+ <Test()> _
+ Public Sub CheckParameters()
+ Dim mock As Mock = MockManager.Mock(GetType(TestedClass))
+ Dim t As TestedClass = New TestedClass
+ mock.ExpectCall("SomeMethod").Args(Check.IsNull(),Nothing)
+ t.SomeMethod(Nothing,Nothing)
+ MockManager.Verify()
+ End Sub
+
+
+ [Test]
+ public void CheckParameters()
+ {
+ Mock mock = MockManager.Mock(typeof(TestedClass));
+ TestedClass t = new TestedClass();
+ mock.ExpectCall("SomeMethod").Args(Check.IsAny());
+ t.SomeMethod("Anything");
+ MockManager.Verify();
+ }
+
+
+ <Test()> _
+ Public Sub CheckParameters()
+ Dim mock As Mock MockManager.Mock(GetType(TestedClass))
+ Dim t As TestedClass = New TestedClass
+ mock.ExpectCall("SomeMethod").Args(Check.IsAny())
+ t.SomeMethod("Anything")
+ MockManager.Verify()
+ End Sub
+
+
+ [Test]
+ public void CheckParameters()
+ {
+ Mock mock = MockManager.Mock(typeof(TestedClass));
+ TestedClass t = new TestedClass();
+ mock.ExpectCall("SomeMethod").Args(Check.IsTypeOf(typeof(string)));
+ t.SomeMethod("Anything");
+ MockManager.Verify();
+ }
+
+
+ <Test()> _
+ Public Sub CheckParameters()
+ Dim mock As Mock MockManager.Mock(GetType(TestedClass))
+ Dim t As TestedClass = New TestedClass
+ mock.ExpectCall("SomeMethod").Args(Check.IsTypeOf(GetType(String)))
+ t.SomeMethod("Anything")
+ MockManager.Verify()
+ End Sub
+
+
+ [Test]
+ public void CheckParameters()
+ {
+ Mock mock = Mock<TestedClass>.MockNextInstance();
+ mock.ExpectCall("SomeMethod").Args(Check<int>.AreSameType());
+
+ TestedClass test = new TestedClass();
+ test.SomeMethod(5);
+ MockManager.Verify();
+ }
+
+
+ <Test()> _
+ Public Sub CheckParameters()
+ Dim mock As Mock = Mock(Of TestedClass).MockNextInstance()
+ mock.ExpectCall("SomeMethod").Args(Check(Of Integer)).AreSameType())
+
+ Dim test As TestedClass = New TestedClass
+ test.SomeMethod(5)
+ MockManager.Verify()
+ End Sub
+
+
+ [Test]
+ public void CheckParameters()
+ {
+ Mock mock = MockManager.Mock(typeof(TestedClass));
+ TestedClass t = new TestedClass();
+ mock.ExpectCall("SomeMethod").Args(Check.IsEqual("String"),"Another"));
+ t.SomeMethod("String","Another");
+ MockManager.Verify();
+ }
+
+
+ <Test()> _
+ Public Sub CheckParameters()
+ Dim mock As Mock MockManager.Mock(GetType(TestedClass))
+ Dim t As TestedClass = New TestedClass
+ mock.ExpectCall("SomeMethod").Args(Check.IsEqual("String"),"Another")))
+ t.SomeMethod("String","Another")
+ MockManager.Verify()
+ End Sub
+
+
+ public static bool CheckParameter(ParameterCheckerEventArgs data)
+ {
+ return data.ArgumentValue == data.ExpectedValue;
+ }
+
+ [Test]
+ public void CheckParameters()
+ {
+ Mock mock = MockManager.Mock(typeof(TestedClass));
+ TestedClass t = new TestedClass();
+ // setup expectation, test first argument by calling our CheckParameter
+ // with ExpectedValue set
+ mock.ExpectCall("SomeMethod").Args(Check.CustomChecker(new ParameterCheckerEx(CheckParameter),"String")));
+ t.SomeMethod("String");
+ MockManager.Verify();
+ }
+
+
+ Public Shared Function CheckParameter(ByVal data As ParameterCheckerEventArgs) As Boolean
+ CheckParameter = data.ArgumentValue = data.ExpectedValue;
+ End Function
+
+ <Test()> _
+ Public Sub CheckParameters()
+ Dim mock As Mock MockManager.Mock(GetType(TestedClass))
+ Dim t As TestedClass = New TestedClass
+ ' setup expectation, test first argument by calling our CheckParameter
+ ' with ExpectedValue set
+ mock.ExpectCall("SomeMethod").Args(Check.CustomChecker(New ParameterCheckerEx(AddressOf CheckParameter),"String"))
+ t.SomeMethod("String")
+ MockManager.Verify()
+ End Sub
+
+
+ [Test]
+ public void CheckParameters()
+ {
+ Mock mock = MockManager.Mock(typeof(TestedClass));
+ TestedClass t = new TestedClass();
+ object pass = new object();
+ mock.ExpectCall("SomeMethod").Args(Check.IsSame(pass),"Another"));
+ t.SomeMethod(pass,"Another");
+ MockManager.Verify();
+ }
+
+
+ <Test()> _
+ Public Sub CheckParameters()
+ Dim mock As Mock MockManager.Mock(GetType(TestedClass))
+ Dim t As TestedClass = New TestedClass
+ Dim pass As Object = New Object
+ mock.ExpectCall("SomeMethod").Args(Check.IsSame(pass),"Another")))
+ t.SomeMethod(pass,"Another")
+ MockManager.Verify()
+ End Sub
+
+
+ [Test]
+ public void CheckParameters()
+ {
+ Mock mock = MockManager.Mock(typeof(TestedClass));
+ TestedClass t = new TestedClass();
+ mock.ExpectCall("SomeMethod").Args(Check.IsIn("String","Another"));
+ t.SomeMethod("String");
+ MockManager.Verify();
+ }
+
+
+ <Test()> _
+ Public Sub CheckParameters()
+ Dim mock As Mock MockManager.Mock(GetType(TestedClass))
+ Dim t As TestedClass = New TestedClass
+ Dim pass As Object = New Object
+ mock.ExpectCall("SomeMethod").Args(Check.IsIn("String","Another"))
+ t.SomeMethod("String")
+ MockManager.Verify()
+ End Sub
+
+
+ [Test]
+ public void CheckParameters()
+ {
+ Mock mock = MockManager.Mock(typeof(TestedClass));
+ TestedClass t = new TestedClass();
+ mock.ExpectCall("SomeMethod").Args(Check.Not("Another"));
+ t.SomeMethod("String");
+ MockManager.Verify();
+ }
+
+
+ <Test()> _
+ Public Sub CheckParameters()
+ Dim mock As Mock MockManager.Mock(GetType(TestedClass))
+ Dim t As TestedClass = New TestedClass
+ Dim pass As Object = New Object
+ mock.ExpectCall("SomeMethod").Args(Check.Not("Another"))
+ t.SomeMethod("String")
+ MockManager.Verify()
+ End Sub
+
+
+ [Test]
+ public void CheckParameters()
+ {
+ Mock mock = MockManager.Mock(typeof(TestedClass));
+ TestedClass t = new TestedClass();
+ mock.ExpectCall("SomeMethod").Args(Check.Or("Another",Checks.Equal("String")));
+ t.SomeMethod("String");
+ MockManager.Verify();
+ }
+
+
+ <Test()> _
+ Public Sub CheckParameters()
+ Dim mock As Mock MockManager.Mock(GetType(TestedClass))
+ Dim t As TestedClass = New TestedClass
+ Dim pass As Object = New Object
+ mock.ExpectCall("SomeMethod").Args(Check.Or("Another"),Checks.Equal("String")))
+ t.SomeMethod("String")
+ MockManager.Verify()
+ End Sub
+
+
+ [Test]
+ public void CheckParameters()
+ {
+ Mock mock = MockManager.Mock(typeof(TestedClass));
+ TestedClass t = new TestedClass();
+ mock.ExpectCall("SomeMethod").Args(Check.And("String",Checks.IsTypeOf(typeof(String))));
+ t.SomeMethod("String");
+ MockManager.Verify();
+ }
+
+
+ <Test()> _
+ Public Sub CheckParameters()
+ Dim mock As Mock MockManager.Mock(GetType(TestedClass))
+ Dim t As TestedClass = New TestedClass
+ Dim pass As Object = New Object
+ mock.ExpectCall("SomeMethod").Args(Check.And("String"),Checks.IsTypeOf(GetType(String))))
+ t.SomeMethod("String")
+ MockManager.Verify()
+ End Sub
+
+
+ [Test]
+ public void CheckParameters()
+ {
+ Mock passedMock = MockManager.Mock(typeof(ArgumentClass));
+ Mock mock = MockManager.Mock(typeof(TestedClass));
+ TestedClass t = new TestedClass();
+ mock.ExpectCall("PassArgument").Args(Check.IsMock(passedMock));
+ t.PassArgument(new ArgumentClass());
+ MockManager.Verify();
+ }
+
+
+ <Test()> _
+ Public Sub CheckParameters()
+ Dim passedMock As Mock = MockManager.Mock(GetType(ArgumentClass))
+ Dim mock As Mock = MockManager.Mock(GetType(TestedClass))
+ Dim t As TestedClass = New TestedClass
+ Dim pass As Object = New Object
+ mock.ExpectCall("PassArgument").Args(Check.IsMock(passedMock))
+ t.PassArgument(new ArgumentClass)
+ MockManager.Verify()
+ End Sub
+
+
+ // Part of tested class
+ public void Init()
+ {
+ Button button = new Button();
+ button.Click += new EventHandler(button_Click);
+ }
+
+
+ Public Sub Init()
+ Dim button As Button = New Button
+ AddHandler button.Click, AddressOf button_Click
+ End Sub
+
+ Here is the test
+
+ [Test]
+ public void Test()
+ {
+ // we will mock the Click event and save the MockedEvent
+ Mock buttonMock = MockManager.Mock(typeof(Button));
+ MockedEvent buttonHandle = buttonMock.ExpectAddEvent("Click");
+
+ // we expect button_Click to be called once (when the button is clicked)
+ Mock testedMock = MockManager.Mock(typeof(TestedClass));
+ testedMock.ExpectCall("button_Click");
+
+ // call our code
+ TestedClass test = new TestedClass();
+ test.Init();
+
+ // emulate click.
+ buttonHandle.Fire(this, EventArgs.Empty);
+
+ // verify that all calls where made
+ MockManager.Verify();
+ }
+ // Natural Mocks
+ [Test]
+ public void Test()
+ {
+ MockedEvent buttonHandle;
+ // Start mocking
+ using (RecordExpectations recorder = RecorderManager.StartRecording())
+ {
+ // we will mock the Click event and save the MockedEvent
+ Button buttonMock = new Button();
+ buttonMock.Click += null;
+ buttonHandle = RecorderManager.LastMockedEvent;
+
+ // we expect button_Click to be called once (when the button is clicked)
+ TestedClass testMock = new TestedClass();
+ testMock.button_Click(null,null); // use Reflective Mocks if this is private
+ }
+
+ // call our code
+ TestedClass test = new TestedClass();
+ test.Init();
+
+ // emulate click.
+ buttonHandle.Fire(this, EventArgs.Empty);
+
+ // verify that all calls where made
+ MockManager.Verify();
+ }
+
+
+ <Test()> _
+ Public Sub Test()
+ ' we will mock the Click event and save the MockedEvent
+ Dim buttonMock As Mock = MockManager.Mock(GetType(Button))
+ Dim buttonHandle As MockedEvent = buttonMock.ExpectAddEvent("Click")
+
+ ' we expect button_Click to be called once (when the button is clicked)
+ Dim testedMock As Mock = MockManager.Mock(GetType(TestedClass))
+ testedMock.ExpectCall("button_Click")
+
+ ' call our code
+ Dim test As New TestedClass
+ test.Init()
+
+ ' emulate click.
+ buttonHandle.Fire(Me, EventArgs.Empty)
+ ' Verify that all calls were made
+ MockManager.Verify()
+ End Sub
+
+ ' .NET 2.0 Natural Mocks
+ <Test()> _
+ Public Sub Test()
+ Dim buttonHandle As MockedEvent
+ Dim test As New TestedClass
+ Using recorder As New RecordExpectations
+ ' mock the Click event and save the MockedEvent
+ Dim buttonMock As Button = New Button()
+ AddHandler buttonMock.Click, AddressOf test.button_Click
+ buttonHandle = RecorderManager.LastMockedEvent
+
+ ' we expect button_Click to be called once (when the button is clicked)
+ testMock.button_Click(Nothing, Nothing) ' use Reflective Mocks if this is private
+ End Using
+
+ ' call our code
+ test.Init()
+
+ ' emulate click.
+ buttonHandle.Fire(Me, EventArgs.Empty)
+ ' Verify that all calls were made
+ MockManager.Verify()
+ End Sub
+
+ For VB .NET 1.1 see
+ EventHandler fire = handle.GetEventHandle() as EventHandler;
+ fire(this, EventArgs.Empty);
+
+
+ Dim fire As EventHandler = handle.GetEventHandle()
+ fire(Me, EventArgs.Empty)
+
+
+ [Test]
+ public void SimulateFiringClickOnManyButtons()
+ {
+ // Mock all Click Events of the all Buttons
+ Mock buttonMock = MockManager.MockAll(typeof(Button));
+ MockedEvent handle = buttonMock.ExpectAddEventAlways("Click");
+
+ // create 2 buttons and register to the Click Event
+ Button button1 = new Button();
+ Button button2 = new Button();
+ button1.Click += new EventHandler(button_Click);
+ button2.Click += new EventHandler(button_Click);
+
+ // Simulate firing Click of button1
+ handle.Instance[0].Fire(this, EventArgs.Empty);
+ // Simulate firing Click of button2
+ handle.Instance[1].Fire(this, EventArgs.Empty);
+ // Check that system works...
+
+ MockManager.Verify()
+ }
+
+
+ <Test()> _
+ Public Sub SimulateFiringClickOnManyButtons()
+ 'Mock all Click Events of the all Buttons
+ Dim buttonMock As Mock = MockManager.MockAll(GetType(Button))
+ Dim handle As MockedEvent = buttonMock.ExpectAddEventAlways("Click")
+
+ ' create 2 buttons and register to the Click Event
+ Dim button1 As Button = New Button
+ Dim button2 As Button = New Button
+
+ AddHandler button1.Click, AddressOf button_Click
+ AddHandler button2.Click, AddressOf button_Click
+
+ ' Simulate firing Click of button1
+ handle.Instance(0).Fire(Me, EventArgs.Empty)
+ ' Simulate firing Click of button2
+ handle.Instance(1).Fire(Me, EventArgs.Empty)
+ ' Check that system works...
+
+ MockManager.Verify()
+ End Sub
+
+
+ private Mock SetupExpectations()
+ {
+ //Mock all invocation of AccessController,
+ Mock mock = MockManager.MockAll(typeof(AccessController));
+
+ // start a block called loginLabel, this will be verified normally
+ mock.StartBlock("loginLabel",VerifyMode.Normal);
+ // We expect that the login method will be called and we will return
+ // AccessStatus.INVALID_USER the first time and AccessStatus.VALIDATED the
+ // second time
+ mock.ExpectAndReturn("Login", AccessStatus.INVALID_USER);
+ mock.ExpectAndReturn("Login", AccessStatus.VALIDATED);
+ mock.EndBlock();
+
+ // expect another call and return validated.
+ mock.ExpectAndReturn("Login", AccessStatus.VALIDATED);
+ return mock;
+ }
+ [Test]
+ public void TestSomething()
+ {
+ Mock mock = SetupExpectations();
+
+ // In this test we need to add an expectation before our block
+ mock.StartBlockBefore(mock.GetBlock("loginLabel"));
+ mock.ExpectAndReturn("Login", AccessStatus.VALIDATED);
+ mock.EndBlock();
+
+ // continue with test
+ }
+ [Test]
+ public void TestSomething2()
+ {
+ Mock mock = SetupExpectations();
+
+ // In this test we need to remove the expectation our block
+ mock.Clear(mock.GetBlock("loginLabel"));
+
+ // continue with test
+ }
+
+
+ Private Function SetupExpectations() As Mock
+ 'Mock all invocation of AccessController,
+ Dim mock As Mock = MockManager.Mock(GetType(AccessController))
+
+ ' start a block called loginLabel, this will be verified normally
+ mock.StartBlock("loginLabel",VerifyMode.Normal)
+ ' We expect that the login method will be called and we will return
+ ' AccessStatus.INVALID_USER the first time and AccessStatus.VALIDATED the
+ ' second time
+ mock.ExpectAndReturn("Login", AccessStatus.INVALID_USER)
+ mock.ExpectAndReturn("Login", AccessStatus.VALIDATED)
+ mock.EndBlock()
+
+ ' expect another call and return validated.
+ mock.ExpectAndReturn("Login", AccessStatus.VALIDATED)
+ SetupExpectations = mock
+ End Function
+ <Test()> _
+ Public Sub TestSomething()
+ Dim mock As Mock = SetupExpectations()
+
+ ' In this test we need to add an expectation before our block
+ mock.StartBlockBefore(mock.GetBlock("loginLabel"))
+ mock.ExpectAndReturn("Login", AccessStatus.VALIDATED)
+ mock.EndBlock()
+
+ ' continue with test
+ End Sub
+ <Test()> _
+ Public Sub TestSomething2()
+ Dim mock As Mock = SetupExpectations()
+
+ ' In this test we need to remove the expectation our block
+ mock.Clear(mock.GetBlock("loginLabel"))
+
+ ' continue with test
+ End Sub
+
+
+ public class StatefulClass
+ {
+ static private int count = 0;
+ public int Count {get { return count++ ;}}
+ }
+
+ [Test]
+ public void Stateful()
+ {
+ StatefulClass stateful = new StatefulClass();
+ // Save our state
+ ObjectState objState = new ObjectState(state);
+ // Do something to change the state
+ Assert.AreEqual(0,stateful.Count);
+ // lets reset our code for next test
+ objState.ResetState();
+ Assert.AreEqual(0,stateful.Count);
+ }
+
+
+ Public Class StatefulClass
+ Private Shared count As Integer = 0
+ Public ReadOnly Property Count() As Integer
+ Get
+ Return _defaultName
+ End Get
+ End Property
+ End Class
+
+ <Test()> _
+ Public Sub Stateful()
+ Dim stateful As StatefulClass = New StatefulClass
+ ' Save our state
+ Dim objState As ObjectState = New ObjectState(state)
+ ' Do something to change the state
+ Assert.AreEqual(0,stateful.Count)
+ ' lets reset our code for next test
+ objState.ResetState()
+ Assert.AreEqual(0,stateful.Count)
+ End Sub
+
+
+ [Test]
+ public void CheckRefAndOut()
+ {
+ Mock mock = MockManager.Mock(typeof(TestedClass));
+ TestedClass t = new TestedClass();
+ // Check that first arg is "rr" and assign it with "changed"
+ // Assign the second arg with 3, don't check (same as Check.IsAny())
+ mock.ExpectCall("SomeMethod").Args(new Assign("changed").AndCheck("rr"), new Assign(3));
+ int a ;
+ string s = "rr";
+ t.SomeMethod(ref s,out a);
+ Assert.AreEqual(3,a);
+ Assert.AreEqual("changed",s);
+ MockManager.Verify();
+ }
+
+
+
+ <Test()> _
+ Public Sub CheckRefAndOut()
+ Dim mock As Mock = MockManager.Mock(GetType(TestedClass))
+ Dim t As TestedClass = New TestedClass
+ ' Check that first arg is "rr" and assign it with "changed"
+ ' Assign the second arg with 3, don't check (same as Check.IsAny())
+ mock.ExpectCall("SomeMethod").Args(New Assign("changed").AndCheck("rr"), New Assign(3))
+ Dim a As Integer
+ Dim s As String = "rr"
+ t.SomeMethod(s,a)
+ Assert.AreEqual(3,a)
+ Assert.AreEqual("changed",s)
+ MockManager.Verify()
+ End Sub
+
+
+
+ [TestMethod]
+ [Isolated]
+ public void CallOriginalOnFakeInstance()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>(Members.ReturnNulls);
+
+ // Override the Increment() method to call its original implementation
+ Isolate.WhenCalled(() => fake.Increment()).CallOriginal();
+
+ // Make sure Count is reset
+ fake.Count = 0;
+
+ // This call now redirects to its original implementation - the count should increment
+ fake.Increment();
+ Assert.AreEqual(1, fake.Count);
+
+ // even though we called the original implementation, we can still verify the call happened
+ Isolate.Verify.WasCalledWithAnyArguments(() => fake.Increment());
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ [ExpectedException(typeof(OutOfMemoryException))]
+ public void WillThrowOnFakeInstance()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>();
+
+ // Override the Write() method to throw an exception
+ Isolate.WhenCalled(() => fake.Write("")).WillThrow(new OutOfMemoryException());
+
+ // This call will now throw an exception when called - this is verified by the
+ // [ExpectedException] decorator
+ fake.Write("Hello");
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void FakeAnInstance_StubIncrementMethod()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>();
+
+ // Increment call will be ignored (stubbed)
+ Isolate.WhenCalled(() => fake.Increment()).IgnoreCall();
+
+ // Make sure Count is reset
+ fake.Count = 0;
+
+ // This call is faked - count should not increment
+ fake.Increment();
+
+ Assert.AreEqual(0, fake.Count);
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void FakeAnInstance_DoInstead()
+ {
+ var fake = Isolate.Fake.Instance<RealLogger>(Members.CallOriginal);
+
+ // Use DoInstead to replace the called method with custom action
+ Isolate.WhenCalled(() => fake.CallWithArguments("", 0, 0.0))
+ .DoInstead((callContext) =>
+ {
+ // Change the value of a field in the object that called the method
+ ((RealLogger)callContext.Instance).count = (int)callContext.Parameters[1];
+ });
+
+ // Call the method
+ fake.CallWithArguments(100);
+
+ // Verify the field's value
+ Assert.AreEqual(100, fake.count);
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void FakeAnInstance_ChangeMethodReturnValue()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>();
+
+ // Change the return value for Count property
+ Isolate.WhenCalled(() => fake.Count).WillReturn(10);
+
+ // fake.Count will return the assigned value
+ Assert.AreEqual(10, fake.Count);
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void FakeAnInstance_DoInstead()
+ {
+ var fake = Isolate.Fake.Instance<RealLogger>(Members.CallOriginal);
+
+ // Use DoInstead to replace the method called with custom function
+ Isolate.WhenCalled(() => fake.IntCallWithArgs(0))
+ .DoInstead((callContext) =>
+ {
+ // We can set field on the instance that called the method
+ ((RealLogger)callContext.Instance).count = (int)callContext.Parameters[0];
+
+ // Change the returned value
+ return 100;
+ });
+
+ int value = fake.IntCallWithArgs(10);
+
+ // Verify
+ Assert.AreEqual(100, value);
+ Assert.AreEqual(10, fake.count);
+
+
+ [TestMethod]
+ [Isolated]
+ public void FakeAnInstance_StubIncrementMethod()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>();
+
+ // Increment call will be ignored (stubbed)
+ Isolate.WhenCalled(() => fake.Increment()).IgnoreCall();
+
+ // Make sure Count is reset
+ fake.Count = 0;
+
+ // This call is faked - count should not increment
+ fake.Increment();
+
+ Assert.AreEqual(0, fake.Count);
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void FakeAnInstance_StubIncrementMethod()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>();
+
+ // Change the return value of IntCall()
+ Isolate.WhenCalled(() => fake.IntCall()).WillReturn(10);
+
+ Assert.AreEqual(10, fake.IntCall());
+ }
+
+
+ [TestMethod]
+ public void FakeAnInstance_StubIncrementMethod()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>();
+
+ // Increment call will be ignored (stubbed)
+ Isolate.WhenCalled(() => fake.IntCall()).WillReturn(10);
+
+ Assert.AreEqual(10, fake.IntCall());
+ Isolate.CleanUp();
+ }
+
+
+ The following test uses IsolatedAttribute and similar in functionality:
+
+ [TestMethod]
+ [Isolated]
+ public void FakeAnInstance_StubIncrementMethod()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>();
+
+ // Increment call will be ignored (stubbed)
+ Isolate.WhenCalled(() => fake.IntCall()).WillReturn(10);
+
+ Assert.AreEqual(10, fake.IntCall());
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void SwapAFutureInstance_StubIncrementMethod()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>();
+ Isolate.Swap.NextInstance<RealLogger>().With(fake);
+
+ Isolate.WhenCalled(() => fake.Increment()).IgnoreCall();
+
+ // This object is swapped with the fake
+ RealLogger logger = new RealLogger();
+
+ // Make sure Count is reset
+ logger.Count = 0;
+
+ // This call is faked - count should not increment
+ logger.Increment();
+
+ Assert.AreEqual(0, logger.Count);
+ }
+
+ This example shows how to use Isolate.Swap.
+ [TestMethod]
+ [Isolated]
+ public void SwapCallsOnObject_CallsRedirectedToTargetObject()
+ {
+ // Create the object under test
+ RealLogger logger = new RealLogger();
+ // Create the object calls will be redirected to
+ TestLogger swapped = new TestLogger();
+
+ // Redirect any calls from the object under test to the swapping target
+ Isolate.Swap.CallsOn(logger).WithCallsTo(swapped);
+
+ // logger.Write() is redirected to TestLogger.Write() which writes to console instead of disk
+ logger.Write("Hello World");
+
+ // We can still verify the call to logger.Write() happened
+ Isolate.Verify.WasCalledWithAnyArguments(() => logger.Write(""));
+ }
+
+ // excerpt code for the class under test:
+ public class RealLogger
+ {
+ string logFilePath = ...;
+ public void Write(string toWrite)
+ {
+ logFile.WriteAllText(logFilePath, toWrite);
+ }
+ }
+
+ // excerpt code for the replacement class:
+ public class TestLogger
+ {
+ public void Write(string toWrite)
+ {
+ Console.WriteLine("RealLogger.Write() was called with {0}", toWrite);
+ }
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void FakeAnInstance_StubIncrementMethod()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>();
+
+ // Increment call will be ignored (stubbed)
+ Isolate.WhenCalled(() => fake.Increment()).IgnoreCall();
+
+ // Make sure Count is reset
+ fake.Count = 0;
+
+ // This call is faked - count should not increment
+ fake.Increment();
+
+ Assert.AreEqual(0, fake.Count);
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void StubPrivateMethod()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>();
+
+ // Avoid performing actual write to disk by ignoring (stubbing) a private call
+ Isolate.NonPublic.WhenCalled(fake, "WriteToDisk").IgnoreCall();
+
+ // This call is faked - count should not increment
+ fake.Log("Hello World");
+
+ Assert.AreEqual(1, fake.LineCount);
+ // Verify the private call was actually made
+ Isolate.Verify.NonPublic.WasCalled(fake, "WriteToDisk").WithArguments("Hello World");
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void VerifyStubWasCalled_FailWhenNotCalled()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>();
+
+ fake.Increment();
+
+ Isolate.Verify.WasCalledWithAnyArguments(() => fake.Increment());
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void VerifyMethodWasCalled()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>(Members.CallOriginal);
+
+ fake.Write("Hello");
+
+ // Verify the internal call to WriteToDisk() was performed with correct arguments
+ Isolate.Verify.NonPublic.WasCalled(fake, "WriteToDisk").WithArguments("Hello");
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void VerifyStaticMethodWasCalled()
+ {
+ Isolate.Fake.Instance<LoggerFactory>(Members.CallOriginal);
+
+ RealLogger logger = LoggerFactory.GetLogger("logfile.txt", Access.ReadWrite);
+
+ // Verify the call to internal method LoggerFactory.GetRealLogger() has been made
+ Isolate.Verify.NonPublic.WasNotCalled(typeof(LoggerFactory), "GetRealLogger").
+ WithArguments("logfile.txt", Access.ReadWrite);
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void VerifyMethodWasNotCalled()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>(Members.CallOriginal);
+
+ fake.Write("Hello world!");
+
+ // The logger write was called, so an internal WriteToDisk() was performed -
+ // this verification should fail
+ Isolate.Verify.NonPublic.WasNotCalled(fake, "WriteToDisk");
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void VerifyMethodWasNotCalled()
+ {
+ Isolate.Fake.Instance<LoggerFactory>(Members.CallOriginal);
+
+ RealLogger logger = LoggerFactory.GetLogger();
+
+ // We retrieved a RealLogger and an internal call to GetRealLogger() was made -
+ // this verification should fail
+ Isolate.Verify.NonPublic.WasNotCalled(typeof(LoggerFactory), "GetRealLogger");
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void VerifyPropertyWasCalled()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>(Members.CallOriginal);
+
+ fake.Log("Hello World");
+
+ // Verify an internal disk space check was performed
+ Isolate.Verify.NonPublic.Property.WasCalledGet(fake, "IsDiskFull");
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void VerifyIndexSetterWasCalled()
+ {
+ LogFile fake = Isolate.Fake.Instance<LogFile>(Members.CallOriginal);
+
+ fake.Write("Hello");
+
+ // Verify a set call to the LogFile's internal indexer was made
+ Isolate.Verify.NonPublic.Indexer.WasSetCalled(fake);
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ [ExpectedExcetion(typeof(OutOfDiskSpaceException))]
+ public void ChangePrivatePropertyReturnValue_SimulateDiskError()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>();
+
+ // Set the behavior on the internal IsDiskFull property to true
+ Isolate.NonPublic.Property.WhenGetCalled(fake, "IsDiskFull").WillReturn(true);
+
+ // The fake object checks the disk is full before logging and throws an exception
+ fake.Log("Hello World");
+ }
+
+ // Excerpt from class under test
+ public class RealLogger : ILogger
+ {
+ private string fileName;
+ // method under test
+ public override void Log(string message)
+ {
+ if(IsDiskFull)
+ {
+ throw new OutOfDiskSpaceException();
+ }
+
+ AppendToFile(fileName, message);
+ }
+
+ private bool IsDiskFull
+ {
+ get { return ...; }
+ }
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ [ExpectedException(typeof(OutOfDiskSpaceException))]
+ public void ChangePrivatePropertyReturnValue_SimulateDiskError()
+ {
+ Isolate.Fake.StaticMethods<RealLogger>();
+
+ // Set the behavior on the internal IsDiskFull property to true
+ Isolate.NonPublic.Property.WhenGetCalled(typeof(RealLogger), "IsDiskFull").WillReturn(true);
+
+ RealLogger logger = new RealLogger();
+
+ // The logger object calls the static property to find out if the disk is full before logging and throws an exception
+ logger.Log("Hello World");
+ }
+
+ // Excerpt from class under test
+ public class RealLogger : ILogger
+ {
+ private string fileName;
+ // method under test
+ public static override void Log(string message)
+ {
+ if(IsDiskFull)
+ {
+ throw new OutOfDiskSpaceException();
+ }
+
+ AppendToFile(fileName, message);
+ }
+
+ private static bool IsDiskFull
+ {
+ get { return ...; }
+ }
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ [ExpectedException(typeof(OutOfDiskSpaceException))]
+ public void ThrowExceptionFromPrivatePropertySetter_SimulateDiskError()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>();
+
+ // Set the behavior of the internal CurrentLine property to throw an exception when set
+ Isolate.NonPublic.Property.WhenSetCalled(fake, "CurrentLine").WillThrow(new OutOfDiskSpaceException());
+
+ // The object under test tries to log to its internal container and fails because of the exception we set
+ fake.Log("Hello World");
+ }
+
+ // Excerpt from classes under test
+ public class RealLogger : ILogger
+ {
+ private string fileName;
+ // method under test
+ public static override void Log(string message)
+ {
+ if(IsDiskFull)
+ {
+ throw new OutOfDiskSpaceException();
+ }
+
+ CurrentLine = message;
+ }
+
+ private static bool IsDiskFull
+ {
+ get { return ...; }
+ }
+
+ internal string CurrentLine
+ {
+ get { return current; }
+ set { WriteToLogFile(value); current = value; }
+ }
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ [ExpectedException(typeof(OutOfMemoryException))]
+ public void ThrowExceptionFromPrivatePropertySetter_SimulateMemoryFull()
+ {
+ Isolate.Fake.Instance<LogContainer>();
+
+ // Set the behavior on the internal IsDiskFull property to true
+ Isolate.NonPublic.Property.WhenSetCalled(typeof(LogContainer), "Cache").WillThrow(new OutOfMemoryException());
+
+ // The object under test tries to log using the LogContainer.Cache internal container and fails because of the exception we set
+ fake.Log("Hello World");
+ }
+
+ // Excerpt from class under test:
+ public class LogContainer
+ {
+ public void Log(string message)
+ {
+ LogContainer.Cache.Add(message);
+ WriteToDisk(message);
+ }
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void SwapAFutureInstance_StubIncrementMethod()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>();
+ Isolate.Swap.NextInstance<RealLogger>().With(fake);
+
+ Isolate.WhenCalled(() => fake.Increment()).IgnoreCall();
+
+ // This object is swapped with the fake
+ RealLogger logger = new RealLogger();
+
+ // Make sure Count is reset
+ logger.Count = 0;
+
+ // This call is faked - count should not increment
+ logger.Increment();
+
+ Assert.AreEqual(0, logger.Count);
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void SwapCallsOnObject_CallsRedirectedToTargetObject()
+ {
+ // Create the object under test
+ RealLogger logger = new RealLogger();
+ // Create the object calls will be redirected to
+ TestLogger swapped = new TestLogger();
+
+ // Redirect any calls from the object under test to the swapping target
+ Isolate.Swap.CallsOn(logger).WithCallsTo(swapped);
+
+ // logger.Write() is redirected to TestLogger.Write() which writes to console instead of disk
+ logger.Write("Hello World");
+
+ // We can still verify the call to logger.Write() happened
+ Isolate.Verify.WasCalledWithAnyArguments(() => logger.Write(""));
+ }
+
+ // excerpt code for the class under test:
+ public class RealLogger
+ {
+ string logFilePath = ...;
+ public void Write(string toWrite)
+ {
+ logFile.WriteAllText(logFilePath, toWrite);
+ }
+ }
+
+ // excerpt code for the replacement class:
+ public class TestLogger
+ {
+ public void Write(string toWrite)
+ {
+ Console.WriteLine("RealLogger.Write() was called with {0}", toWrite);
+ }
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void VerifyPropertyWasCalled()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>(Members.CallOriginal);
+
+ fake.Write("Hello");
+
+ // Verify the private property IsDiskFull has been called
+ Isolate.Verify.NonPublic.Property.WasCalledGet(fake, "IsDiskFull");
+ }
+
+ // Exceprt from class under test
+ public class RealLogger : ILogger
+ {
+ private string fileName;
+ public void override Write(string message)
+ {
+ if(IsDiskFull)
+ {
+ throw new OutOfDiskSpaceException();
+ }
+
+ WriteToFile(fileName, message);
+ }
+
+ private bool IsDiskFull
+ {
+ get { return ...; }
+ }
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void VerifyPropertyWasCalled()
+ {
+ Isolate.Fake.Instance<LoggerFactory>(Members.CallOriginal);
+
+ RealLogger logger = LoggerFactory.GetLogger();
+
+ // Verify the private property DoesLoggerExist has been called
+ Isolate.Verify.NonPublic.Property.WasCalledGet(typeof(LoggerFactory), "DoesLoggerExist");
+ }
+
+ // Excerpt from class under test
+ public class LoggerFactory
+ {
+ private ILogger logger;
+ public ILogger GetLogger()
+ {
+ if(!DoesLoggerExist)
+ {
+ logger = new RealLogger();
+ }
+
+ return logger;
+ }
+
+ private bool DoesLoggerExist
+ {
+ get { return logger != null; }
+ }
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void VerifyPropertyWasCalled_WithSpecificArgument()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>(Members.CallOriginal);
+
+ fake.Write("Hello");
+
+ // Verify the private property LineCount has been set to 1
+ Isolate.Verify.NonPublic.Property.WasCalledSetWithExactArgument(fake, "LineCount").WithArgument(1);
+ }
+
+ // Excerpt from class under test
+ public class RealLogger : ILogger
+ {
+ public void override Write(string message)
+ {
+ LineCount = lineCount + 1;
+ WriteToDisk(lineCount, message);
+ }
+
+ private int lineCount;
+ internal int LineCount
+ { get; set; }
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void VerifyPropertyWasCalled_WithSpecificArgument()
+ {
+ Isolate.Fake.Instance<LoggerFactory>(Members.CallOriginal);
+
+ RealLogger logger = LoggerFactory.GetLogger();
+
+ // Verify the private property LoggerCount has been set to 1
+ Isolate.Verify.NonPublic.Property.WasCalledSetWithExactArgument(typeof(LoggerFactory), "LoggerCount").WithArgument(1);
+ }
+
+ // Excerpt from class under test
+ public class LoggerFactory
+ {
+ public ILogger GetLogger()
+ {
+ LoggerCount++;
+ return ...;
+ }
+
+ private static int loggerCount = 0;
+ protected static int LoggerCount
+ { get; set; }
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void VerifyPropertyWasNotCalled()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>(Members.CallOriginal);
+
+ fake.Write("Hello world!");
+
+ // The logger write was called, so an internal call to the IsDiskFull property was performed -
+ // this verification should fail
+ Isolate.Verify.NonPublic.Property.WasNotCalledGet(fake, "IsDiskFull");
+ }
+
+
+ // Exceprt from class under test
+ public class RealLogger : ILogger
+ {
+ private string fileName;
+ public void override Write(string message)
+ {
+ if(IsDiskFull)
+ {
+ throw new OutOfDiskSpaceException();
+ }
+
+ WriteToFile(fileName, message);
+ }
+
+ private bool IsDiskFull
+ {
+ get { return ...; }
+ }
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void VerifyPropertyWasNotCalled()
+ {
+ Isolate.Fake.Instance<LoggerFactory>(Members.CallOriginal);
+
+ RealLogger logger = LoggerFactory.GetLogger();
+
+ // We retrieved a RealLogger and an internal call to LoggerFactory.LoggerInstance was made -
+ // this verification should fail
+ Isolate.Verify.NonPublic.Property.WasNotCalledGet(typeof(LoggerFactory), "LoggerInstance");
+ }
+
+ // Excerpt from class under test
+ public class LoggerFactory
+ {
+ public ILogger GetLogger()
+ {
+ if(LoggerInstance == null)
+ {
+ LoggerInstance = new ...;
+ }
+ return LoggerInstance;
+ }
+
+ protected ILogger LoggerInstance
+ {
+ get { ... }
+ set { ... }
+ }
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void VerifyPropertyWasNotCalled()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>(Members.CallOriginal);
+
+ fake.Write("Hello world!");
+
+ // The logger write was called, so internal property LineCount was updated -
+ // this verification should fail
+ Isolate.Verify.NonPublic.Property.WasNotCalledSet(fake, "LineCount");
+ }
+
+ // Excerpt from class under test
+ public class RealLogger : ILogger
+ {
+ public void override Write(string message)
+ {
+ LineCount = lineCount + 1;
+ WriteToDisk(lineCount, message);
+ }
+
+ private int lineCount;
+ internal int LineCount
+ { get; set; }
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void VerifyPropertyWasNotCalled()
+ {
+ Isolate.Fake.Instance<LoggerFactory>(Members.CallOriginal);
+
+ RealLogger logger = LoggerFactory.GetLogger();
+
+ // We created a RealLogger and an internal property LoggerFactory.LoggerCount was updated -
+ // this verification should fail
+ Isolate.Verify.NonPublic.Property.WasNotCalledSet(typeof(LoggerFactory), "LoggerCount");
+ }
+
+ // Excerpt from class under test
+ public class LoggerFactory
+ {
+ public ILogger GetLogger()
+ {
+ LoggerCount++;
+ return ...;
+ }
+
+ private static int loggerCount = 0;
+ protected static int LoggerCount
+ { get; set; }
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void VerifyMethodWasCalled()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>(Members.CallOriginal);
+
+ fake.Write("Hello");
+
+ // Verify the internal call to WriteToDisk() was performed with correct arguments
+ Isolate.Verify.NonPublic.WasCalled(fake, "WriteToDisk").WithArguments("Hello");
+ }
+
+ // Excerpt from class under test
+ public class RealLogger : ILogger
+ {
+ public void override Write(string message)
+ {
+ WriteToDisk(message);
+ }
+
+ private void WriteToDisk(string content)
+ { ... }
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void VerifyPropertyWasCalled_WithSpecificArgument()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>(Members.CallOriginal);
+
+ fake.Write("Hello");
+
+ // Verify the private property LineCount has been set to 1
+ Isolate.Verify.NonPublic.Property.WasCalledSetWithExactArgument(fake, "LineCount").WithArgument(1);
+ }
+
+ // Excerpt from class under test
+ public class RealLogger : ILogger
+ {
+ public override void Write(string message)
+ {
+ LineCount++;
+ WriteToDisk...;
+ }
+
+ private int lineCount;
+ internal int LineCount
+ { get; set; }
+
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void VerifyIndexGetterWasCalled()
+ {
+ LogFile fake = Isolate.Fake.Instance<LogFile>(Members.CallOriginal);
+
+ string line = fake.GetLineAt(10);
+
+ // Verify a get call to the LogFile's internal indexer was made
+ Isolate.Verify.NonPublic.Indexer.WasGetCalled(fake).WithIndex(10);
+ }
+
+ // Excerpt from class under test
+ public class LogFile
+ {
+ public string GetLineAt(int lineNumber)
+ {
+ return this[lineNumber];
+ }
+
+ protected string this[int line]
+ {
+ get { return ...; }
+ }
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void VerifyIndexSetterWasCalled()
+ {
+ LogFile fake = Isolate.Fake.Instance<LogFile>(Members.CallOriginal);
+
+ // set the position to write at - this will be used for internal index value
+ fake.SetPosition(10);
+ fake.Write("Hello World");
+
+ // Verify a set call to the LogFile's internal indexer was made at the correct index
+ Isolate.Verify.NonPublic.Indexer.WasSetCalled(fake).WithIndexAndValue(10, "Hello World");
+ }
+
+ // Excerpt from class under test
+ public class LogFile
+ {
+ private int currentPosition = 0;
+ public void Write(string message)
+ {
+ this[currentPosition] = message;
+ }
+
+ public void SetPosition(int value)
+ {
+ currentPosition = value;
+ }
+
+ protected string this[int line]
+ {
+ set { WriteToFile(line, value); }
+ }
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void VerifyIndexGetterWasNotCalled()
+ {
+ LogFile fake = Isolate.Fake.Instance<LogFile>(Members.CallOriginal);
+
+ string line = fake.GetLineAt(10)
+
+ // The internal index was used to retrieve the log line - this verification should fail
+ Isolate.Verify.NonPublic.Indexer.WasNotCalledGet(fake);
+ }
+
+
+ // Excerpt from class under test
+ public class LogFile
+ {
+ public string GetLineAt(int lineNumber)
+ {
+ return this[lineNumber];
+ }
+
+ protected string this[int line]
+ {
+ get { return ...; }
+ }
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void VerifyIndexSetterWasNotCalled()
+ {
+ LogFile fake = Isolate.Fake.Instance<LogFile>(Members.CallOriginal);
+
+ // set the position to write at - this will be used for internal index value
+ fake.SetPosition(10);
+ fake.Write("Hello World");
+
+ // The internal index was set during the Write operation so this verification will fail
+ Isolate.Verify.NonPublic.Indexer.WasNotCalledSet(fake);
+ }
+
+ // Excerpt from class under test
+ public class LogFile
+ {
+ private int currentPosition = 0;
+ public void Write(string message)
+ {
+ this[currentPosition] = message;
+ }
+
+ public void SetPosition(int value)
+ {
+ currentPosition = value;
+ }
+
+ protected string this[int line]
+ {
+ set { WriteToFile(line, value); }
+ }
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void VerifyIndexGetterWasCalled()
+ {
+ LogFile fake = Isolate.Fake.Instance<LogFile>(Members.CallOriginal);
+
+ string line = fake.GetLineAt(10);
+
+ // Verify a get call to the LogFile's internal indexer was made
+ Isolate.Verify.NonPublic.Indexer.WasGetCalled(fake).WithIndex(10);
+ }
+
+ // Excerpt from class under test
+ public class LogFile
+ {
+ public string GetLineAt(int index)
+ {
+ return this[index];
+ }
+
+ internal string this[int line]
+ {
+ get { return GetFromLog(line); }
+ }
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void VerifyIndexSetterWasCalled()
+ {
+ LogFile fake = Isolate.Fake.Instance<LogFile>(Members.CallOriginal);
+
+ // set the position to write at - this will be used for internal index value
+ fake.SetPosition(10);
+ fake.Write("Hello World");
+
+ // Verify a set call to the LogFile's internal indexer was made
+ Isolate.Verify.NonPublic.Indexer.WasSetCalled(fake).WithIndexAndValue(10, "Hello World");
+ }
+
+ // Excerpt from class under test
+ public class LogFile
+ {
+ private int currentPosition = 0;
+ public void Write(string message)
+ {
+ this[currentPosition] = message;
+ }
+
+ public void SetPosition(int value)
+ {
+ currentPosition = value;
+ }
+
+ protected string this[int line]
+ {
+ set { WriteToFile(line, value); }
+ }
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void ThrowExceptionFromGenericMethod_SimulateErrorCreatingLogger()
+ {
+ LoggerFactory fake = Isolate.Fake.Instance<LoggerFactory>();
+
+ // Set the logger factory to throw an exception when trying to retrieve a RealLogger
+ Isolate.NonPublic.WhenCalled(fake, "GetLogger").
+ WithGenericArguments(typeof(RealLogger)).
+ WillThrow(new ArgumentNullException());
+
+ // The following method call is not faked because it does not match the specified generic
+ // type arguments - no exception is thrown
+ DiskLogger logger = fake.GetLogger<DiskLogger>();
+
+ // This call will throws an exception as specified
+ try
+ {
+ fake.GetLogger<RealLogger>();
+ Assert.Fail("Retrieving a RealLogger should have failed with an ArgumentNullException");
+ }
+ catch(ArgumentNullException)
+ {
+ }
+ }
+
+
+ [TestFixture]
+ [Isolated] // clear all mocks between tests
+ public TestClass
+ {
+ [Test]
+ public void MyTest1()
+ {
+ // the test code
+ }
+ }
+
+
+ < TestFixture >_
+ < Isolated >_ ' clear all mocks between tests
+ Public class TestClass
+ < Test >_
+ Public Sub MyTest1()
+ ' the test code
+ End Sub
+ End Class
+
+
+ [TestMethod]
+ [Isolated]
+ public void StubPrivateMethod_DoNotWriteToDisk()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>();
+
+ // Avoid performing actual write to disk by ignoring (stubbing) a private call
+ Isolate.NonPublic.WhenCalled(fake, "WriteToDisk").IgnoreCall();
+
+ // The private call is stubbed so no actual disk writes are performed
+ fake.Log("Hello World");
+
+ Assert.AreEqual(1, fake.LineCount);
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void StubPrivateStaticMethod_FactoryCreate()
+ {
+ Isolate.Fake.StaticMethods<LoggerFactory>();
+
+ // Avoid performing to network access by ignoring (stubbing) a private call
+ Isolate.NonPublic.WhenCalled(typeof(LoggerFactory), "ReportToControllerServer").IgnoreCall();
+
+ // The private method is stubbed and the unit test will not perform external calls
+ RealLogger logger = LoggerFactory.CreateLogger();
+
+ Assert.IsNotNull(logger);
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void SetPrivatePropertyBehavior_ChangeReturnValue()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>(Members.CallOriginal);
+
+ // have private RealLogger.IsDiskFull property return true to simulate an error
+ Isolate.NonPublic.Property.WhenCalledGet(fake, "IsDiskFull").WillReturn(true);
+
+ // Because we simulated a disk full error, this call should throw an exception
+ try
+ {
+ fake.Log("Hello World");
+ Assert.Fail("fake.Log() should have thrown because IsDiskFull is true");
+ }
+ catch(OutOfDiskSpaceException)
+ {
+ }
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void SetPrivateIndexBehavior_ChangeReturnValue()
+ {
+ LogFile fake = Isolate.Fake.Instance<LogFile>(Members.CallOriginal);
+
+ // have private LogFile[i] index return a specified log line
+ Isolate.NonPublic.Indexer.WhenCalledGet(fake).WillReturn("Info: this is a test log line");
+
+ // We set the value of the next log line the internal implementation will look at
+ Assert.AreEqual("this is a test log line", fake.GetNextLogLine(Level.Info));
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void ChangeIndexGetReturnValue()
+ {
+ RealLogger fake = Isolate.Fake.Instance<LogContainer>();
+
+ // Set the internal indexer to return a specific value
+ Isolate.NonPublic.Indexer.WhenGetCalled(fake).WillReturn("hello");
+
+ // The object under test uses the private index get result as part of a calculation
+ string result = fake.GetStringAt(10);
+ Assert.AreEqual("hello", result);
+ }
+
+ // Excerpt from class under test
+ public class LogContainer
+ {
+ // method under test
+ public string GetStringAt(int line)
+ {
+ return this[line];
+ }
+
+ private string fileName = ...
+
+ // private indexer
+ private string this[int line]
+ {
+ get { return ReadFromFile(fileName, line); }
+ }
+
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ [ExpectedException(typeof(OutOfMemoryException))
+ public void ThrowExceptionFromIndexSet_SimulateMemoryError()
+ {
+ RealLogger fake = Isolate.Fake.Instance<LogContainer>();
+
+ // Set the internal indexer to throw an exception on set
+ Isolate.NonPublic.Indexer.WhenSetCalled(fake).WillThrow(new OutOfMemoryException());
+
+ // The object under test uses the private index setter when writing to log
+ fake.WriteToLog("hello");
+ }
+
+ // Excerpt from class under test
+ public class LogContainer
+ {
+ // method under test
+ public string WriteToLog(string message)
+ {
+ this[currentLine] = message;
+ currentLine++;
+ }
+
+ private string fileName = ...
+ private int currentLine = 0;
+
+ // private indexer
+ private string this[int line]
+ {
+ set { InternalWrite(fileName, line, value); }
+ }
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void FakeAnInstance_StubIncrementMethod()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>();
+
+ fake.Count = 0;
+
+ // This call is faked because we used the default Instance overload - count should not increment
+ fake.Increment();
+
+ Assert.AreEqual(0, fake.Count);
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void FakeAnInstance_MustSpecifyReturnValues()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>(Members.MustSpecifyReturnValues);
+
+ fake.Count = 0;
+
+ // This call is faked because we used MustSpecifyReturnValues - count should not increment
+ fake.Increment();
+ Assert.AreEqual(0, fake.count);
+
+ // The following statement will throw, because we didn't set behavior on IntCall method.
+ int x = fake.IntCall();
+ }
+
+ The next test shows the CallOriginal setting on Instance:
+
+ [TestMethod]
+ [Isolated]
+ public void FakeAnInstance_UseCallOriginal()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>(Members.CallOriginal);
+
+ fake.Count = 0;
+
+ // This call is not faked. Count should be incremented.
+ fake.Increment();
+ Assert.AreEqual(1, fake.Count);
+ }
+
+ The next test shows what happens when using ReturnNulls:
+
+ [TestMethod]
+ [Isolated]
+ public void FakeAnInstance_UseReturnNulls()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>(Members.ReturnNulls);
+
+ fake.Count = 0;
+ // This call is faked because we set faked method behavior using ReturnNulls
+ fake.Increment();
+ Assert.AreEqual(0, fake.Count);
+
+ // Since we're returning Null by default the following Assert passes
+ Assert.IsNull(fake.IntCall());
+ }
+
+ Finally, using recursive faking, this test should pass:
+
+ [TestMethod]
+ [Isolated]
+ public void RecursiveStubsChain()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>(Members.ReturnRecursiveFakes);
+
+ // This method returns a value type, and therefore, returns a fake 0.
+ Assert.AreEqual(0, fake.ReturnFive());
+
+ // This method returns an object, and therefore returns a non-null object
+ Assert.IsNotNull(fake.GetSon());
+
+ // And the result of GetSon also returns a non-null object
+ Assert.IsNotNull(fake.GetSon().GetNephew());
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void FakeAnInstance_MustSpecifyReturnValues()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>(Members.MustSpecifyReturnValues, ConstructorWillBe.Ignored);
+
+ fake.Count = 0;
+
+ // This call is faked because we used MustSpecifyReturnValues - count should not increment
+ fake.Increment();
+ Assert.AreEqual(0, fake.count);
+
+ // The following statement will throw, because we didn't set behavior on IntCall method.
+ int x = fake.IntCall();
+ }
+
+ The next test shows the CallOriginal setting on Instance:
+
+ [TestMethod]
+ [Isolated]
+ public void FakeAnInstance_UseCallOriginal()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>(Members.CallOriginal, ConstructorWillBe.Ignored);
+
+ // Because constructor was not called Count was not initialized
+ Assert.AreEqual(0, fake.Count);
+
+ // This call is not faked. Count should be incremented.
+ fake.Increment();
+ Assert.AreEqual(1, fake.Count);
+ }
+
+ The next test shows what happens when using ReturnNulls:
+
+ [TestMethod]
+ [Isolated]
+ public void FakeAnInstance_UseReturnNulls()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>(Members.ReturnNulls, ConstructorWillBe.Ignored);
+
+ fake.Count = 0;
+ // This call is faked because we set faked method behavior using ReturnNulls
+ fake.Increment();
+ Assert.AreEqual(0, fake.Count);
+
+ // Since we're returning Null by default the following Assert passes
+ Assert.IsNull(fake.IntCall());
+ }
+
+ Finally, using recursive faking, this test should pass:
+
+ [TestMethod]
+ [Isolated]
+ public void RecursiveStubsChain()
+ {
+ // We create a fake after running the real constructor that sets count field to 5
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>(Members.ReturnRecursiveFakes, ConstructorWillBe.Called);
+
+ // Because Constructor was called fake.count field was initialized
+ Assert.AreEqual(5, fake.count);
+
+ // This method returns a value type, and therefore, returns a fake 0.
+ Assert.AreEqual(0, fake.ReturnFive());
+
+ // This method returns an object, and therefore returns a non-null object
+ Assert.IsNotNull(fake.GetSon());
+
+ // And the result of GetSon also returns a non-null object
+ Assert.IsNotNull(fake.GetSon().GetNephew());
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void FakeAnInstance_MustSpecifyReturnValues()
+ {
+ // Call class constructor passing a number that will be passed to count field
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>(Members.MustSpecifyReturnValues, ConstructorWillBe.Called, 10);
+
+ // Check that the value we've passed to the constructor was passed to the field
+ Assert.AreEqual(10, fake.count);
+ fake.Count = 0;
+
+ // This call is faked because we used MustSpecifyReturnValues - count should not increment
+ fake.Increment();
+ Assert.AreEqual(0, fake.count);
+
+ // The following statement will throw, because we didn't set behavior on IntCall method.
+ int x = fake.IntCall();
+ }
+
+ The next test shows the CallOriginal setting on Instance:
+
+ [TestMethod]
+ [Isolated]
+ public void FakeAnInstance_UseCallOriginal()
+ {
+ // Call class constructor passing a number that will be passed to count field
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>(Members.CallOriginal, ConstructorWillBe.Called, 10);
+
+ // Check that the value we've passed to the constructor was passed to the field
+ Assert.AreEqual(10, fake.count);
+
+ // Because constructor was not called Count was not initialized
+ Assert.AreEqual(0, fake.Count);
+
+ // This call is not faked. Count should be incremented.
+ fake.Increment();
+ Assert.AreEqual(1, fake.Count);
+ }
+
+ The next test shows what happens when using ReturnNulls:
+
+ [TestMethod]
+ [Isolated]
+ public void FakeAnInstance_UseReturnNulls()
+ {
+ // Call class constructor passing a number that will be passed to count field
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>(Members.ReturnNulls, ConstructorWillBe.Called, 10);
+
+ // Check that the value we've passed to the constructor was passed to the field
+ Assert.AreEqual(10, fake.count);
+
+ fake.Count = 0;
+ // This call is faked because we set faked method behavior using ReturnNulls
+ fake.Increment();
+ Assert.AreEqual(0, fake.Count);
+
+ // Since we're returning Null by default the following Assert passes
+ Assert.IsNull(fake.IntCall());
+ }
+
+ Finally, using recursive faking, this test should pass:
+
+ [TestMethod]
+ [Isolated]
+ public void RecursiveStubsChain()
+ {
+ // Call class constructor passing a number that will be passed to count field
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>(Members.ReturnRecursiveFakes, ConstructorWillBe.Called, 10);
+
+ // Check that the value we've passed to the constructor was passed to the field
+ Assert.AreEqual(10, fake.count);
+
+ // This method returns a value type, and therefore, returns a fake 0.
+ Assert.AreEqual(0, fake.ReturnFive());
+
+ // This method returns an object, and therefore returns a non-null object
+ Assert.IsNotNull(fake.GetSon());
+
+ // And the result of GetSon also returns a non-null object
+ Assert.IsNotNull(fake.GetSon().GetNephew());
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void FakeStaticConstructor_CCtorNotCalled()
+ {
+ Isolate.Fake.StaticConstructor<TestClass>()
+
+ TestClass.DoSomething(); // this causes the static constructor to be called
+
+ // the call to the static constructor was faked so the flag equals false
+ Assert.IsFalse(TestClass.TrueIfCCtorHappened);
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void FakeStaticConstructor_CCtorNotCalled()
+ {
+ Isolate.Fake.StaticConstructor( typeof(StaticTestClass))
+
+ StaticTestClass.DoSomething(); // this causes the static constructor to be called
+
+ // the call to the static constructor was faked so the flag equals false
+ Assert.IsFalse(StaticTestClass.TrueIfCCtorHappened);
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void FakeStaticMethods_StubIncrementMethod()
+ {
+ Isolate.Fake.StaticMethods<LoggerFactory>();
+
+ LoggerFactory.Count = 0;
+ // This call is faked because we used the default overload for FakeStaticMethods -
+ // IncrementCount() is not really performed
+ LoggerFactory.IncrementCount();
+
+ Assert.AreEqual(0, LoggerFactory.Count);
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void FakeStaticMethods_StubIncrementMethod()
+ {
+ Isolate.Fake.StaticMethods( typeof(LoggerFactory));
+
+ LoggerFactory.Count = 0;
+ // This call is faked because we used the default overload for FakeStaticMethods -
+ // IncrementCount() is not really performed
+ LoggerFactory.IncrementCount();
+
+ Assert.AreEqual(0, LoggerFactory.Count);
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void FakeStaticMethods_UseDefault()
+ {
+ Isolate.Fake.StaticMethods<LoggerFactory>();
+
+ LoggerFactory.Count = 0;
+ // This call is faked because we used the default overload for FakeStaticMethods -
+ // IncrementCount() is not really performed
+ LoggerFactory.IncrementCount();
+
+ Assert.AreEqual(0, LoggerFactory.Count);
+
+ // The following statement will throw, because we didn't set behavior on GetCount() method.
+ int x = LoggerFactory.GetCount();
+ }
+
+ The next test shows the CallOriginal setting for FakeStaticMethods():
+
+ [TestMethod]
+ [Isolated]
+ public void FakeStaticMethods_UseCallOriginal()
+ {
+ Isolate.Fake.StaticMethods<LoggerFactory>(Members.CallOriginal);
+
+ LoggerFactory.Count = 0;
+
+ // This call is not faked. Count should be incremented.
+ LoggerFactory.Increment();
+ Assert.AreEqual(1, fake.Count);
+ }
+
+ The next test shows what happens when using ReturnNulls:
+
+ [TestMethod]
+ [Isolated]
+ public void FakeStaticMethods_UseReturnNulls()
+ {
+ Isolate.Fake.StaticMethods<LoggerFactory>(Members.ReturnNulls);
+
+ LoggerFactory.Count = 0;
+ // This call is faked because we set faked method behavior using ReturnNulls
+ LoggerFactory.Increment();
+ Assert.AreEqual(0, fake.Count);
+
+ // Since we're returning Null by default the following Assert passes
+ Assert.IsNull(LoggerFactory.GetLogger());
+ }
+
+ Finally, using recursive faking, this test should pass:
+
+ [TestMethod]
+ [Isolated]
+ public void RecursiveStubsChain()
+ {
+ Isolate.Fake.StaticMethods<LoggerFactory>(Members.ReturnRecursiveFakes);
+
+ // This method returns a value type, and therefore, returns a fake 0.
+ Assert.AreEqual(0, LoggerFactory.GetLoggerCount());
+
+ // This method returns an object, and therefore returns a non-null object
+ Assert.IsNotNull(LoggerFactory.GetLogger());
+
+ // And the result of GetLogger also returns a non-null object
+ Assert.IsNotNull(LoggerFactory.GetLogger().GetWriter());
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void FakeStaticMethods_UseDefault()
+ {
+ Isolate.Fake.StaticMethods(typeof (LoggerFactory));
+
+ LoggerFactory.Count = 0;
+ // This call is faked because we used the default overload for FakeStaticMethods -
+ // IncrementCount() is not really performed
+ LoggerFactory.IncrementCount();
+
+ Assert.AreEqual(0, LoggerFactory.Count);
+
+ // The following statement will throw, because we didn't set behavior on GetCount() method.
+ int x = LoggerFactory.GetCount();
+ }
+
+ The next test shows the CallOriginal setting for FakeStaticMethods():
+
+ [TestMethod]
+ [Isolated]
+ public void FakeStaticMethods_UseCallOriginal()
+ {
+ Isolate.Fake.StaticMethods(typeof (LoggerFactory), Members.CallOriginal);
+
+ LoggerFactory.Count = 0;
+
+ // This call is not faked. Count should be incremented.
+ LoggerFactory.Increment();
+ Assert.AreEqual(1, fake.Count);
+ }
+
+ The next test shows what happens when using ReturnNulls:
+
+ [TestMethod]
+ [Isolated]
+ public void FakeStaticMethods_UseReturnNulls()
+ {
+ Isolate.Fake.StaticMethods(typeof (LoggerFactory), Members.ReturnNulls);
+
+ LoggerFactory.Count = 0;
+ // This call is faked because we set faked method behavior using ReturnNulls
+ LoggerFactory.Increment();
+ Assert.AreEqual(0, fake.Count);
+
+ // Since we're returning Null by default the following Assert passes
+ Assert.IsNull(LoggerFactory.GetLogger());
+ }
+
+ Finally, using recursive faking, this test should pass:
+
+ [TestMethod]
+ [Isolated]
+ public void RecursiveStubsChain()
+ {
+ Isolate.Fake.StaticMethods(typeof (LoggerFactory), Members.ReturnRecursiveFakes);
+
+ // This method returns a value type, and therefore, returns a fake 0.
+ Assert.AreEqual(0, LoggerFactory.GetLoggerCount());
+
+ // This method returns an object, and therefore returns a non-null object
+ Assert.IsNotNull(LoggerFactory.GetLogger());
+
+ // And the result of GetLogger also returns a non-null object
+ Assert.IsNotNull(LoggerFactory.GetLogger().GetWriter());
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void VerifyMethodWasCalled()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>();
+
+ fake.Write("Hello");
+
+ // We did not check the call for argument matching so this verification should pass
+ Isolate.Verify.WasCalledWithAnyArguments(() => fake.Write("Goodbye"));
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void VerifyMethodWasCalled()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>(Members.ReturnNulls);
+
+ int x = fake.GetCount();
+
+ Isolate.Verify.WasCalledWithAnyArguments(() => fake.GetCount());
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void VerifyMethodWasCalled_WithExactArguments()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>();
+
+ fake.Write("Hello");
+
+ // As we're verifying the call was made with exact arguments, this verification should fail
+ Isolate.Verify.WasCalledWithExactArguments(() => fake.Write("Goodbye"));
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void VerifyMethodWasCalled_WithExactArguments()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>();
+
+ fake.Write("Hello");
+
+ // As we're verifying the call was made with exact arguments, this verification should fail
+ Isolate.Verify.WasCalledWithExactArguments(() => fake.Write("Goodbye"));
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void VerifyMethodWasNotCalled()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>();
+
+ fake.Increment();
+
+ // This verification should fail
+ Isolate.Verify.WasNotCalled(() => fake.Increment());
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void VerifyMethodWasNotCalled()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>();
+
+ fake.Increment();
+
+ // This verification should fail
+ Isolate.Verify.WasNotCalled(() => fake.Increment());
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void SwapAFutureInstance_StubIncrementMethod()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>();
+ Isolate.Swap.NextInstance<RealLogger>().With(fake);
+
+ Isolate.WhenCalled(() => fake.Increment()).IgnoreCall();
+
+ // This object is swapped with the fake
+ RealLogger logger = new RealLogger();
+
+ // Make sure Count is reset
+ logger.Count = 0;
+
+ // This call is faked - count should not increment
+ logger.Increment();
+
+ Assert.AreEqual(0, logger.Count);
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void WithExactArguments_DifferentArgsReturnDifferentValues()
+ {
+ // create a fake logger which will behave as the original one
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>(Members.CallOriginal);
+
+ // Set return value according to exact arguments
+ Isolate.WhenCalled(() => fake.VoidCallWithArg(0)).WithExactArguments().IgnoreCall();
+ Isolate.WhenCalled(() => fake.VoidCallWithArg(1)).WithExactArguments().CallOriginal();
+ Isolate.WhenCalled(() => fake.VoidCallWithArg(2)).WithExactArguments().WillThrow(new Exception(""));
+
+ // Check that the correct value returned
+ fake.VoidCallWithArg(0); // This call will be ignored
+ fake.VoidCallWithArg(1); // This call will call the real method
+ fake.VoidCallWithArg(2); // This call will throw an exception
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void SwapCallsOnObject_CallsRedirectedToTargetObject()
+ {
+ // Create the object under test
+ RealLogger logger = new RealLogger();
+ // Create the object calls will be redirected to
+ TestLogger swapped = new TestLogger();
+
+ // Redirect any calls from the object under test to the swapping target
+ Isolate.Swap.CallsOn(logger).WithCallsTo(swapped);
+
+ // logger.Write() is redirected to TestLogger.Write() which writes to console instead of disk
+ logger.Write("Hello World");
+
+ // We can still verify the call to logger.Write() happened
+ Isolate.Verify.WasCalledWithAnyArguments(() => logger.Write(""));
+ }
+
+ // excerpt code for the class under test:
+ public class RealLogger
+ {
+ string logFilePath = ...;
+ public void Write(string toWrite)
+ {
+ logFile.WriteAllText(logFilePath, toWrite);
+ }
+ }
+
+ // excerpt code for the replacement class:
+ public class TestLogger
+ {
+ public void Write(string toWrite)
+ {
+ Console.WriteLine("RealLogger.Write() was called with {0}", toWrite);
+ }
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void SwapCollectionValues_ReplaceCollectionWithTestData()
+ {
+ // Create a logger to use as test data
+ RealLogger logger = new RealLogger();
+ // Swap the logger collection for the class under test with a collection containing the prepared test data
+ Isolate.WhenCalled(() => LoggerFactory.Loggers).WithValuesFrom(new[] { logger });
+
+ // Verify the GetLogger() method returned the existing logger instead of creating a new one.
+ RealLogger actual = LoggerFactory.GetLogger();
+ Assert.AreSame(logger, actual);
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void FakeAnInstance_StubIncrementMethod()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>();
+
+ fake.Count = 0;
+
+ // This call is faked because we used the default Instance overload - count should not increment
+ fake.Increment();
+
+ Assert.AreEqual(0, fake.Count);
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void FakeAnInstance_UseDefault()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>();
+
+ fake.Count = 0;
+
+ // This call is faked because we used Instance's default overload - count should not increment
+ fake.Increment();
+ Assert.AreEqual(0, fake.Count);
+
+ // The following statement will throw, because we didn't set behavior on IntCall method.
+ int x = fake.IntCall();
+ }
+
+ The next test shows the CallOriginal setting on Instance:
+
+ [TestMethod]
+ [Isolated]
+ public void FakeAnInstance_UseCallOriginal()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>(Members.CallOriginal);
+
+ fake.Count = 0;
+
+ // This call is not faked. Count should be incremented.
+ fake.Increment();
+ Assert.AreEqual(1, fake.Count);
+ }
+
+ The next test shows what happens when using ReturnNulls:
+
+ [TestMethod]
+ [Isolated]
+ public void FakeAnInstance_UseReturnNulls()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>(Members.ReturnNulls);
+
+ fake.Count = 0;
+ // This call is faked because we set faked method behavior using ReturnNulls
+ fake.Increment();
+ Assert.AreEqual(0, fake.Count);
+
+ // Since we're returning Null by default the following Assert passes
+ Assert.IsNull(fake.IntCall());
+ }
+
+ Finally, using recursive faking, this test should pass:
+
+ [TestMethod]
+ [Isolated]
+ public void RecursiveStubsChain()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>(Members.ReturnRecursiveFakes);
+
+ // This method returns a value type, and therefore, returns a fake 0.
+ Assert.AreEqual(0, fake.ReturnFive());
+
+ // This method returns an object, and therefore returns a non-null object
+ Assert.IsNotNull(fake.GetSon());
+
+ // And the result of GetSon also returns a non-null object
+ Assert.IsNotNull(fake.GetSon().GetNephew());
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void ReturnRecursiveFake_ChainedCallsAreFake()
+ {
+ // create a fake logger which will behave as the original one
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>(Members.CallOriginal);
+
+ // exclude one method from the default behavior and return a recursive fake from it
+ Isolate.WhenCalled(() => fake.Storage).ReturnRecursiveFake();
+
+ // subsequent calls to the method will not return null values
+ Assert.IsNotNull(fake.Storage);
+ Assert.IsNotNull(fake.Storage.FileSystem);
+ // methods returning a value type will return the default value for the type
+ Assert.AreEqual(0, fake.Storage.FreeSpaceInBytes);
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void WithExactArguments_DifferentArgsReturnDifferentValues()
+ {
+ // create a fake logger which will behave as the original one
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>(Members.CallOriginal);
+
+ // Set return value according to exact arguments
+ Isolate.WhenCalled(() => fake.IntCallWithArg(0)).WithExactArguments().WillReturn(10);
+ Isolate.WhenCalled(() => fake.IntCallWithArg(1)).WithExactArguments().WillReturn(20);
+
+ // Check that the correct value returned
+ Assert.AreEqual(10, fake.IntCallWithArg(0));
+ Assert.AreEqual(20, fake.IntCallWithArg(1));
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void SwapAFutureInstance_StubIncrementMethod()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>();
+ Isolate.Swap.NextInstance<RealLogger>().With(fake);
+
+ Isolate.WhenCalled(() => fake.Increment()).IgnoreCall();
+
+ // This object is swapped with the fake
+ RealLogger logger = new RealLogger();
+
+ // Make sure Count is reset
+ logger.Count = 0;
+
+ // This call is faked - count should not increment
+ logger.Increment();
+
+ Assert.AreEqual(0, logger.Count);
+ }
+
+
+ [TestMethod]
+ [Isolated]
+ public void SwapAFutureInstance_StubIncrementMethod()
+ {
+ RealLogger fake = Isolate.Fake.Instance<RealLogger>();
+ Isolate.Swap.NextInstance<RealLogger>().With(fake);
+
+ Isolate.WhenCalled(() => fake.Increment()).IgnoreCall();
+
+ // This object is swapped with the fake
+ RealLogger logger = new RealLogger();
+
+ // Make sure Count is reset
+ logger.Count = 0;
+
+ // This call is faked - count should not increment
+ logger.Increment();
+
+ Assert.AreEqual(0, logger.Count);
+ }
+
+ The Runway website is very simple in form and provided without +any design or functionality. By installing Runway, you'll begin +with a minimal site built on best practices. You'll also enjoy the +benefits of speaking the same "language" as the rest of the umbraco +community by using common properties and naming conventions.
+ +Now that you know what Runway is, it is time to get started +using Runway.
+ + + +AJAX Loader:
+ + +]]> + + Runway + +Once installed, Runway Modules are open source and easy to customize if you want to modify the behavior for your specific needs.
Because Runway modules are provided under the MIT license you are free to use and modify them any way you want, with no strings attached.
To add Runway modules to your website, go to the Developer section, expand the Packages item and click Install Runway modules.
+Runwau modules are available for various kinds of navigation, a sitemap, and a contact form. The list of available Runway modules is growing rapidly and is automatically updated from a central source, always fresh and current.
+Get more information about the umbraco way.
]]> + + 0 +With umbraco you’ve finally got a solid, open and reliable platform for websites as simple as a Runway site, and umbraco can be rapidly expanded to support multi-language websites, collaboration platforms and intra/extranets, to name just a few.
+Advanced functionality is created with umbraco macros, built with XSLT and umbraco’s award-winning .NET integration, including full support for any .NET User or Custom control. Create and integrate your own .NET macros in mere minutes with point and click simplicity. Simply copy your controls to the umbraco website, go to the Developer section and create a new macro, selecting your control from the list.
+We’ve also gathered the best community macros into a repository that’s also accessed from the Developer section, in the Packages area. You can find more information about creating macros, on the umbraco website.
+The sky is the limit with umbraco, and you have the benefit a friendly community, training, and guaranteed support. Find out how to get help.
]]> + + 0 +Edit the text on the homepage and create a site structure by adding new texpages to your site. This is all done in the Content section.
+If you find the editing options provided by Runway too limited for you needs, simply add more properties to the page by going to the Settings section, expanding the Document Types item and adding new properties on the Generic Properties tab. You can find more information about document types and properties at the umbraco website.
+But mostly you’ll probably want to personalize your site by changing the current design. This is also done in the Settings section, by editing the CSS styles and HTML templates. Umbraco uses master templates, so the main, common markup is placed in the Runway Master template, while the Homeage and Textpage have separate templates for their unique layouts. You can find more information about templates and css in umbraco at the umbraco website.
+Once you’re happy with your site’s design, you might want to add more functionality, such as automated navigation. This is done by installing Runway modules.
]]> + + 0 +Fusce tristique. Cras faucibus porta nunc. Aliquam ultrices, +arcu quis ornare sagittis, lectus augue ornare nulla, eu lobortis +velit lectus id nibh. Aliquam condimentum aliquet purus. Quisque +blandit ante non sapien. Sed justo libero, sollicitudin ac, pretium +et, luctus nec, nisl. Nulla semper neque nec magna. Cras ut nibh ut +urna bibendum sodales. Quisque venenatis euismod lacus. +Pellentesque dapibus turpis at urna.
+ +Sed scelerisque adipiscing mauris. Mauris egestas dapibus quam. +Integer in libero eget eros dignissim pretium. Proin luctus sem nec +lorem. Praesent lorem. Vivamus eget nunc quis sapien condimentum +egestas. Maecenas facilisis, nunc at sodales facilisis, quam magna +pretium nibh, vel ultrices lectus lorem quis neque. Nam sit amet +leo ac lectus gravida convallis. Phasellus at enim vel dui porta +porttitor. Morbi id dolor adipiscing erat egestas consequat.
+ +Phasellus diam. Morbi +dolor. Donec consequat sodales nunc. Nam dapibus lectus id +lectus. Sed ultrices metus sit amet est. Morbi porttitor. Proin vel +risus. Phasellus sodales convallis justo. Sed luctus hendrerit +risus. Sed est lorem, feugiat et, rutrum quis, condimentum non, +nunc. Aenean urna leo, sagittis a, commodo eget, lobortis nec, +eros. Vivamus pharetra, lectus eu ultrices pulvinar, nunc quam +consectetur nibh, sed pulvinar leo dolor ut felis.
+ +Nullam lobortis, mi nec feugiat congue, dolor diam cursus lacus, +a elementum ligula dolor vitae sem. Suspendisse at quam. Praesent +neque. Vestibulum at justo. Nulla rutrum velit et eros.
+ +Nullam lobortis, mi nec feugiat congue, dolor diam cursus lacus, +a elementum ligula dolor vitae sem. Suspendisse at quam.
+]]> + +It means that you are not bound and locked to the licensing +rules about the number of content items / processors / web / +domains, etc. Many products are very expensive as the license cost +escalates with the number of websites. In many cases, one is soon +up in the 500' before one can even start to implement the +solution.
+ +In an Open Source product one has at any time full access to +source code. This provides insight and leads to better quality, as +"shortcuts" and bad code can easily be penetrated. Moreover, one +has the ability to influence and further develop the product.
+ +Umbraco is based on open source and is therefore not +lisence-plated or subject to an enterprise's ownership. The Umbraco +publishing tool places great emphasis on simplicity, standards, +flexibility and integration. Umbraco was launched in 2005 and has +had a tremendous growth since that time. Umbraco is today among the +most popular systems based on open source for Microsoft. NET +platform.
+ +Umbraco is built 100% on the Microsoft. NET 2.0. This means that +you can use 3rd party .NET components directly in Umbraco. +Moreover, integration with other .NET-based solutions is well +adapted from Umbracos part. Umbraco won an award for the +Integration possibilities on BNP Awards 2006.
+ +Umbraco is a powerful tool with a focus on core functionality +and openness. This efficiently allows you to achieve exactly what +you want - rather than be restricted to a "finished" module, which +makes only half of what you really wanted.
+ +Umbraco has a focus on content and facilitate rapid and +intuitive content management. The system strives to be elegant, +usable and effective.
+ +Umbraco is based on standards from the W3C as XHTML, CSS, XML +and XSLT. This gives a greater flexibility and independence, which +in turn provides more value for the money.
+ +Umbraco is known to be among the best CMS on integration. Much +of the reason for this is the way to expose Microsoft ASP.NET +components as elements of, or so-called "macro's" for use in +templates, as well as in the WYSIWYG editor that writers and +editors use. Elements is also possible to "cache" on several levels +and is based on standard Microsoft .NET technology. Below are some +examples:
+ ++ +
+]]> + +
Sam Grady, me, is a graphic designer. I loves graphic design.
+Great graphic design and simple solutions makes this man very
+happy. Photography is also very close to my heart and I'd like to
+be better, so I practice a lot and annoy people with my
+requests.
+
+ I haven't got a blog, yet, don't Twitter and cancelled my Facebook
+account as I felt uncomfortable with people knowing my business.
+Anyone else feel that way? I do, however, have a Flickr account, so
+go check it out: www.flickr.com/photos/mrgrady
+
+ I also have my own business, G72, which has a website that
+desperately needs updating. Also, as of today (03/03/09), it's
+currently down due to inept web hosts. Hopefully it won't be if you
+want to take a look: www.g-72.co.uk
+
+ Regarding this project, Warren asked me if I wanted to design his
+website starter package for the fantastic Umbraco CMS, which I
+jumped at the chance to do. Hopefully you'll find the design
+appropriate and the package very useful, as that's what we really
+want from this project.
+
+ Finally, Warren says the layout is work in progress and I have a,
+typically fussy, list of designer layout requests that I've asked
+Warren to do, but time being what it is, these changes won't be
+made on version 2.0, so if you spot anything, do mail the man as
+we'll be compiling a list of tweaks to be made.
+
+ Enjoy.
Warren Buckley is a web developer who specialises in using the +Umbraco CMS platform to build content managed websites for Xeed in +Norway. I run a blog called Creative Web +Specialist, where I mainly write tips and tutorial articles +around Umbraco.
+ +I have teamed up with ex-collegue Sam Grady to help me design +the new version of CWS as he produces wonderfully sexy designs for +the web. If you have seen my previous version/s of CWS you will +know that my design skills are far from stunning.
+ +I decided to create this website starter site nicknamed CWS +(Creative Website Starter site) as a learning tool to help you +understand how all the elements of a site work together in +Umbraco.
+ +From this NEW CWS package comes the +following:
+ +Want to see where else you can find me on the net?
+ Blog - www.creativewebspecialist.co.uk
+ Flickr - www.flickr.com/photos/warrenbuckley
+ Last.FM - www.last.fm/user/warrenbuckley
+ Twitter - twitter.com/warrenbuckley
The who's who of umbraco will be gathered and share their +knowledge through talks, tutorials and via un-conference formats +like open space or hacking sessions. We have booked a cool, old and +huge industrial venue in central Copenhagen where we'll have one +huge room, three rooms for breakout sessions and a Café that +serves your taste of espresso.
+ +Come join the annual umbraco developer conference in Wonderful +Copenhagen on June 22nd - 23rd. Two days for insights, eye-openers, +great conversations and friendly people.
+ +We've planned a program that fits both experienced umbraco users +as well as new comers. The conference is kicked off with a Keynote +and after that we'll have two or three tracks of sessions and the +first day is rounded with an open Q/A session with the umbraco core +team.
+ +The second day features an un-conference format called open +space, which we also used with great success at last year's +conference. It's a format where everybody can suggest a topic and +as we have plenty of break-out rooms rest assured that there'll be +room for your topic as well. Last year's more than 20 topics +covered Silverlight, High performance websites with umbraco, +building custom data types and much more.
+ +But it doesn't ends there. We've ensured that we can stay at the +venue until midnight both days which means that when the first day +ends, the fun begins. With more than hundred people gathered at a +place with loads of umbraco knowledge, wifi, great food and plenty +of space, who knows what could happen. A BBQ, new packages, +improvised demos and talks, or...?
+ ++]]> + + /media/445/umbraco_tshirt.jpg + + + + + + + 0 + 0 +
As of today Wednesday the 4th March 2009, the CWS2 package is +now available to download from the built in package repository +inside Umbraco.
+ +With this new version comes the following:
+ +If you have a particular enquiry, please fill out the form below +and provide as much information as you can, so that one of our +representatives can deal with your enquiry as effciently as +possible.
+]]> + + + Thank you. We will be in touch shortly. +]]> + + + Thanks for filling out our contact form we will get back to you +shortly. + +Regards,
+ My Company