mock a function with a pointer-to-pointer argument

Question

I need to mock a function which has a pointer-to-pointer argument (thus a ** argument).

I tried somehing lik the following piece of pseudo-code (note: NON_ZERO_ENUM_MEMBER stands for an enum-value with a value not equal to 0)

my_arg_type argument;
argument.enummember = NON_ZERO_ENUM_MEMBER;

EXPECT_CALL( *my_mock, mock_function( _, _ ) )
.times(1)
.WillOnce( DoAll( SetArgPointee<1>( &argument ), Return( 0 ) ) );

This builds OK, but when I run my test argument.enummember is 0.

If I'm correct this is caused by googlemock making a copy of what I want to return and in case of SetArgPointee create a pointer for it (hence that in case of a normal * one can say SetArgPointee( argument) ). But in this case I give an address and that address is than turned into a pointer. But the actual value of the variable is not stored (if my assumption is correct).

Is there a standard way that googlemock can handle ** arguments or do I have to create a more 'global' variable and return the address of that variable?

/edit/ moved my previous edit to the 2nd reply to keep the original question short

Answer 1

Without seeing more of the code, I cannot figure out how your argument.enummember becomes 0. With that said, it should be possible to set the pointer to a pointer argument with google mock.

Start with a simple class (similar to what was noted in the original post).

class argument {
public:
    int enummember;
};

Then set up a mock class that has a mock method called "run" whose argument is a pointer to a pointer.

class Helper {
public:
    MOCK_METHOD1(run, int(argument ** a));
};

Set up some initial conditions

argument * a = new argument;
a->enummember = 111;

argument * b = new argument;;
b->enummember = 222;

Setup the expectations:

// When we call this function, it will set the given argument to b. 
Helper helper;
EXPECT_CALL(helper, run(_))
    .Times(1)
    .WillOnce(DoAll(SetArgPointee<0>(b), Return(99)));

Run:

int rc = helper.run(&a);

You should see that, rc = 99 and that a is equal to b (they point to the same address).

This can be verified by print out things like this (before and after the run command).

std::cout << "a enummember:" << a->enummember << std::endl;
std::cout << "a (address of the pointer):" << a << std::endl;

std::cout << "b enummember:" << b->enummember << std::endl;
std::cout << "b (address of the pointer):" << b << std::endl;

Answer 2

/edit/moved from original question to here, to keep original question short

On request some more info (I am not allowed to give the exact code, so I have to stick to a pseudo-implementation). I wanted to avoid this at first since (as you can see) it makes my question quite long ;-) )

@Dan: I see that your answer basically boils down to my 'more-global' solution, but than better argumented ;-). At this moment I will not set it as 'correct answer', since I want to see if with this extra info there comes a better one, but as long as none comes consider it as the correct answer.

Some background info:

• The code I'm testing is plain-C, hence my mocks use structs i.s.o. classes.
• The my_arg_type type is defined in a header-file which is used by the SUT (System Under Test)
• For keeping-things-simple: MTBM stands for ModuleToBeMocked and OMM for OtherMockedModule.
• The SUT_code and MTBM / OMM code is old existing code which I'm not allowed to change (don't fix what ain't broken)

Note: Since there actually are 2 modules (even more, but those are not interesting for this particular question) which are mocked involved I've replace the name mock_function from above example with MTBM_mock_function to make the example more clear.

my_arg_type is defined in MTBM.h:

typedef enum
{
    ZERO_ENUM_MEMBER = 0,
    NON_ZERO_ENUM_MEMBER
} MTBM_ENUM_TYPE;

typedef struct
{
    MTBM_ENUM_TYPE enummember;
    ... //some other members not interesting for our test
} my_arg_type;

The code of my SUT boils down to:

#include MTBM.h
#include OMM.h

