Custom Assertions

To create custom assertions between parameters passed to methods, you can use the WHEN_CALLED(...).DoInstead() combo, and provide a pointer to your own verification function:

Assuming the following class in production code

class Person

{

public:

      int GetAverageChildAge(int child1, int child2) 

      { 

              return (child1 + child2) / 2;  

      }

 int CallPrivate(int var) 

      { 

              return SomePrivate(var);  

      }

private:

 int SomePrivate(int var){ return var; }

 int SomePrivate(string var){ return stoi(var); }

};

We'd like to create a custom assertion that GetAverageChildAge actually gets called with the parameters of the same parity, so let's create our verification function:

class AltPerson

{

public:

      int VerifyArguments(int param1, int param2) 

      { 

            int mod1 = param1 % 2;

            int mod2 = param2 % 2;

              ASSERT_EQ(mod1, mod2);

            return -1;

      }

};

Now, let's inject the verification function into the runtime:

TEST_F(Examples, CustomAssertion)

{

   Person* personPtr = new Person();   

   AltPerson* altPerson = new AltPerson(); 

   WHEN_CALLED(personPtr->GetAverageChildAge(_, _)).DoMemberFunctionInstead(altPerson, VerifyArguments);

   int child1 = 0;

   int child2 = 2;

   // We should get an assert exception since the first parameter is not 10

   personPtr->GetAverageChildAge(child1, child2); 

   ISOLATOR_CLEANUP();

}

For more simple custom assertions on parameters passed to methods, you can use the Conditional Checkers:

TEST_F(Examples, CustomAssertion)

{

   Person* personPtr = new Person();   

   WHEN_CALLED(personPtr->GetAverageChildAge(_, _)).Ignore();

   int child1 = 0;

   int child2 = 2;

   personPtr->GetAverageChildAge(child1, child2); 

   ASSERT_WAS_CALLED(personPtr->GetAverageChildAge(EQ(0), LE(10)));

   ISOLATOR_CLEANUP();

}

Using Predicates:

You can use lambda expressions using the IS<> macro like in example below:

Note: In order to assert a specific overload was called with matching arguments, use the IS<> macro to specify the overload and the arguments predicate.

TEST_F(Examples, CustomAssertion)

{

   Person* personPtr = new Person();  

   WHEN_CALLED(personPtr->GetAverageChildAge(_, _)).Ignore();

   int child1 = 0;

   int child2 = 2;

   personPtr->GetAverageChildAge(child1, child2); 

   ASSERT_WAS_CALLED(personPtr->GetAverageChildAge(EQ(0), IS<int>( [](int x) {return x == 2} )));

   ISOLATOR_CLEANUP();

}

Or you can extract the condition like in the next example:

TEST_F(Examples, CustomAssertion)

{

   Person* personPtr = new Person();   

   WHEN_CALLED(personPtr->GetAverageChildAge(_, _)).Ignore();

   int child1 = 0;

   int child2 = 2;

   auto predicate = [](int x)

   {

      return x == 2

   }

   personPtr->GetAverageChildAge(child1, child2); 

   ASSERT_WAS_CALLED(personPtr->GetAverageChildAge(EQ(0), IS<int>( predicate )));

   ISOLATOR_CLEANUP();

}

As in public methods, to assert a private overloaded method with matching arguments was called, use the IS<> macro:

TEST_F(Examples, CustomAssertion)

{

   Person* personPtr = FAKE<Person>(FakeOptions::CallOriginal);

   personPtr->CallPrivate(10);

   PRIVATE_ASSERT_WAS_CALLED(personPtr,SomePrivate,IS<int>([](int x) {return x == 10}));

}

Note: When there is no lambda expressions support, you can use a predicate class with overloaded ().

You'll need to define NO_CPP_LAMBDA_SUPPORT:

#define NO_CPP_LAMBDA_SUPPORT

struct Predicate{

   bool operator()(int x){return x == 10;}

}

TEST_F(Examples, CustomAssertion)

{

   Person* personPtr = FAKE<Person>(FakeOptions::CallOriginal);

   personPtr->CallPrivate(10);

   PRIVATE_ASSERT_WAS_CALLED(personPtr,SomePrivate,IS<int>(Predicate()));

}