Thank you for downloading Typemock Isolator!

 

Typemock Power-Up hint: Caesarian Shift

Now that you have the latest version, go ahead and check out the latest innovative feature from Typemock - Intellitest!

Intellitest makes life simpler by adding Arrange statements, as you write your code! Just click here to learn more.

If you want to get special updates, news about our latest features and improve your unit testing skills, just fill out the form, and we'll get back to you!

This form does not yet contain any fields.

    Writing and running your first unit test in C# 

     You can find the code used in this tutorial in Test0_Tutorial.cs, in the Isolator installation folder (usually C:\Program Files\Typemock\Isolator\VERSION), under the Typemock.Example.VisualBasic solution.

     

    Step 1 - Create a new Test Project

    This step shows you how to create a new test project in Visual Studio, and add the Typemock references you need.

    • Open Visual Studio, click ‘File’ and create a new Test Project.

    • Right click ‘Project Properties’, click ‘Add References’ and add ‘Typemock Isolator’ and ‘Typemock Isolator - C# API’

    For this example test, you’ll need a reference to System.Windows.Forms as well.
     

    Step 2 - Write unit tests

    This section will walk you through the three stages in unit tests that use the C# API to isolate.

         1. Arrange – Set up your faked object’s behaviour

         2. Act - Call your test code

         3. Assert - Make sure that the tests were called

    In the new test project we opened in Visual Studio, go to UnitTest1.cs in the ‘Solutions’ column and add the following test code to the beginning of the file:

     

    using System.Windows.Forms;
    using TypeMock.ArrangeActAssert;

     

    Add the Isolated attribute to the test class:

     

    [TestClass, Isolated]
    public class Test0_Tutorial

     

     

    Example Test 1 - Simple test using MessageBox

    This example shows how to ignore a method call, and verify it was called during our test.

    We’ll use the following APIs in this test:

    • Isolate.WhenCalled - The method inside the WhenCalled clause will be ignored, and will return a fake value
    • Isolate.Verify.WasCalledWithExactArguments - Verifies that the method inside the WhenCalled clause was called during the test with the exact arguments

    The following takes place in the code:

     

    [TestMethod]
    public void SimpleTestUsingMessageBox()
    {
     // Arrange
    1 Isolate.WhenCalled(()=> MessageBox.Show(String.Empty)).WillReturn(DialogResult.OK);

     // Act
    2 MessageBox.Show("This is a message");

     // Assert
    3 Isolate.Verify.WasCalledWithExactArguments(()=>MessageBox.Show("This is a message"));
    }

     

    • Set all calls to MessageBox.Show to be ignored, and return a fake value.
    • Call MessageBox.Show - notice that when you run the test, the MessageBox doesn't actually appear.
    • Check that the static function ‘Show’ was called during the test with the parameter "This is a message".

     

      Example Test 2 - Complex Test

    This example shows how to test the interaction between two classes:

    • SomeClass - Has a shared sub called MyMethod
    • UserOfSomeClass - Has a sub called DoSomthing

     

    public class SomeClass
    {
     public static void MyMethod()
     {
      // do work
     }
    }

    public class UserOfSomeClass
    {
     public void DoSomething()
     {
      try

      {
       SomeClass.MyMethod();
      }
     catch (Exception exc)
     {
      MessageBox.Show("Exception caught: " & exc.Message);
      }
     }
    }

     

    This test checks that the user sees every exception thrown from SomeClass using a MessageBox.

    The following APIs are used in the test:

    We’ll use the following APIs in this test:

    • Isolate.WhenCalled(..).WillThrow - The method inside the WhenCalled clause will throw a specified exception when called
    • Isolate.WhenCalled(..).WillReturn - The method inside the WhenCalled will be ignored, and return a fake value
    • Isolate.Verify.WasCalledWithExactArguments - Verifies that the method inside the WhenCalled clause was called with the exact arguments during the text execution

     

    [TestMethod]
    public void ComplexTest()
    {
     // Arrange
    1a Isolate.WhenCalled(()=> SomeClass.MyMethod()).WillThrow( new Exception ("foo"));
    2a Isolate.WhenCalled(()=> MessageBox.Show(String.Empty)).WillReturn(DialogResult.Cancel);

     // Act
    2 UserOfSomeClass user = new UserOfSomeClass();
    user.DoSomthing();

     // Assert
    3 Isolate .Verify.WasCalledWithExactArguments(()=> MessageBox .Show("Exception caught: foo"));
    }

     

    The following takes place in the code:

    • The actual test code - Create a new instance of UserOfSomeClass and call the DoSomething method.
    • Check that MessageBox.Show was called during our test with ‘Exception caught: foo’.

    Here is the full source code we used in our examples:

     

    using System;
    using Microsoft.VisualStudio.TestTools.UnitTesting;
    using System.Windows.Forms;
    using TypeMock.ArrangeActAssert;


    [TestClass, Isolated]
    public class Test0_Tutorial

    {

     [TestMethod]
     public void SimpleTestUsingMessageBox()
     {
      // Arrange
      Isolate.WhenCalled(()=> MessageBox.Show(String.Empty)).WillReturn(DialogResult.OK);

      // Act
      MessageBox.Show("This is a message");

      // Assert
      Isolate.Verify.WasCalledWithExactArguments(()=> MessageBox.Show("This is a message"));
     }

     [TestMethod]
     public void ComplexTest()
     {
      // Arrange
      Isolate.WhenCalled(()=> SomeClass.MyMethod()).WillThrow( new Exception ("foo"));
      Isolate.WhenCalled(()=> MessageBox.Show(String.Empty)).WillReturn( DialogResult.Cancel);

      // Act
      UserOfSomeClass user = new UserOfSomeClass ();
      user.DoSomthing();

      // Assert
      Isolate.Verify.WasCalledWithExactArguments(()=> MessageBox.Show("Exception caught:
      foo"));
     }


    }


    public class SomeClass
    {
     public static void MyMethod()
     {
      // do work
     }
    }

    public class UserOfSomeClass
    {
     public void DoSomething()
     {
      try
      {
       SomeClass.MyMethod();
      }
      catch ( Exception exc)
      {
       MessageBox .Show("Exception caught: " & exc.Message);
      }
     }
    }

     

    For more help on using Typemock Isolator, read the following:

    You’re also invited to read our blog to see more advanced usages of Isolator and unit testing information, and if you have any questions, feel free to use our support forums.