Validate function parameters match expected values. More...

Data Structures
struct	SourceLocation
struct	CheckParameterEvent
struct	CheckParameterEventData

Typedefs
typedef int(*	CheckParameterValue) (const uintmax_t value, const uintmax_t check_value_data)
typedef int(*	CheckParameterValueData) (const CMockaValueData value, const CMockaValueData check_value_data)
typedef int(*	CheckIntParameterValue) (const intmax_t value, const intmax_t check_value_data)
typedef int(*	CheckUintParameterValue) (const uintmax_t value, const uintmax_t check_value_data)
typedef struct SourceLocation	SourceLocation
typedef struct CheckParameterEvent	CheckParameterEvent
typedef struct CheckParameterEventData	CheckParameterEventData

Functions
void	expect_check (function, parameter, CheckParameterValue check_function, const void *check_data)
void	expect_check_count (function, parameter, CheckParameterValue check_function, const void *check_data, size_t count)
void	expect_check_data (function, parameter, CheckParameterValueData check_function, CMockaValueData check_data)
	Add a custom parameter checking function using CMockaValueData (new API).
void	expect_check_data_count (function, parameter, CheckParameterValueData check_function, CMockaValueData check_data, size_t count)
	Add a custom parameter checking function using CMockaValueData with count (new API).
