cmocka，如何检查函数指针

Question

I searched in the documentation and in the waiter example but I can't find an example about how to check if the right function pointer is passed as parameter to a function.

This sample code should detail well what I mean:

void func_A();
void func_B();

void verify(int value) {
    if (value == 0) {
        process(func_A);
    } else if (value == 1) {
        process(func_B);
    }
}

My idea was to mock process like this:

void __wrap_process(EVENT_HANDLER handler){
    check_expected(handler);
    ///I made a test also with check_expected_ptr but the result is the same.
}

And, in the test call:

expect_memory(__wrap_process, handler, func_A, sizeof(func_A));
verify(0);

This does not work because if I replace func_A with func_B in the expect_memory the test pass. I don't see any expect_* function other than expect_memory that can check a pointer.

What did you use?

EDIT: Added the following example. EDIT2: Updated example with includes and verified that it compiles correctly.

As example I can provide this simple code:

#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <stdint.h>
#include <cmocka.h>

union EVENT{
    uint8_t event;
};

typedef void (*CALLBACK)(union EVENT * event);

void wrap_register_callback( CALLBACK callback );

void callback_module_a( union EVENT *event ) {
    //Do something with the event
    //It is out of scope for this test.
    (void)event;
}

void callback_module_b( union EVENT *event ) {
    //Do something with the event
    //It is out of scope for this test.
    (void)event;
}



void __wrap_register_callback( CALLBACK callback ) {
    check_expected(callback);
}

void code_that_set_the_callback( int status ) {
    if (status < 0){
        register_callback(callback_module_a);
    }else{
        register_callback(callback_module_b);
    }
}

void test_correct_handler( ) {
    int status = 0;
    expect_memory(__wrap_register_callback, callback,  callback_module_a, sizeof(CALLBACK));
    //TEST 1 expected result test pass. Result: test pass
    code_that_set_the_callback(status);

    status = -1;
    expect_memory(__wrap_register_callback, callback, callback_module_b, sizeof(CALLBACK));
    //TEST 2 expected result test pass. Result: test pass
    code_that_set_the_callback(status);

    //At the moment if I change the callbacks in the tests, like:
    status = 0;
    //This is not correct but the test passes.
    expect_memory(__wrap_register_callback, callback, callback_module_b, sizeof(CALLBACK));
    //TEST 3 expected result test fail. Result: test pass
    //This is wrong
    code_that_set_the_callback(status);

    status = -1;
    //This is not correct but the test passes.
    expect_memory(__wrap_register_callback, callback, callback_module_a, sizeof(CALLBACK));
    //TEST 4 expected result test fail. Result: test pass
    //This is wrong
    code_that_set_the_callback(status);
}

int main(void)
{
    //Make coverage happy
    const struct CMUnitTest tests[] = {
        cmocka_unit_test(test_correct_handler),
    };
return cmocka_run_group_tests(tests, NULL, NULL);
}

Note on the code: The function register_callback is not under the test in this test code. The body of the function is omitted because during the compilation of the code, passing the argument -Wl,--wrap=register_callback to the linker the function is completely replaced with __wrap_register_callback

The idea is that a function initialize a callback, this callback depends on some initialization value. I want to check that the selected callback is the right one depending on the situation.

from the documentation page https://api.cmocka.org/group__cmocka__param.html

the available macros for verify the parameters received by a function that was mocked does not contain a function for verify a function pointer parameter. In my opinion the only function that I can adapt for this scope is expect_memory but

• it is not working,
• I didn't understand correctly the way to use it
• I made a mistake writing the test.

Answer 1

cmocka does not appear to have any parameter-checking macro specifically intended for pointers. In many C implementations, expect_value may serve your purpose. cmocka converts the value you pass it to LargestIntegralType , which it attempts to define to be a wide unsigned integer type. Assuming the type is wide enough, many C implementations will convert different pointers to different integers and equal pointers to equal integers. (Two pointers in C may compare as equal even though they have different bit representations internally. But a good C implementation will normalize the representation when converting to integer.)

If these requirements are met, you should be able to use expect_value to test pointers, as with:

void test_correct_handler( ) {
    int status = 0;
    expect_value(__wrap_register_callback, callback,  callback_module_a);
    code_that_set_the_callback(status);

    status = -1;
    expect_value(__wrap_register_callback, callback, callback_module_b);
    code_that_set_the_callback(status);

    //At the moment if I change the callbacks in the tests, like:
    status = 0;
    //This is not correct but the test passes.
    expect_value(__wrap_register_callback, callback, callback_module_b);
    code_that_set_the_callback(status);

    status = -1;
    //This is not correct but the test passes.
    expect_value(__wrap_register_callback, callback, callback_module_a);
    code_that_set_the_callback(status);
}

Tinkering with the above confirms it is sensitive to whether callback_module_a or callback_module_b is used. However, the sense of the tests is reversed from what you say in the question: The first two report failure, and the last two report pass. Are you sure you have the tests the right way around? If you swap callback_module_a with callback_module_b in this code, you will have the situation you request, where the first two pass and the last two fail.