with_side_effects() should provide ability to inspect arguments passed to a mocked function

[Kamil2000]

The with_side_effects() should create the constrain that allows user to browse the arguments of a function.
This could be relatively easily achieved by just passing a second argument to a user callback.

Expected feature:
void user_callback(void* data, Arguments* args) {
// here it is possible to inspect/interact with args
}

//using cb
expect(mocked_function, with_side_effect(&user_callback, &unimportant));

Such change should be backward-compatible, because same thing
was used by GTK+ extensively:
// old code, most important thing is that gtk_main_quit
// declares no parameters, receives two
// and despite all of this works like a charm.
g_signal_connect(G_OBJECT(window), "destroy",
G_CALLBACK(gtk_main_quit), NULL);

[thoni56]

This is a great idea!

I'm not familiar enough with GTK to see how they get away with this. Just calling a function/macro with more arguments than it has declared will surely fire error messages from most C compilers.

Or am I misunderstanding you? I would appreciate a more detailed sketch of how this would look.

[Kamil2000]

Ok, I will try to explain this whole C function pointers magic above:

The most important thing is to handle two
function signatures with a one macro. This can be done
with little bit of casting. Take a look at this trivial program:
#include <stdio.h>

typedef void (*Func2)(int, int);
typedef void (*Func1)(int);
void func(void) {
printf("LaLa\n");
}
int main()
{
Func2 func2 = (Func2)&func;
Func1 func1 = (Func1)&func;
func2(4,5);
func1(5);
return 0;
}

It will compile and run on any platform. However, this doesn't mean this
is a C-compilant program, because standard doesn't define
such calls at any point.

For more information please visit:
https://stackoverflow.com/questions/559581/casting-a-function-pointer-to-another-type
As one reply suggest, this is technically undefined behavior., but the second
one suggests that whole GNOME framework depends upon it, because of ABI
compatibility.

After some reconsideration I figured out we might use some other,
more standard C tricks to handle two types with a single macro.
In C11 there is a _Generic macro, which can be useful:
#include <stdio.h>

typedef void (*FuncA)(void);
typedef void (*FuncB)(int);

void funcA(void) {
printf("LaLa\n");
}
void funcB(int unused) {
(void)unused;
printf("TaTa\n");
}
void callA(FuncA a) {
a();
}
void callB(FuncB b) {
b(0);
}
#define CALL(x) _Generic(x, FuncA: callA, default: callB)(x)

int main()
{
CALL(funcA);
CALL(funcB);
return 0;
}

I personally like the second approach more sue to standard compliance
and cleaner error messages. If that approach is to be chosen sth like
with_parametrized_side_effects needs to be provided for for
older C versions.

Hope all is clear by now ;)