int SUT_function_to_be_tested( void )
{
   int error = 0;
   my_arg_type *argument_ptr = NULL;
   int interesting_value_OMM = 0;

   error = SUT_code_which_setups_memory_for_argument_and_initializes_it_to_ZERO_ENUM_MEMBER( argument_ptr );

   if (error == 0)
   {
      error = MTBM_mock_function( TRUE, &argument_ptr )
   }

   if ((error == 0) && (argument_ptr->enummember == ZERO_ENUM_MEMBER )
   {
       error = OMM_function_not_interesting_for_this_particular_test();
   }

   if ((error == 0) && (argument_ptr->enummember == NON_ZERO_ENUM_MEMBER )
   {
       error = OMM_function_interesting_for_this_particular_test( &interesting_value_OMM );
   }

   ...

   return(error);
}

The mock I've created is:

extern "C"
{
    #include MTBM.h
    #include OMM.h
}

struct helper
{
   virtual ~helper() {}
   virtual int MTBM_mock_function( bool lock, my_arg_type **argument ) = 0;
   virtual int OMM_function_not_interesting_for_this_particular_test( void ) = 0;
   virtual int OMM_function_interesting_for_this_particular_test( int *interesting_value_OMM) = 0;
};

struct Mock: public helper
{
   MOCK_METHOD2( MTBM_mock_function, int( bool lock, my_arg_type **argument ) );
   MOCK_METHOD0( OMM_function_not_interesting_for_this_particular_test, int( void ) );
   MOCK_METHOD1( OMM_function_interesting_for_this_particular_test, int( int *interesting_value_OMM) );
}

Mock *my_mock

extern "C"
{
   int MTBM_mock_function( bool lock, my_arg_type **argument )
   {
      my_mock->MTBM_mock_function( lock, argument );
   }

   int OMM_function_not_interesting_for_this_particular_test( void )
   {
      my_mock->OMM_function_not_interesting_for_this_particular_test();
   }

   int OMM_function_interesting_for_this_particular_test( int *interesting_value_OMM )
   {
      my_mock->OMM_function_interesting_for_this_particular_test( interesting_value_OMM );
   }
}

my_mock is initialized in the fixture (see this previous question for another unittest where I specified the structure of the fixture)

My first try (on which above question was based) was:

void setup_mocks( void )
//There are actually a lot more mocks, but not interesting for this particular question
//except that I used a function to setup the mocks to keep the actual TEST_F code clear
{
   my_arg_type argument;
   argument.enummember = NON_ZERO_ENUM_MEMBER;

   EXPECT_CALL( *my_mock, MTBM_mock_function( _, _ ) )
   .times(1)
   .WillOnce( DoAll( SetArgPointee<1>( &argument ), Return( 0 ) ) ); 

   EXPECT_CALL( *my_mock, OMM_function_interesting_for_this_particular_test( _ ) )
   .times(1)
   .WillOnce( DoAll( SetArgPointee<0>( 3 ), Return( 0 ) ) );

   //No EXPECT_CALL for the other OMM-function, since that was not expected for this
   //particular test

   ... //other mocks, not interesting for this question
 }

 TEST_F( fixture, test_case )
 {
    setup_mocks();

    SUT_function_to_be_tested();
 }

This unexpectedly led to OMM_function_not_interesting_for_this_particular_test being called and not OMM_function_interesting_for_this_particular_test.

As can be read above I already figured out that it had to do with how GoogleMock sets up the mock, hence my reference to 'more global variable', so in the mean time I've changed the code to:

void setup_mocks( my_arg_type *argument)
{
   argument->enummember = NON_ZERO_ENUM_MEMBER;
   EXPECT_CALL( *my_mock, MTBM_mock_function( _, _ ) )
   .times(1)
   .WillOnce( DoAll( SetArgPointee<1>( &*argument ), Return( 0 ) ) );

   ...

}

TEST_F( fixture, test_case )
{
   my_arg_type argument;

   setup_mocks( &argument );

   SUT_function_to_be_tested();
}

And that works, but I was wondering if there is a way to avoid the 'more global' solution and do it directly via GoogleMock (e.g. define my own type of action (with which I don't have any experience at all)?). Since this particular pattern with a pointer-to-pointer needed to be mocked among a lot of other functions to be mocked is needed for more unittests. And I want to avoid that in the future I need to create setup_mock functions with multiple arguments just to setup a number of pointer-to-pointer mocks.