With Isolator++ you can assert a function call on a fake object. Let’s say my class has a void call and I want to make sure got called. In the next test, the ASSERT_WAS_CALLED macro is used for validation of the VoidCall call:

/ Asserting a method call

TEST_F(IsolatorTests, AssertWasCalled)

{

     ConcreteClass* fakeConcrete = FAKE(ConcreteClass);

     fakeConcrete->VoidCall(); / this call is ignored

     ASSERT_WAS_CALLED(fakeConcrete->VoidCall());

} 

The test will fail if the method was not called during the run. To make sure a method was not called, use ASSERT_ NOT_CALLED macro:
ASSERT_NOT_CALLED(fakeConcrete->VoidCall());

And finally to verify a method was called X times use the TIMES_CALLED macro:
int num = TIMES_CALLED(instance-> VoidCall ());

On the num variable, you can now use ASSERT_EQ to verify the count):
ASSERT_EQ(3, num);

In this example, I’m using GTest as my test framework. I use the TEST_F macro for declaring a test, with the class name and scenario.

TEST_F(IsolatorTests, ChangeReturnedIntValue)

With Isolator you can change behavior of any calls, instance or statics. In order to fake calls, you still need to create a fake class using the FAKE macro:

ConcreteClass* fakeConcrete = FAKE(ConcreteClass);

My ConcreteClass is a regular class, and I would like to change the behavior of its GetInt() method. The concrete implementation returns -1. By default, native return types like int, doubles, bools return their default values. So if you want to return these values, using the FAKE macro takes care of that. But if you want to change the return value, you can use the WHEN_CALLED macro, like this:

WHEN_CALLED(fakeConcrete->GetInt()).Return(5);

The macro takes the function call to change, and is completed by Return to specify the return value.

I’m completing this test with an ASSERT_EQ (GTest macro for asserting equality) to make sure that the GetInt call returns what I specified:

ASSERT_EQ(5, fakeConcrete->GetInt());

If GetInt returns something other than 5, the test will break when run.

void methods are ignored by default; so again, there’s no need to specify this behavior. However, you can tell the fake instance, that for specific methods, it should run its original implementation:

WHEN_CALLED(fakeConcrete->GetInt()).CallOriginal();

With this, GetInt returns it’s original value, -1.

If you’d like to throw an exception (this is a TypemockException), you’ll use the Throw function:

WHEN_CALLED(fakeConcrete->GetInt()).Throw("Exception occured");

This is valuable when you want to simulate an exception thrown from a dependency.

Download the recent installer and run it. There are a few folders under the Typemock:

• Bin: contains the Isolator.lib header file. You’ll need this to link to your test project.
• Include: contains the Isolator.h header file. You’ll need this to compile your test project.
• Examples: A solution containing examples of Isolator++ features
• GTest: Google testing framework. You’ll need this to run the examples.

 Isolator++ tests runs inside an executable. To start, create a new C++ Console Application.

Make sure the project is compiled to a console application:

Open the project properties. Add the Isolator++ include folder to the include directories.

Add the Isolator.lib to the linker input list

Set up additional includes and libraries, for the test frameworks and the code under test. For GTest, which is deployed with Isolator++, use:

• Add the GTest Include folder: "C:Program FilesTypemockIsolatorgtestInclude"
• Add the GTest library: "gtestd.lib"

Write the _tmain function to run the tests. With GTest it looks like this:

#include "stdafx.h"
#include    int _tmain(int argc, _TCHAR* argv[]) {     ::testing::InitGoogleTest(&argc, argv);     return RUN_ALL_TESTS(); }

Write tests using your test framework, in a separate cpp file. In GTest, TEST_F identifies a test, the first argument is the name of the test, and the second is the scenario. For example:

/ Changing return value
TEST_F(IsolatorTests, ChangeReturnedIntValue)
{
WHEN_CALLED(fakeConcrete->GetInt()).Return(5);
      ASSERT_EQ(5, fakeConcrete->GetInt());
}

Compile and run the console application to run the tests. With GTest, results look like this:

In the result window, you’ll see which tests passed, and which didn’t.

That’s it! You’ve just run your first tests. It’s time to learn more on Isolator++ features.

You can always come back to this page to download the latest Beta build. Here’s a short feature list of what is supported in the current release, and what to look out for.

Supported frameworks:

This version of Isolator++ works in Visual Studio 2008. Isolator++ also deploys GTest, the framework that runs the examples.

Features:

Known issues:

We’ll be following with a few how-tos to get you started.

Typemock Isolator++ is a new unit testing tool for C++. With its API, you can test your C++ code, and isolate the code under test from dependencies (like other classes). Let’s walk through an example to show what that means.

Let’s say I have a Product class. This class has a GetPrice() function:

int Product::GetPrice(PricingManager* manager)
{
      if (manager->isOnSale())
            return 5;
      else
            return 10;
}

As you can see, the GetPrice() function has a dependency: the PricingManager pointer it receives as an argument. The PricingManager’s isOnSale() method looks like this:

bool PricingManager::isOnSale()
{
     return false;
}

It always returns false. I want to test my Product, with both cases – when we have a sale or not. But I don’t want to change the code of isOnSale() just for a test. Maybe I can’t touch it.

This is where Isolator++ helps. It allows you to change the behavior of dependencies, without changing the code.

I’ll create two tests (for a step-by-step guide, read the “Getting Started” section). For the first scenario, where there is no sale, here’s the test:

TEST_F(IsolatorTests, GetPrice_OnSaleIsFalse_ExpectHighPrice)
{
     Product product;
     PricingManager* manager =  new PricingManager();
     ASSERT_EQ(10, product.GetPrice(manager));
}

Since manager->isOnSale() always returns false, the GetPrice() function always returns 10.

However, the second case is different. I want manager->isOnSale() to return true, but without changing the code. Here’s how the test looks like:

TEST_F(IsolatorTests, GetPrice_OnSaleIsTrue_ExpectLowPrice)
{
      Product product;
      PricingManager* fakeManager = FAKE(PricingManager);
      WHEN_CALLED(fakeManager->isOnSale()).Return(true);
      ASSERT_EQ(5, product.GetPrice(fakeManager));
}

I’m using Isolator++’s FAKE macro to create a fake a PricingManager instance (although from a type point of view, this is a regular PricingManager pointer). After that, I’m using Isolator++ to specify the return value true, I want the isOnSale method to return. Finally, I’m testing the expected return value 5.

Isolator++ has many more features. You can learn more in other posts coming up.