void	expect_in_set (#function, #parameter, uintmax_t value_array[])
void	expect_in_set (#function, #parameter, intmax_t value_array[])
	Add an event to check if the parameter value is part of the provided integer array.
void	expect_in_set_count (#function, #parameter, uintmax_t value_array[], size_t count)
void	expect_int_in_set_count (#function, #parameter, intmax_t value_array[], size_t count)
	Add an event to check if the parameter value is part of the provided integer array.
void	expect_uint_in_set_count (#function, #parameter, uintmax_t value_array[], size_t count)
	Add an event to check if the parameter value is part of the provided unsigned integer array.
void	expect_not_in_set (#function, #parameter, uintmax_t value_array[])
void	expect_not_in_set_count (#function, #parameter, uintmax_t value_array[], size_t count)
void	expect_int_not_in_set (#function, #parameter, intmax_t value_array[])
	Add an event to check if the integer parameter value is not part of the provided integer array.
void	expect_int_not_in_set_count (#function, intmax_t value_array[], size_t count)
	Add an event to check if the integer parameter value is not part of the provided integer array.
void	expect_uint_not_in_set (#function, #parameter, uintmax_t value_array[])
	Add an event to check if the unsigned integer parameter value is not part of the provided unsigned integer array.
void	expect_uint_not_in_set_count (#function, uintmax_t value_array[], size_t count)
	Add an event to check if the unsigned integer parameter value is not part of the provided unsigned integer array.
void	expect_float_in_set (#function, #parameter, double value_array[], double epsilon)
	Add an event to check if the float parameter value is part of the provided array.
void	expect_float_in_set_count (#function, #parameter, double value_array[], double epsilon, size_t count)
	Add an event to check if the float parameter value is part of the provided integer array.
void	expect_float_not_in_set (#function, #parameter, double value_array[], double epsilon)
	Add an event to check if the float parameter value is not part of the provided array.
void	expect_float_not_in_set_count (#function, #parameter, double value_array[], double epsilon, size_t count)
	Add an event to check if the float parameter value is not part of the provided integer array.
void	expect_in_range (#function, #parameter, uintmax_t minimum, uintmax_t maximum)
void	expect_in_range_count (#function, #parameter, uintmax_t minimum, uintmax_t maximum, size_t count)
void	expect_int_in_range (#function, intmax_t minimum, intmax_t maximum)
	Add an event to check an integer parameter is inside a numerical range. The check would succeed if minimum <= value <= maximum.
void	expect_int_in_range_count (#function, intmax_t minimum, intmax_t maximum, size_t count)
	Add an event to repeatedly check an integer parameter is inside a numerical range. The check would succeed if minimum <= value <= maximum.
void	expect_uint_in_range (#function, uintmax_t minimum, uintmax_t maximum)
	Add an event to check an unsigned integer parameter is inside a numerical range. The check would succeed if minimum <= value <= maximum.
void	expect_uint_in_range_count (#function, uintmax_t minimum, uintmax_t maximum, size_t count)
	Add an event to repeatedly check an unsigned integer parameter is inside a numerical range. The check would succeed if minimum <= value <= maximum.
void	expect_not_in_range (#function, #parameter, uintmax_t minimum, uintmax_t maximum)
	Add an event to check a parameter is outside a numerical range. The check would succeed if minimum > value > maximum.
void	expect_not_in_range_count (#function, #parameter, uintmax_t minimum, uintmax_t maximum, size_t count)
	Add an event to repeatedly check a parameter is outside a numerical range. The check would succeed if minimum > value > maximum.
void	expect_int_not_in_range (#function, intmax_t minimum, intmax_t maximum)
	Add an event to check an integer parameter is outside a numerical range. The check would succeed if minimum > value > maximum.
void	expect_int_not_in_range_count (#function, intmax_t minimum, intmax_t maximum, size_t count)
	Add an event to repeatedly check an integer parameter is outside a numerical range. The check would succeed if minimum > value > maximum.
void	expect_uint_not_in_range (#function, uintmax_t minimum, uintmax_t maximum)
	Add an event to check an unsigned integer parameter is outside a numerical range. The check would succeed if minimum > value > maximum.
void	expect_uint_not_in_range_count (#function, uintmax_t minimum, uintmax_t maximum, size_t count)
	Add an event to repeatedly check an unsigned integer parameter is outside a numerical range. The check would succeed if minimum > value > maximum.
void	expect_float_in_range (#function, #parameter, double minimum, double maximum, double epsilon)
	Add an event to check a parameter is inside a numerical range. The check would succeed if minimum <= value <= maximum.
void	expect_float_in_range_count (#function, #parameter, double minimum, double maximum, double epsilon, size_t count)
	Add an event to repeatedly check a parameter is inside a numerical range. The check would succeed if minimum <= value <= maximum.
void	expect_float_not_in_range (#function, #parameter, double minimum, double maximum, double epsilon)
	Add an event to check a parameter is outside a numerical range. The check would succeed if minimum > value > maximum.
void	expect_float_not_in_range_count (#function, #parameter, double minimum, double maximum, double epsilon, size_t count)
	Add an event to repeatedly check a parameter is outside a numerical range. The check would succeed if minimum > value > maximum.
void	expect_value (#function, #parameter, uintmax_t value)
void	expect_value_count (#function, #parameter, uintmax_t value, size_t count)
void	expect_int_value (#function, #parameter, intmax_t value)
	Add an event to check if an integer parameter is the given value.
void	expect_int_value_count (#function, intmax_t value, size_t count)
	Add an event to repeatedly check if an integer parameter is the given value.
void	expect_uint_value (#function, #parameter, uintmax_t value)
	Add an event to check if an unsigned integer parameter is the given value.
void	expect_uint_value_count (#function, uintmax_t value, size_t count)
	Add an event to repeatedly check if an unsigned integer parameter is the given value.
void	expect_int_not_value (#function, #parameter, intmax_t value)
	Add an event to check if a parameter (int) isn't the given value.
void	expect_int_not_value_count (#function, intmax_t value, size_t count)
	Add an event to repeatedly check if a parameter (int) isn't the given value.
void	expect_uint_not_value (#function, #parameter, uintmax_t value)
	Add an event to check if a parameter (uint) isn't the given value.
void	expect_uint_not_value_count (#function, uintmax_t value, size_t count)
	Add an event to repeatedly check if a parameter (uint) isn't the given value.
void	expect_not_value (#function, #parameter, uintmax_t value)
void	expect_not_value_count (#function, #parameter, uintmax_t value, size_t count)
void	expect_float (#function, #parameter, double value, double epsilon)
	Add an event to check if a parameter is the given floating point value.
void	expect_float_count (#function, #parameter, double value, double epsilon, size_t count)
	Add an event to repeatedly check if a parameter is the given floating point value.
void	expect_not_float (#function, #parameter, double value, double epsilon)
	Add an event to check if a parameter isn't the given floating point value.
void	expect_not_float_count (#function, #parameter, double value, double epsilon, size_t count)
	Add an event to repeatedly check if a parameter isn't the floating point value.
void	expect_double (#function, #parameter, double value, double epsilon)
	Add an event to check if a parameter is the given double precision floating point value.
void	expect_double_count (#function, double value, double epsilon, size_t count)
	Add an event to repeatedly check if a parameter is the given double precision floating point value.
void	expect_not_double (#function, #parameter, double value, double epsilon)
	Add an event to check if a parameter isn't the given double precision floating point value.
void	expect_not_double_count (#function, double value, double epsilon, size_t count)
	Add an event to repeatedly check if a parameter isn't the double precision floating point value.
void	expect_string (#function, #parameter, const char *string)
	Add an event to check if the parameter value is equal to the provided string.
void	expect_string_count (#function, #parameter, const char *string, size_t count)
	Add an event to check if the parameter value is equal to the provided string.
void	expect_not_string (#function, #parameter, const char *string)
	Add an event to check if the parameter value isn't equal to the provided string.
void	expect_not_string_count (#function, #parameter, const char *string, size_t count)
	Add an event to check if the parameter value isn't equal to the provided string.
void	expect_memory (#function, #parameter, void *memory, size_t size)
	Add an event to check if the parameter does match an area of memory.
void	expect_memory_count (#function, #parameter, void *memory, size_t size, size_t count)
	Add an event to repeatedly check if the parameter does match an area of memory.
void	expect_not_memory (#function, #parameter, void *memory, size_t size)
	Add an event to check if the parameter doesn't match an area of memory.
void	expect_not_memory_count (#function, #parameter, void *memory, size_t size, size_t count)
	Add an event to repeatedly check if the parameter doesn't match an area of memory.
void	expect_any (#function, #parameter)
	Add an event to check if a parameter (of any value) has been passed.
void	expect_any_always (#function, #parameter)
	Add an event to always check if a parameter (of any value) has been passed.
void	expect_any_count (#function, #parameter, size_t count)
	Add an event to repeatedly check if a parameter (of any value) has been passed.
void	check_expected (#parameter)
void	check_expected_any (#parameter)
	Check that any parameter value matches the next value in the queue.
void	check_expected_ptr (#parameter)
	Determine whether a function parameter is correct.
void	check_expected_int (#parameter)
	Determine whether a function parameter is correct.
void	check_expected_uint (#parameter)
	Determine whether a function parameter is correct.
void	check_expected_float (#parameter)
	Determine whether a function parameter is correct.
void	check_expected_double (#parameter)
	Determine whether a function parameter is correct.

Detailed Description

Validate function parameters match expected values.

Functionality to store expected values for mock function parameters.

In addition to storing the return values of mock functions, cmocka provides functionality to store expected values for mock function parameters using the expect_*() functions provided. A mock function parameter can then be validated using the check_expected_*() macros.

Successive calls to expect_*() macros for a parameter queues values to check the specified parameter. check_expected_*() checks a function parameter against the next value queued using expect_*(), if the parameter check fails a test failure is signalled. In addition if check_expected_*() is called and no more parameter values are queued a test failure occurs.

The following test stub illustrates how to do this. First is the the function we call in the test driver:

static void test_driver(void **state)
{
    expect_string(chef_cook, order, "hotdog");
}

Now the chef_cook function can check if the parameter we got passed is the parameter which is expected by the test driver. This can be done the following way:

int chef_cook(const char *order, char **dish_out)
{
    check_expected_ptr(order);
}

For a complete example please take a look here

Typedef Documentation

◆ CheckIntParameterValue

typedef int(* CheckIntParameterValue) (const intmax_t value, const intmax_t check_value_data)

Function that determines whether a function parameter value is correct.

◆ CheckParameterEvent

typedef struct CheckParameterEvent CheckParameterEvent

Event that's called to check a parameter value (old API).

◆ CheckParameterEventData

typedef struct CheckParameterEventData CheckParameterEventData

Event that's called to check a parameter value (new API with CMockaValueData).

◆ CheckParameterValue

typedef int(* CheckParameterValue) (const uintmax_t value, const uintmax_t check_value_data)

Function that determines whether a function parameter value is correct (old API).

◆ CheckParameterValueData

typedef int(* CheckParameterValueData) (const CMockaValueData value, const CMockaValueData check_value_data)

Function that determines whether a function parameter value is correct (new API with CMockaValueData).

◆ CheckUintParameterValue

typedef int(* CheckUintParameterValue) (const uintmax_t value, const uintmax_t check_value_data)

Function that determines whether a function parameter value is correct.

◆ SourceLocation

typedef struct SourceLocation SourceLocation

Location within some source code.

Function Documentation

◆ check_expected()

void check_expected ( # parameter )

Deprecated: Use check_expected_int(), check_expected_uint(), check_expected_float or check_expetecd_double() instead.

◆ check_expected_any()

void check_expected_any ( # parameter )

Check that any parameter value matches the next value in the queue.

This generic parameter checker works with any type including structs passed by value. It passes the address of the parameter, making it suitable for struct validation with custom checkers.

Use this when:

Checking structs passed by value with expect_check_data()
Generic/template code where the type isn't known

For scalar types, prefer the type-specific versions:

check_expected_int() for signed integers
check_expected_uint() for unsigned integers
check_expected_float() for float types
check_expected_double() for double types
check_expected_ptr() for pointers

Parameters

[in] parameter The parameter to check.

See also: check_expected_int(); check_expected_uint(); check_expected_float(); check_expected_double(); check_expected_ptr(); expect_check_data()

◆ check_expected_double()

void check_expected_double ( # parameter )

Determine whether a function parameter is correct.

This ensures the next value queued by one of the expect*_double() macros matches the specified variable.

This function needs to be called in the mock object.

Parameters

[in] parameter The parameter to check.

See also: expect_double; expect_not_double; expect_double_count; expect_not_double_count

◆ check_expected_float()

void check_expected_float ( # parameter )

Determine whether a function parameter is correct.

This ensures the next value queued by one of the expect*_float() macros matches the specified variable.

This function needs to be called in the mock object.

Parameters

[in] parameter The parameter to check.

See also: expect_float; expect_not_float; expect_float_count; expect_not_float_count

◆ check_expected_int()

void check_expected_int ( # parameter )

Determine whether a function parameter is correct.

This ensures the next value queued by one of the expect_int*() macros matches the specified variable.

This function needs to be called in the mock object.

Parameters

[in] parameter The parameter to check.

◆ check_expected_ptr()

void check_expected_ptr ( # parameter )

Determine whether a function parameter is correct.

This ensures the next value queued by one of the expect_*() macros matches the specified variable.

This function needs to be called in the mock object.

Parameters

[in] parameter The pointer to check.

◆ check_expected_uint()

void check_expected_uint ( # parameter )

Determine whether a function parameter is correct.

This ensures the next value queued by one of the expect_uint*() macros matches the specified variable.

This function needs to be called in the mock object.

Parameters

[in] parameter The parameter to check.

◆ expect_any()

void expect_any	(	#	function,
		#	parameter )

Add an event to check if a parameter (of any value) has been passed.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]		function	The function to add the check for.
[in]		parameter	The name of the parameter passed to the function.

See also: check_expected().

◆ expect_any_always()

void expect_any_always	(	#	function,
		#	parameter )

Add an event to always check if a parameter (of any value) has been passed.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]		function	The function to add the check for.
[in]		parameter	The name of the parameter passed to the function.

See also: check_expected().

◆ expect_any_count()

void expect_any_count	(	#	function,
		#	parameter,
		size_t	count )

Add an event to repeatedly check if a parameter (of any value) has been passed.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	count	The count parameter returns the number of times the value should be returned by check_expected(). If count is set to -1 the value will always be returned.

See also: check_expected().

◆ expect_check()

void expect_check	(	function	,
		parameter	,
		CheckParameterValue	check_function,
		const void *	check_data )

Deprecated: Use expect_check_data()

◆ expect_check_count()

void expect_check_count	(	function	,
		parameter	,
		CheckParameterValue	check_function,
		const void *	check_data,
		size_t	count )

Deprecated: Use expect_check_data_count()

◆ expect_check_data()

void expect_check_data	(	function	,
		parameter	,
		CheckParameterValueData	check_function,
		CMockaValueData	check_data )

Add a custom parameter checking function using CMockaValueData (new API).

This is the new API that uses CMockaValueData for type-safe parameter checking. It allows checking of integer, float, double, and pointer values.

Parameters

[in]	function	The function to add a custom parameter checking function for.
[in]	parameter	The parameters passed to the function.
[in]	check_function	The check function to call (CheckParameterValueData).
[in]	check_data	The data to pass to the check function (CMockaValueData).

Checker Function Interface

The checker function must have the following signature:

int checker_function(CMockaValueData value, CMockaValueData check_data);

CMockaValueData

Definition cmocka.h:6338

Parameters

value: The actual parameter value passed to the mocked function. This is provided via check_expected(), check_expected_int(), check_expected_uint(), check_expected_float(), or check_expected_double() in the mocked function.
check_data: The expected data that was passed to expect_check_data(). This contains the value you want to compare against.

Return Value

The checker function should return:

Non-zero (typically 1 or true) if the check succeeds
Zero (0 or false) if the check fails

When the checker returns zero, cmocka will fail the test with an appropriate error message.

Accessing Values in CMockaValueData

The CMockaValueData union contains the following fields:

int_val: For signed integer types (intmax_t)
uint_val: For unsigned integer types (uintmax_t)
float_val: For single-precision floating-point types (float)
real_val: For double-precision floating-point types (double)
ptr: For pointer types (const void *)

Usage Notes

Calling will_return() in the checker: You can call will_return() or other cmocka setup functions within your checker function to set up return values dynamically based on the parameter being checked. This is useful when the return value depends on the input parameter.
Checking multiple parameters: To check all parameters of a function at once, you can pass a pointer to a struct containing all parameter values as the check_data. Your checker function can then validate all fields in a single call. See example below.
Memory allocation for check_data: If you allocate memory for the check_data parameter (e.g., for a struct), you are responsible for managing its lifetime. The checker function receives the data by value, so if you pass a pointer in check_data.ptr, ensure it remains valid until the checker is called. Note that cmocka does not free this memory automatically.

// Example: Custom range checker
typedef struct {
    int min;
    int max;
} range_data;
 
int check_in_custom_range(CMockaValueData value, CMockaValueData check_data)
{
    range_data *range = (range_data *)check_data.ptr;
    int val = value.int_val;
 
    // Return 1 (true) if in range, 0 (false) otherwise
    return (val >= range->min && val <= range->max);
}
 
// In your test:
void test_custom_check(void **state)
{
    range_data range = {10, 20};
    expect_check_data(my_function, param,
                      check_in_custom_range,
                      cast_ptr_to_cmocka_value(&range));
    my_function(15);  // This will pass
}
 
// The mocked function:
void my_function(int param)
{
    check_expected_int(param);  // Triggers the checker
}

// Example: Checker that also sets return values
int check_and_setup_return(CMockaValueData value, CMockaValueData check_data)
{
    int expected = check_data.int_val;
    int actual = value.int_val;
 
    if (actual == expected) {
        // Set up return value dynamically based on the parameter
        will_return_int(some_other_function, actual * 2);
        return 1;  // Success
    }
    return 0;  // Failure
}

// Example: Checking multiple parameters at once
typedef struct {
    int expected_a;
    int expected_b;
    const char *expected_str;
} multi_param_check;
 
int check_multiple_params(CMockaValueData value, CMockaValueData check_data)
{
    multi_param_check *expected = (multi_param_check *)check_data.ptr;
    multi_param_check *actual = (multi_param_check *)value.ptr;
 
    return (actual->expected_a == expected->expected_a &&
            actual->expected_b == expected->expected_b &&
            strcmp(actual->expected_str, expected->expected_str) == 0);
}
 
// In your test:
void test_multi_param(void **state)
{
    multi_param_check expected = {42, 100, "test"};
    multi_param_check actual = {42, 100, "test"};
 
    expect_check_data(my_function, params,
                     check_multiple_params,
                     cast_ptr_to_cmocka_value(&expected));
 
    // In the mocked function, you would pack all params into a struct
    // and call check_expected_ptr(params)
}

See also: check_expected_int(); check_expected_uint(); check_expected_float(); check_expected_double(); check_expected_ptr(); expect_check_data_count()

◆ expect_check_data_count()

void expect_check_data_count	(	function	,
		parameter	,
		CheckParameterValueData	check_function,
		CMockaValueData	check_data,
		size_t	count )

Add a custom parameter checking function using CMockaValueData with count (new API).

This is the new API that uses CMockaValueData for type-safe parameter checking. This version allows you to specify how many times the check should be performed.

Parameters

[in]	function	The function to add a custom parameter checking function for.
[in]	parameter	The parameters passed to the function.
[in]	check_function	The check function to call (CheckParameterValueData).
[in]	check_data	The data to pass to the check function (CMockaValueData).
[in]	count	The number of times this check should be called. A specific positive number: The check will be performed exactly that many times. EXPECT_ALWAYS (-1): The check will always be performed and must be called at least once. The test will fail if not called. EXPECT_MAYBE (-2): The check will always be performed but is not required to be called. The test will not fail if the checker is never invoked.

See expect_check_data() for detailed documentation on the checker function interface, usage notes, and examples.

// Example: Check a parameter exactly 3 times
expect_check_data_count(my_function, param,
                       my_checker,
                       assign_int_to_cmocka_value(42),
                       3);
my_function(42);
my_function(42);
my_function(42);

// Example: Always check (must be called at least once)
expect_check_data_count(my_function, param,
                       my_checker,
                       assign_int_to_cmocka_value(42),
                       EXPECT_ALWAYS);
my_function(42);
my_function(42);
// Can call any number of times, but at least once

// Example: Optional check (may or may not be called)
expect_check_data_count(my_function, param,
                       my_checker,
                       assign_int_to_cmocka_value(42),
                       EXPECT_MAYBE);
// my_function may or may not be called - test won't fail either way

See also: expect_check_data()

◆ expect_double()

void expect_double	(	#	function,
		#	parameter,
		double	value,
		double	epsilon )

Add an event to check if a parameter is the given double precision floating point value.

The event is triggered by calling check_expected_double() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	value	The value to check.
[in]	epsilon	The epsilon used as margin for double comparison.

See also: check_expected_double()

◆ expect_double_count()

void expect_double_count	(	#	function,
		double	value,
		double	epsilon,
		size_t	count )

Add an event to repeatedly check if a parameter is the given double precision floating point value.

The event is triggered by calling check_expected_double() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	value	The value to check.
[in]	epsilon	The epsilon used as margin for double comparison.
[in]	count	The count parameter returns the number of times the value should be returned by check_expected(). If count is set to -1 the value will always be returned.

See also: check_expected_double().

◆ expect_float()

void expect_float	(	#	function,
		#	parameter,
		double	value,
		double	epsilon )

Add an event to check if a parameter is the given floating point value.

The event is triggered by calling check_expected_float() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	value	The value to check.
[in]	epsilon	The epsilon used as margin for float comparison.

See also: check_expected_float(); expect_string(); expect_memory(); expect_any()

◆ expect_float_count()

void expect_float_count	(	#	function,
		#	parameter,
		double	value,
		double	epsilon,
		size_t	count )

Add an event to repeatedly check if a parameter is the given floating point value.

The event is triggered by calling check_expected_float() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	value	The value to check.
[in]	epsilon	The epsilon used as margin for float comparison.
[in]	count	The count parameter returns the number of times the value should be returned by check_expected(). If count is set to -1 the value will always be returned.

See also: check_expected_float().; expect_not_string(); expect_not_memory()

◆ expect_float_in_range()

void expect_float_in_range	(	#	function,
		#	parameter,
		double	minimum,
		double	maximum,
		double	epsilon )

Add an event to check a parameter is inside a numerical range. The check would succeed if minimum <= value <= maximum.

The event is triggered by calling check_expected_float() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	minimum	The lower boundary of the interval to check against.
[in]	maximum	The upper boundary of the interval to check against.
[in]	epsilon	The epsilon used as margin for float comparison.

See also: check_expected_float().

◆ expect_float_in_range_count()

void expect_float_in_range_count	(	#	function,
		#	parameter,
		double	minimum,
		double	maximum,
		double	epsilon,
		size_t	count )

Add an event to repeatedly check a parameter is inside a numerical range. The check would succeed if minimum <= value <= maximum.

The event is triggered by calling check_expected_float() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	minimum	The lower boundary of the interval to check against.
[in]	maximum	The upper boundary of the interval to check against.
[in]	epsilon	The epsilon used as margin for float comparison.
[in]	count	The count parameter returns the number of times the value should be returned by check_expected(). If count is set to -1 the value will always be returned.

See also: check_expected_float()

◆ expect_float_in_set()

void expect_float_in_set	(	#	function,
		#	parameter,
		double	value_array[],
		double	epsilon )

Add an event to check if the float parameter value is part of the provided array.

The event is triggered by calling check_expected_float() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	epsilon	The epsilon used as margin for float comparison.
[in]	value_array[]	The array to check for the value.

See also: check_expected_float().

◆ expect_float_in_set_count()

void expect_float_in_set_count	(	#	function,
		#	parameter,
		double	value_array[],
		double	epsilon,
		size_t	count )

Add an event to check if the float parameter value is part of the provided integer array.

The event is triggered by calling check_expected_float() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	value_array[]	The array to check for the value.
[in]	epsilon	The epsilon used as margin for float comparison.
[in]	count	The count parameter returns the number of times the value should be returned by check_expected(). If count is set to -1 the value will always be returned.

See also: check_expected_float().

◆ expect_float_not_in_range()

void expect_float_not_in_range	(	#	function,
		#	parameter,
		double	minimum,
		double	maximum,
		double	epsilon )

Add an event to check a parameter is outside a numerical range. The check would succeed if minimum > value > maximum.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	minimum	The lower boundary of the interval to check against.
[in]	maximum	The upper boundary of the interval to check against.
[in]	epsilon	The epsilon used as margin for float comparison.

See also: check_expected().

◆ expect_float_not_in_range_count()

void expect_float_not_in_range_count	(	#	function,
		#	parameter,
		double	minimum,
		double	maximum,
		double	epsilon,
		size_t	count )

Add an event to repeatedly check a parameter is outside a numerical range. The check would succeed if minimum > value > maximum.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	minimum	The lower boundary of the interval to check against.
[in]	maximum	The upper boundary of the interval to check against.
[in]	epsilon	The epsilon used as margin for float comparison.
[in]	count	The count parameter returns the number of times the value should be returned by check_expected(). If count is set to -1 the value will always be returned.

See also: check_expected().

◆ expect_float_not_in_set()

void expect_float_not_in_set	(	#	function,
		#	parameter,
		double	value_array[],
		double	epsilon )

Add an event to check if the float parameter value is not part of the provided array.

The event is triggered by calling check_expected_float() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	epsilon	The epsilon used as margin for float comparison.
[in]	value_array[]	The array to check for the value.

See also: check_expected_float().

◆ expect_float_not_in_set_count()

void expect_float_not_in_set_count	(	#	function,
		#	parameter,
		double	value_array[],
		double	epsilon,
		size_t	count )

Add an event to check if the float parameter value is not part of the provided integer array.

The event is triggered by calling check_expected_float() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	value_array[]	The array to check for the value.
[in]	epsilon	The epsilon used as margin for float comparison.
[in]	count	The count parameter returns the number of times the value should be returned by check_expected(). If count is set to -1 the value will always be returned.

See also: check_expected_float().

◆ expect_in_range()

void expect_in_range	(	#	function,
		#	parameter,
		uintmax_t	minimum,
		uintmax_t	maximum )

Deprecated: Use expect_int_in_range()

◆ expect_in_range_count()

void expect_in_range_count	(	#	function,
		#	parameter,
		uintmax_t	minimum,
		uintmax_t	maximum,
		size_t	count )

Deprecated: Use expect_int_in_range_count()

◆ expect_in_set() [1/2]

void expect_in_set	(	#	function,
		#	parameter,
		intmax_t	value_array[] )

Add an event to check if the parameter value is part of the provided integer array.

Add an event to check if the parameter value is part of the provided unsigned integer array.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	value_array[]	The array to check for the value.

See also: check_expected().

◆ expect_in_set() [2/2]

void expect_in_set	(	#	function,
		#	parameter,
		uintmax_t	value_array[] )

Deprecated: Use expect_int_in_set() or expect_uint_in_set()

◆ expect_in_set_count()

void expect_in_set_count	(	#	function,
		#	parameter,
		uintmax_t	value_array[],
		size_t	count )

Deprecated: Use expect_int_in_set_count() or expect_uint_in_set_count()

◆ expect_int_in_range()

void expect_int_in_range	(	#	function,
		intmax_t	minimum,
		intmax_t	maximum )

Add an event to check an integer parameter is inside a numerical range. The check would succeed if minimum <= value <= maximum.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	minimum	The lower boundary of the interval to check against.
[in]	maximum	The upper boundary of the interval to check against.

See also: check_expected().

◆ expect_int_in_range_count()

void expect_int_in_range_count	(	#	function,
		intmax_t	minimum,
		intmax_t	maximum,
		size_t	count )

Add an event to repeatedly check an integer parameter is inside a numerical range. The check would succeed if minimum <= value <= maximum.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	minimum	The lower boundary of the interval to check against.
[in]	maximum	The upper boundary of the interval to check against.
[in]	count	The count parameter returns the number of times the value should be returned by check_expected(). If count is set to -1 the value will always be returned.

See also: check_expected().

◆ expect_int_in_set_count()

void expect_int_in_set_count	(	#	function,
		#	parameter,
		intmax_t	value_array[],
		size_t	count )

Add an event to check if the parameter value is part of the provided integer array.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	value_array[]	The array to check for the value.
[in]	count	The count parameter returns the number of times the value should be returned by check_expected(). If count is set to -1 the value will always be returned.

See also: check_expected().

◆ expect_int_not_in_range()

void expect_int_not_in_range	(	#	function,
		intmax_t	minimum,
		intmax_t	maximum )

Add an event to check an integer parameter is outside a numerical range. The check would succeed if minimum > value > maximum.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	minimum	The lower boundary of the interval to check against.
[in]	maximum	The upper boundary of the interval to check against.

See also: check_expected().

◆ expect_int_not_in_range_count()

void expect_int_not_in_range_count	(	#	function,
		intmax_t	minimum,
		intmax_t	maximum,
		size_t	count )

Add an event to repeatedly check an integer parameter is outside a numerical range. The check would succeed if minimum > value > maximum.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	minimum	The lower boundary of the interval to check against.
[in]	maximum	The upper boundary of the interval to check against.
[in]	count	The count parameter returns the number of times the value should be returned by check_expected(). If count is set to -1 the value will always be returned.

See also: check_expected().

◆ expect_int_not_in_set()

void expect_int_not_in_set	(	#	function,
		#	parameter,
		intmax_t	value_array[] )

Add an event to check if the integer parameter value is not part of the provided integer array.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	value_array[]	The array to check for the value.

See also: check_expected().

◆ expect_int_not_in_set_count()

void expect_int_not_in_set_count	(	#	function,
		intmax_t	value_array[],
		size_t	count )

Add an event to check if the integer parameter value is not part of the provided integer array.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	value_array[]	The array to check for the value.
[in]	count	The count parameter returns the number of times the value should be returned by check_expected(). If count is set to -1 the value will always be returned.

See also: check_expected().

◆ expect_int_not_value()

void expect_int_not_value	(	#	function,
		#	parameter,
		intmax_t	value )

Add an event to check if a parameter (int) isn't the given value.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	value	The value (intmax_t) to check.

See also: check_expected().

◆ expect_int_not_value_count()

void expect_int_not_value_count	(	#	function,
		intmax_t	value,
		size_t	count )

Add an event to repeatedly check if a parameter (int) isn't the given value.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	value	The value (intmax_t) to check.
[in]	count	The count parameter returns the number of times the value should be returned by check_expected(). If count is set to -1 the value will always be returned.

See also: check_expected().

◆ expect_int_value()

void expect_int_value	(	#	function,
		#	parameter,
		intmax_t	value )

Add an event to check if an integer parameter is the given value.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	value	The value to check.

See also: check_expected().

◆ expect_int_value_count()

void expect_int_value_count	(	#	function,
		intmax_t	value,
		size_t	count )

Add an event to repeatedly check if an integer parameter is the given value.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	value	The value to check.
[in]	count	The count parameter returns the number of times the value should be returned by check_expected(). If count is set to -1 the value will always be returned.

See also: check_expected().

◆ expect_memory()

void expect_memory	(	#	function,
		#	parameter,
		void *	memory,
		size_t	size )

Add an event to check if the parameter does match an area of memory.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	memory	The memory to compare.
[in]	size	The size of the memory to compare.

See also: check_expected().

◆ expect_memory_count()

void expect_memory_count	(	#	function,
		#	parameter,
		void *	memory,
		size_t	size,
		size_t	count )

Add an event to repeatedly check if the parameter does match an area of memory.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	memory	The memory to compare.
[in]	size	The size of the memory to compare.
[in]	count	The count parameter returns the number of times the value should be returned by check_expected(). If count is set to -1 the value will always be returned.

See also: check_expected().

◆ expect_not_double()

void expect_not_double	(	#	function,
		#	parameter,
		double	value,
		double	epsilon )

Add an event to check if a parameter isn't the given double precision floating point value.

The event is triggered by calling check_expected_double() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	value	The value to check.
[in]	epsilon	The epsilon used as margin for double comparison.

See also: check_expected_double()

◆ expect_not_double_count()

void expect_not_double_count	(	#	function,
		double	value,
		double	epsilon,
		size_t	count )

Add an event to repeatedly check if a parameter isn't the double precision floating point value.

The event is triggered by calling check_expected_double() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	value	The value to check.
[in]	epsilon	The epsilon used as margin for double comparison.
[in]	count	The count parameter returns the number of times the value should be returned by check_expected(). If count is set to -1 the value will always be returned.

See also: check_expected_double().

◆ expect_not_float()

void expect_not_float	(	#	function,
		#	parameter,
		double	value,
		double	epsilon )

Add an event to check if a parameter isn't the given floating point value.

The event is triggered by calling check_expected_float() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	value	The value to check.
[in]	epsilon	The epsilon used as margin for float comparison.

See also: check_expected_float(); expect_string(); expect_memory(); expect_any()

◆ expect_not_float_count()

void expect_not_float_count	(	#	function,
		#	parameter,
		double	value,
		double	epsilon,
		size_t	count )

Add an event to repeatedly check if a parameter isn't the floating point value.

The event is triggered by calling check_expected_float() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	value	The value to check.
[in]	epsilon	The epsilon used as margin for float comparison.
[in]	count	The count parameter returns the number of times the value should be returned by check_expected(). If count is set to -1 the value will always be returned.

See also: check_expected_float().; expect_not_string(); expect_not_memory()

◆ expect_not_in_range()

void expect_not_in_range	(	#	function,
		#	parameter,
		uintmax_t	minimum,
		uintmax_t	maximum )

Add an event to check a parameter is outside a numerical range. The check would succeed if minimum > value > maximum.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	minimum	The lower boundary of the interval to check against.
[in]	maximum	The upper boundary of the interval to check against.

See also: check_expected().

◆ expect_not_in_range_count()

void expect_not_in_range_count	(	#	function,
		#	parameter,
		uintmax_t	minimum,
		uintmax_t	maximum,
		size_t	count )

Add an event to repeatedly check a parameter is outside a numerical range. The check would succeed if minimum > value > maximum.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	minimum	The lower boundary of the interval to check against.
[in]	maximum	The upper boundary of the interval to check against.
[in]	count	The count parameter returns the number of times the value should be returned by check_expected(). If count is set to -1 the value will always be returned.

See also: check_expected().

◆ expect_not_in_set()

void expect_not_in_set	(	#	function,
		#	parameter,
		uintmax_t	value_array[] )

Deprecated: Use expect_int_not_in_set() or expect_uint_not_in_set()

◆ expect_not_in_set_count()

void expect_not_in_set_count	(	#	function,
		#	parameter,
		uintmax_t	value_array[],
		size_t	count )

Deprecated: Use expect_int_not_in_set_count() or expect_uint_not_in_set_count()

◆ expect_not_memory()

void expect_not_memory	(	#	function,
		#	parameter,
		void *	memory,
		size_t	size )

Add an event to check if the parameter doesn't match an area of memory.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	memory	The memory to compare.
[in]	size	The size of the memory to compare.

See also: check_expected().

◆ expect_not_memory_count()

void expect_not_memory_count	(	#	function,
		#	parameter,
		void *	memory,
		size_t	size,
		size_t	count )

Add an event to repeatedly check if the parameter doesn't match an area of memory.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	memory	The memory to compare.
[in]	size	The size of the memory to compare.
[in]	count	The count parameter returns the number of times the value should be returned by check_expected(). If count is set to -1 the value will always be returned.

See also: check_expected().

◆ expect_not_string()

void expect_not_string	(	#	function,
		#	parameter,
		const char *	string )

Add an event to check if the parameter value isn't equal to the provided string.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	string	The string value to compare.

See also: check_expected().

◆ expect_not_string_count()

void expect_not_string_count	(	#	function,
		#	parameter,
		const char *	string,
		size_t	count )

Add an event to check if the parameter value isn't equal to the provided string.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	string	The string value to compare.
[in]	count	The count parameter returns the number of times the value should be returned by check_expected(). If count is set to -1 the value will always be returned.

See also: check_expected().

◆ expect_not_value()

void expect_not_value	(	#	function,
		#	parameter,
		uintmax_t	value )

Deprecated: Use expect_int_not_value() or expect_uint_not_value()

◆ expect_not_value_count()

void expect_not_value_count	(	#	function,
		#	parameter,
		uintmax_t	value,
		size_t	count )

Deprecated: Use expect_int_not_value_count() or expect_uint_not_value_count()

◆ expect_string()

void expect_string	(	#	function,
		#	parameter,
		const char *	string )

Add an event to check if the parameter value is equal to the provided string.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	string	The string value to compare.

See also: check_expected().

◆ expect_string_count()

void expect_string_count	(	#	function,
		#	parameter,
		const char *	string,
		size_t	count )

Add an event to check if the parameter value is equal to the provided string.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	string	The string value to compare.
[in]	count	The count parameter returns the number of times the value should be returned by check_expected(). If count is set to -1 the value will always be returned.

See also: check_expected().

◆ expect_uint_in_range()

void expect_uint_in_range	(	#	function,
		uintmax_t	minimum,
		uintmax_t	maximum )

Add an event to check an unsigned integer parameter is inside a numerical range. The check would succeed if minimum <= value <= maximum.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	minimum	The lower boundary of the interval to check against.
[in]	maximum	The upper boundary of the interval to check against.

See also: check_expected().

◆ expect_uint_in_range_count()

void expect_uint_in_range_count	(	#	function,
		uintmax_t	minimum,
		uintmax_t	maximum,
		size_t	count )

Add an event to repeatedly check an unsigned integer parameter is inside a numerical range. The check would succeed if minimum <= value <= maximum.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	minimum	The lower boundary of the interval to check against.
[in]	maximum	The upper boundary of the interval to check against.
[in]	count	The count parameter returns the number of times the value should be returned by check_expected(). If count is set to -1 the value will always be returned.

See also: check_expected().

◆ expect_uint_in_set_count()

void expect_uint_in_set_count	(	#	function,
		#	parameter,
		uintmax_t	value_array[],
		size_t	count )

Add an event to check if the parameter value is part of the provided unsigned integer array.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	value_array[]	The array to check for the value.
[in]	count	The count parameter returns the number of times the value should be returned by check_expected(). If count is set to -1 the value will always be returned.

See also: check_expected().

◆ expect_uint_not_in_range()

void expect_uint_not_in_range	(	#	function,
		uintmax_t	minimum,
		uintmax_t	maximum )

Add an event to check an unsigned integer parameter is outside a numerical range. The check would succeed if minimum > value > maximum.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	minimum	The lower boundary of the interval to check against.
[in]	maximum	The upper boundary of the interval to check against.

See also: check_expected().

◆ expect_uint_not_in_range_count()

void expect_uint_not_in_range_count	(	#	function,
		uintmax_t	minimum,
		uintmax_t	maximum,
		size_t	count )

Add an event to repeatedly check an unsigned integer parameter is outside a numerical range. The check would succeed if minimum > value > maximum.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	minimum	The lower boundary of the interval to check against.
[in]	maximum	The upper boundary of the interval to check against.
[in]	count	The count parameter returns the number of times the value should be returned by check_expected(). If count is set to -1 the value will always be returned.

See also: check_expected().

◆ expect_uint_not_in_set()

void expect_uint_not_in_set	(	#	function,
		#	parameter,
		uintmax_t	value_array[] )

Add an event to check if the unsigned integer parameter value is not part of the provided unsigned integer array.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	value_array[]	The array to check for the value.

See also: check_expected().

◆ expect_uint_not_in_set_count()

void expect_uint_not_in_set_count	(	#	function,
		uintmax_t	value_array[],
		size_t	count )

Add an event to check if the unsigned integer parameter value is not part of the provided unsigned integer array.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	value_array[]	The array to check for the value.
[in]	count	The count parameter returns the number of times the value should be returned by check_expected(). If count is set to -1 the value will always be returned.

See also: check_expected().

◆ expect_uint_not_value()

void expect_uint_not_value	(	#	function,
		#	parameter,
		uintmax_t	value )

Add an event to check if a parameter (uint) isn't the given value.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	value	The value (uintmax_t) to check.

See also: check_expected().

◆ expect_uint_not_value_count()

void expect_uint_not_value_count	(	#	function,
		uintmax_t	value,
		size_t	count )

Add an event to repeatedly check if a parameter (uint) isn't the given value.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	value	The value (uintmax_t) to check.
[in]	count	The count parameter returns the number of times the value should be returned by check_expected(). If count is set to -1 the value will always be returned.

See also: check_expected().

◆ expect_uint_value()

void expect_uint_value	(	#	function,
		#	parameter,
		uintmax_t	value )

Add an event to check if an unsigned integer parameter is the given value.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	value	The value to check.

See also: check_expected().

◆ expect_uint_value_count()

void expect_uint_value_count	(	#	function,
		uintmax_t	value,
		size_t	count )

Add an event to repeatedly check if an unsigned integer parameter is the given value.

The event is triggered by calling check_expected() in the mocked function.

Parameters

[in]	function	The function to add the check for.
[in]	parameter	The name of the parameter passed to the function.
[in]	value	The value to check.
[in]	count	The count parameter returns the number of times the value should be returned by check_expected(). If count is set to -1 the value will always be returned.

See also: check_expected().

◆ expect_value()

void expect_value	(	#	function,
		#	parameter,
		uintmax_t	value )

Deprecated: Use expect_int_value() or expect_uint_value()

◆ expect_value_count()

void expect_value_count	(	#	function,
		#	parameter,
		uintmax_t	value,
		size_t	count )

Deprecated: Use expect_int_value_count() or expect_uint_value_count()

Data Structures

Typedefs

Functions

Detailed Description

Typedef Documentation

◆ CheckIntParameterValue

◆ CheckParameterEvent

◆ CheckParameterEventData

◆ CheckParameterValue

◆ CheckParameterValueData

◆ CheckUintParameterValue

◆ SourceLocation

Function Documentation

◆ check_expected()

◆ check_expected_any()

◆ check_expected_double()

◆ check_expected_float()

◆ check_expected_int()

◆ check_expected_ptr()

◆ check_expected_uint()

◆ expect_any()

◆ expect_any_always()

◆ expect_any_count()

◆ expect_check()

◆ expect_check_count()

◆ expect_check_data()

Checker Function Interface

Parameters

Return Value

Accessing Values in CMockaValueData

Usage Notes

◆ expect_check_data_count()

◆ expect_double()

◆ expect_double_count()

◆ expect_float()

◆ expect_float_count()

◆ expect_float_in_range()

◆ expect_float_in_range_count()

◆ expect_float_in_set()

◆ expect_float_in_set_count()

◆ expect_float_not_in_range()

◆ expect_float_not_in_range_count()

◆ expect_float_not_in_set()

◆ expect_float_not_in_set_count()

◆ expect_in_range()

◆ expect_in_range_count()

◆ expect_in_set() [1/2]

◆ expect_in_set() [2/2]

◆ expect_in_set_count()

◆ expect_int_in_range()

◆ expect_int_in_range_count()

◆ expect_int_in_set_count()

◆ expect_int_not_in_range()

◆ expect_int_not_in_range_count()

◆ expect_int_not_in_set()

◆ expect_int_not_in_set_count()

◆ expect_int_not_value()

◆ expect_int_not_value_count()

◆ expect_int_value()

◆ expect_int_value_count()

◆ expect_memory()

◆ expect_memory_count()

◆ expect_not_double()

◆ expect_not_double_count()

◆ expect_not_float()

◆ expect_not_float_count()

◆ expect_not_in_range()

◆ expect_not_in_range_count()

◆ expect_not_in_set()

◆ expect_not_in_set_count()

◆ expect_not_memory()

◆ expect_not_memory_count()

◆ expect_not_string()

◆ expect_not_string_count()

◆ expect_not_value()

◆ expect_not_value_count()

◆ expect_string()

◆ expect_string_count()

◆ expect_uint_in_range()

◆ expect_uint_in_range_count()