/* * Copyright 2008 Google Inc. * Copyright 2014-2022 Andreas Schneider * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef CMOCKA_H_ #define CMOCKA_H_ #ifdef _WIN32 # ifdef _MSC_VER # ifndef CMOCKA_STATIC # ifdef CMOCKA_EXPORTS #define CMOCKA_DLLEXTERN __declspec(dllexport) # else #define CMOCKA_DLLEXTERN __declspec(dllimport) # endif /* CMOCKA_EXPORTS */ # endif /* ndef CMOCKA_STATIC */ #ifndef __func__ #define __func__ __FUNCTION__ #endif /* __func__ */ #ifndef inline #define inline __inline #endif /* inline */ # endif /* _MSC_VER */ #endif /* _WIN32 */ /** * @def CMOCKA_DLLEXTERN * This attribute is needed when dynamically linking to a data object in a DLL. * It's optional (but increases performance) for dynamically linking to * functions in a DLL. * @see * https://github.com/MicrosoftDocs/cpp-docs/blob/bd5a4fbd8ea3dd47b5c7a228c266cdddcaca0e00/docs/cpp/dllexport-dllimport.md */ #ifndef CMOCKA_DLLEXTERN #define CMOCKA_DLLEXTERN // only needed on MSVC compiler when using a DLL #endif /* ndef CMOCKA_DLLEXTERN */ #ifdef __cplusplus extern "C" { #endif /** * @defgroup cmocka 📚 The CMocka API * @brief Unit testing framework for C with support for mock objects. * * cmocka is an elegant unit testing framework for C with support for mock * objects. It only requires the standard C library, works on a lot of platforms * (including embedded) and with different compilers. * * @section cmocka-includes Standard includes * * CMocka requires the include of the following list of standard headers or * their equivalent. * * @code * #include * #include * #include * #include * #include * @endcode * * The header file 'cmocka.h' includes those headers already and in case your * platform does not provide those header files, you must * `#define CMOCKA_NO_STANDARD_INCLUDES` in order to prevent the include of * those files. * * An example of how your code which uses CMocka could look like is given below. * * @code * #include "path/to/cmocka_platform.h" * #define CMOCKA_NO_STANDARD_INCLUDES * #include * // ... your test code goes here ... * @endcode */ #ifndef CMOCKA_NO_STANDARD_INCLUDES #include #include #include #include #include #endif /** * @defgroup cmocka_util 🔨 Utility Macros and Types * @ingroup cmocka * @brief Type conversions, casting helpers, and common data structures. * * Internal utilities and data types used throughout the CMocka API. * * @{ */ /* Perform an signed cast to intmax_t. */ #define cast_to_intmax_type(value) \ ((intmax_t)(value)) /* Perform an unsigned cast to uintmax_t. */ #define cast_to_uintmax_type(value) \ ((uintmax_t)(value)) /* Perform a safe cast from pointer to uintmax_t. */ #define cast_ptr_to_uintmax_type(value) \ ((uintmax_t)(uintptr_t)(value)) /* Perform cast to double. */ #define cast_to_double_type(value) \ ((double)(value)) /* Perform cast to float. */ #define cast_to_float_type(value) \ ((float)(value)) /** * Perform cast to void pointer. * * ISO C forbids conversion between function pointers and void*. This macro * provides a portable way to perform such conversions by casting through * uintptr_t, which is allowed by POSIX and works on all practical platforms. */ #define cast_to_void_pointer(ptr) \ ((void *)(uintptr_t)(ptr)) /** * Perform a cast from an integer to CMockaValueData. * * For backwards compatibility reasons, this explicitly casts to `uintmax_t`. * For most compilers, this will suppress warnings about passing float/intmax_t * to this macro. */ #define cast_int_to_cmocka_value(value) \ (CMockaValueData) \ { \ .uint_val = (uintmax_t)(value) \ } /** Perform a cast from a pointer to CMockaValueData. */ #define cast_ptr_to_cmocka_value(value) \ (CMockaValueData) \ { \ .const_ptr = (value) \ } /** Assign an integer value to CMockaValueData. */ #define assign_int_to_cmocka_value(value) \ (CMockaValueData) \ { \ .int_val = (value) \ } /** Assign an unsigned integer value to CMockaValueData. */ #define assign_uint_to_cmocka_value(value) \ (CMockaValueData) \ { \ .uint_val = (value) \ } /** Assign a floating point value to CMockaValueData. */ #define assign_float_to_cmocka_value(value) \ (CMockaValueData) \ { \ .float_val = ((float)(value)) \ } /** Assign a double floating point value to CMockaValueData. */ #define assign_double_to_cmocka_value(value) \ (CMockaValueData) \ { \ .real_val = ((double)(value)) \ } /* Nested macros are not expanded when they appear along with # or ## */ #define cmocka_tostring(val) #val /** @cond INTERNAL */ /* GCC have printf type attribute check. */ #ifdef __GNUC__ #define CMOCKA_PRINTF_ATTRIBUTE(a,b) \ __attribute__ ((__format__ (__printf__, a, b))) #else #define CMOCKA_PRINTF_ATTRIBUTE(a,b) #endif /* __GNUC__ */ #if defined(CMOCKA_DISABLE_DEPRECATION_WARNINGS) || defined(CMOCKA_DISABLE_DEPRECTATION_WARNINGS) #define CMOCKA_DEPRECATED #define CMOCKA_DEPRECATION_WARNING(msg) #else /* CMOCKA_DISABLE_DEPRECATION_WARNINGS */ /* Deprecation warnings for functions */ #if defined(__GNUC__) #define CMOCKA_DEPRECATED __attribute__ ((deprecated)) #else /* MSVC requires __declspec(deprecated) before the function declaration, * not after it. Since we already use CMOCKA_DEPRECATION_WARNING() in * the macro wrappers, we don't need function-level deprecation for MSVC. */ #define CMOCKA_DEPRECATED #endif /* Deprecation warnings for macros */ #if defined(__GNUC__) || defined(__clang__) /* Use a deprecated typedef in a statement expression to generate warnings * that work even when the header is included as a system header (-isystem). */ #define CMOCKA_DEPRECATION_WARNING(msg) \ __extension__({ \ typedef int cmocka_macro __attribute__((deprecated(msg))); \ cmocka_macro cmocka_deprecated_var __attribute__((unused)) = 0; \ (void)sizeof(cmocka_deprecated_var); \ }); #elif defined(_MSC_VER) #define CMOCKA_DEPRECATION_WARNING(msg) __pragma(message("warning: " msg)) #else #define CMOCKA_DEPRECATION_WARNING(msg) #endif #endif /* CMOCKA_DISABLE_DEPRETATION_WARNINGS */ #if defined(__GNUC__) #define CMOCKA_NORETURN __attribute__ ((noreturn)) #elif defined(_MSC_VER) #define CMOCKA_NORETURN __declspec(noreturn) #else #define CMOCKA_NORETURN #endif /* Function attribute that tells the compiler that we never access the value * of a/b, just the pointer address. * * Without this, newer compilers like GCC-12 will print * `-Wmaybe-uninitialized` warnings. * * See: * https://gcc.gnu.org/onlinedocs/gcc-12.2.0/gcc/Common-Function-Attributes.html#Common-Function-Attributes */ #ifdef __has_attribute #if __has_attribute(access) #define CMOCKA_NO_ACCESS_ATTRIBUTE \ __attribute__((access(none, 1), access(none, 2))) #endif #endif #ifndef CMOCKA_NO_ACCESS_ATTRIBUTE #define CMOCKA_NO_ACCESS_ATTRIBUTE #endif /** @endcond */ /** @} */ /* cmocka_util */ /** * @defgroup cmocka_mock 🎪 Mock Objects * @ingroup cmocka * @brief Simulate objects and control function return values in tests. * * Mock objects are simulated objects that mimic the behavior of * real objects. Instead of calling the real objects, the tested object calls a * mock object that merely asserts that the correct methods were called, with * the expected parameters, in the correct order. * *
    *
  • will_return(function, value) - The will_return() macro * pushes a value onto a queue of mock values. This macro is intended to be * used by the unit test itself, while programming the behaviour of the mocked * object.
    • * *
  • mock() - the mock macro pops a value from a queue of * test values. The user of the mock() macro is the mocked object that uses it * to learn how it should behave.
    • *
* * Because the will_return() and mock() are intended to be used in pairs, the * cmocka library would fail the test if there are more values pushed onto the * queue using will_return() than consumed with mock() and vice-versa. * * The following unit test stub illustrates how would a unit test instruct the * mock object to return a particular value: * * @code * will_return_ptr_type(chef_cook, "hotdog", const char *); * will_return_int(chef_cook, 0); * @endcode * * Now the mock object can check if the parameter it received is the parameter * which is expected by the test driver. This can be done the following way: * * @code * int chef_cook(const char *order, char **dish_out) * { * *dish_out = mock_ptr_type(char *); // "hotdog" * int return_code = mock_int(); // 0 * return return_code; * } * @endcode * * For a complete example please take a look * here. * * @{ */ /** * @brief Return a value indefinitely when used with will_return_count(). * * This constant can be passed as the count parameter to will_return_count() * and related functions to indicate that the specified value should be * returned every time the mocked function is called, without limit. * * @see will_return_count() * @see will_return_int_count() * @see will_return_uint_count() * @see will_return_ptr_count() */ #define WILL_RETURN_ALWAYS -1 /** * @brief Return a value once when used with will_return_count(). * * This constant can be passed as the count parameter to will_return_count() * and related functions to indicate that the specified value should be * returned only the next time the mocked function is called. This is the * default behavior of will_return() and related macros. * * @see will_return_count() * @see will_return() */ #define WILL_RETURN_ONCE -2 /** * @brief Check a parameter every time when used with expect_check_data_count(). * * This constant can be passed as the count parameter to expect_check_data_count() * to indicate that the parameter check should be performed every time the mocked * function is called. The test will fail if the function is never called. * * @see expect_check_data_count() */ #define EXPECT_ALWAYS -1 /** * @brief Optionally check a parameter when used with expect_check_data_count(). * * This constant can be passed as the count parameter to expect_check_data_count() * to indicate that the parameter check is optional. The check will be performed * if the function is called, but the test will not fail if it's never called. * * @see expect_check_data_count() */ #define EXPECT_MAYBE -2 #ifdef DOXYGEN /** * @brief Retrieve a return value of the current function. * * @return The value which was stored to return by this function. * * @see will_return() */ uintmax_t mock(void); #else #define mock() (_mock(__func__, __FILE__, __LINE__, NULL)).uint_val #endif #ifdef DOXYGEN /** * @brief Retrieve a value of the current function and cast it to given type. * * The value would be casted to type internally to avoid having the * caller to do the cast manually. Type safety checks are disabled with that * function. * * @param[in] #type The expected type of the return value * * @return The value which was stored to return by this function casted to the * specified type. * * @code * int param; * * param = mock_type(int); * @endcode * * @see will_return() */ type mock_type(#type); #else #define mock_type(type) ((type) mock()) #endif #ifdef DOXYGEN /** * @brief Check if data is available for the current mock function. * * This function checks if there is data available for the current mock function * which calls has_mock() without consuming it. This is useful when you want to * check if mock data has been set up before calling mock(). * * @return true if mock data is available, false otherwise. * * @code * int example_mock_function(void) * { * if (has_mock()) { * return mock_int(); * } * return default_value; * } * @endcode * * @see mock() * @see mock_int() * @see mock_uint() * @see mock_float() * @see will_return() */ bool has_mock(void); #else #define has_mock() _has_mock(__func__) #endif #ifdef DOXYGEN /** * @brief Retrieve an integer return value of the current function. * * @return The value which was stored to return by this function. * * @code * intmax_t param; * * param = mock_int(); * @endcode * * @see will_return_int() */ intmax_t mock_int(); #else /* TODO: Enable type safety check by passing intmax_t instead of NULL */ #define mock_int() (_mock(__func__, __FILE__, __LINE__, NULL)).int_val #endif #ifdef DOXYGEN /** * @brief Retrieve an unsigned integer return value of the current function. * * @return The value which was stored to return by this function. * * @code * uintmax_t param; * * param = mock_uint(); * @endcode * * @see will_return_uint() */ uintmax_t mock_uint(void); #else #define mock_uint() (_mock(__func__, __FILE__, __LINE__, "uintmax_t")).uint_val #endif #ifdef DOXYGEN /** * @brief Retrieve a float return value of the current function. * * @return The float value which was stored to return by this function. * * @see will_return_float() */ float mock_float(void); #else #define mock_float() (_mock(__func__, __FILE__, __LINE__, NULL)).float_val #endif #ifdef DOXYGEN /** * @brief Retrieve a double precision floating point return value of the * current function. * * @return The double value which was stored to return by this function. * * @see will_return_double() */ double mock_double(void); #else #define mock_double() (_mock(__func__, __FILE__, __LINE__, NULL)).real_val #endif #ifdef DOXYGEN /** * @brief Retrieve a typed return value of the current function. * * The value would be casted to type internally to avoid having the * caller to do the cast manually. This macro does NOT perform type checking. * For type-safe pointer retrieval, use mock_ptr_type_checked() instead. * * @param[in] #type The expected type of the return value * * @return The value which was stored to return by this function. * * @code * char *param; * * param = mock_ptr_type(char *); * @endcode * * @see will_return_ptr() * @see mock_ptr_type_checked() */ type mock_ptr_type(#type); #else #define mock_ptr_type(type) \ ((type)(_mock(__func__, __FILE__, __LINE__, NULL)).ptr) #endif #ifdef DOXYGEN /** * @brief Retrieve a typed return value of the current function with type checking. * * The value would be casted to type internally to avoid having the * caller to do the cast manually. This macro DOES perform type checking * and will fail the test if the type used with will_return_ptr_type() * does not match the type passed to this macro. * * @param[in] #type The expected type of the return value * * @return The value which was stored to return by this function. * * @code * char *param; * * param = mock_ptr_type_checked(char *); * @endcode * * @see will_return_ptr_type() * @see mock_ptr_type() */ type mock_ptr_type_checked(#type); #else #define mock_ptr_type_checked(type) \ ((type)(_mock(__func__, __FILE__, __LINE__, #type)).ptr) #endif #ifdef DOXYGEN /** * @brief Retrieve a named value for the current function. * * @param[in] #name The name under which to look for the value * * @return The value which was stored under the given name for this function. * * @code * int param; * param = (int)mock_parameter(number); * @endcode * * @see mock() * @see mock_parameter_type() * @see mock_parameter_int() * @see mock_parameter_uint() * @see mock_parameter_float() * @see mock_parameter_ptr() * @see mock_parameter_ptr_type() * @see will_return() * @see will_set_parameter() * @see will_set_parameter_int() * @see will_set_parameter_uint() * @see will_set_parameter_float() * @see will_set_parameter_count() * @see will_set_parameter_always() * @see will_set_parameter_maybe() * @see will_set_parameter_ptr() * @see will_set_parameter_ptr_type() * @see will_set_parameter_ptr_count() * @see will_set_parameter_ptr_always() * @see will_set_parameter_ptr_maybe() */ uintmax_t mock_parameter(#name); #else #define mock_parameter(name) \ (_mock_parameter(__func__, #name, __FILE__, __LINE__, NULL)).uint_val #endif #ifdef DOXYGEN /** * @brief Retrieve a named value for the current function and cast it to given type. * * The value would be casted to type internally to avoid having the * caller to do the cast manually. Type safety checks are disabled with that * function. * * @param[in] #name The name under which to look for the value * * @param[in] #type The expected type of the named value * * @return The value which was stored under name for this function. * * @code * int param; * * param = mock_parameter_type(param, int); * @endcode * * @see mock_parameter() * @see will_set_parameter() */ #type mock_parameter_type(#name, #type); #else #define mock_parameter_type(name, type) ((type) mock_parameter(#name)) #endif #ifdef DOXYGEN /** * @brief Retrieve a named integer value for the current function. * * @param[in] #name The name under which to look for the value * * @return The integer value which was stored under the given name for this function. * * @code * intmax_t param; * * param = mock_parameter_int(param); * @endcode * * @see mock_parameter() * @see will_set_parameter() * @see will_set_parameter_int() */ intmax_t mock_parameter_int(#name); #else #define mock_parameter_int(name) \ (_mock_parameter(__func__, #name, __FILE__, __LINE__, "intmax_t")).int_val #endif #ifdef DOXYGEN /** * @brief Retrieve an unsigned integer return value of the current function. * * @param[in] #name The name under which to look for the value * * @return The value which was stored to return by this function. * * @code * uintmax_t param; * * param = mock_parameter_uint(param); * @endcode * * @see mock_parameter() * @see will_set_parameter() * @see will_set_parameter_uint() */ uintmax_t mock_parameter_uint(#name); #else #define mock_parameter_uint(name) \ (_mock_parameter(__func__, #name, __FILE__, __LINE__, "uintmax_t")).uint_val #endif #ifdef DOXYGEN /** * @brief Retrieve a named float value for the current function. * * @param[in] #name The name under which to look for the value * * @return The float value which was stored to return by this function. * * @code * float param; * * param = mock_parameter_float(param); * @endcode * * @see mock_parameter() * @see will_set_parameter() * @see will_set_parameter_float() */ float mock_parameter_float(#name); #else #define mock_parameter_float(name) \ (_mock_parameter(__func__, #name, __FILE__, __LINE__, "float")).float_val #endif #ifdef DOXYGEN /** * @brief Retrieve a named double precision floating point value for the * current function. * * @param[in] #name The name under which to look for the value * * @return The double value which was stored to return by this function. * * @code * double param; * * param = mock_parameter_double(param); * @endcode * * @see mock_parameter() * @see will_set_parameter_double() */ double mock_parameter_double(#name); #else #define mock_parameter_double(name) \ (_mock_parameter(__func__, #name, __FILE__, __LINE__, "double")).real_val #endif #ifdef DOXYGEN /** * @brief Retrieve a named pointer for the current function. * * @param[in] #name The name under which to look for the pointer * * @return The pointer which was stored to return by this function. * * @code * int *result * result = (int*)mock_parameter_ptr(result); * @endcode * * @see mock_parameter() * @see will_set_parameter() * @see will_set_parameter_ptr() */ void *mock_parameter_ptr(#name); #else #define mock_parameter_ptr(name) \ ((_mock_parameter(__func__, #name, __FILE__, __LINE__, NULL)).ptr) #endif #ifdef DOXYGEN /** * @brief Retrieve a named pointer for the current function. * * In addition it checks if if the type specified by the call to * will_return_ptr_type() is the same. * And casts it to that type. * * @param[in] #name The name under which to look for the pointer * * @return The pointer which was stored to return by this function. * * @code * int *result * result = mock_parameter_ptr_type(result, int*); * @endcode * * @see mock_parameter() * @see will_set_parameter() * @see will_set_parameter_ptr_type() */ type mock_parameter_ptr_type(#name, #type); #else #define mock_parameter_ptr_type(name, type) \ ((type)(_mock_parameter(__func__, #name, __FILE__, __LINE__, #type)).ptr) #endif #ifdef DOXYGEN /** * @brief set errno for the current function. * * @code * mock_errno(); * @endcode */ void mock_errno(void); #else #define mock_errno() \ do { \ intmax_t err = (_mock_parameter( \ __func__, \ "/errno", \ __FILE__, \ __LINE__, \ "errno")).int_val; \ if (err != 0) { \ errno = err; \ } \ } while (0) #endif #ifdef DOXYGEN /** * @brief Store a value to be returned by mock() later. * * @param[in] #function The function which should return the given value. * * @param[in] value The value to be returned by mock(). * * @code * int return_integer(void) * { * return (int)mock(); * } * * static void test_integer_return(void **state) * { * will_return(return_integer, 42); * * assert_int_equal(my_function_calling_return_integer(), 42); * } * @endcode * * @see mock() * @see mock_int() * @see mock_uint() * @see mock_float() * @see will_return_int() * @see will_return_uint() * @see will_return_float() * @see will_return_ptr_type() * @see will_return_count() * @see will_return_always() * @see will_return_ptr_always() */ void will_return(#function, uintmax_t value); #else #define will_return(function, value) \ _will_return(cmocka_tostring(function), \ __FILE__, \ __LINE__, \ NULL, \ cast_int_to_cmocka_value(value), \ 1) #endif #ifdef DOXYGEN /** * @brief Store an integer value to be returned by mock() later. * * @param[in] #function The function which should return the given value. * * @param[in] value The value to be returned by mock(). * * @code * int32_t return_int32(void) * { * return (int32_t)mock_int(); * } * * static void test_integer_return(void **state) * { * will_return_int(return_int32, -42); * * assert_int_equal(my_function_calling_return_int32(), -42); * } * @endcode * * @see mock_int() */ void will_return_int(#function, intmax_t value); #else #define will_return_int(function, value) \ _will_return(#function, \ __FILE__, \ __LINE__, \ "intmax_t", \ assign_int_to_cmocka_value(value), \ 1) #endif #ifdef DOXYGEN /** * @brief Store an integer value to be returned a specified number of times by * mock() later. * * @param[in] #function The function which should return the given value. * * @param[in] value The value to be returned by mock(). * * @param[in] count The parameter indicates the number of times the value * should be returned by mock_int(). If count is set to -1, the value will * always be returned but must be returned at least once. If count is set to -2, * the value will always be returned by mock_int(), but is not required to be * returned. * * @code * int32_t return_int32(void) * { * return (int32_t)mock_int(); * } * * static void test_integer_return(void **state) * { * will_return_int_count(return_int32, -42, 3); * * assert_int_equal(my_function_calling_return_int32(), -42); * assert_int_equal(my_function_calling_return_int32(), -42); * assert_int_equal(my_function_calling_return_int32(), -42); * } * @endcode * * @see mock_int() * @see will_return_int() */ void will_return_int_count(#function, intmax_t value, int count); #else #define will_return_int_count(function, value, count) \ _will_return(#function, \ __FILE__, \ __LINE__, \ "intmax_t", \ assign_int_to_cmocka_value(value), \ count) #endif #ifdef DOXYGEN /** * @brief Store a unsigned integer value to be returned by mock() later. * * @param[in] #function The function which should return the given value. * * @param[in] value The value to be returned by mock(). * * @code * uint32_t return_uint32(void) * { * return (uint32_t)mock_uint(); * } * * static void test_integer_return(void **state) * { * will_return_uint(return_uint32, 42); * * assert_uint_equal(my_function_calling_return_uint32(), 42); * } * @endcode * * @see mock_uint() * @see will_return_count() */ void will_return_uint(#function, uintmax_t value); #else #define will_return_uint(function, value) \ _will_return(#function, \ __FILE__, \ __LINE__, \ "uintmax_t", \ assign_uint_to_cmocka_value(value), \ 1) #endif #ifdef DOXYGEN /** * @brief Store an unsigned integer value to be returned a specified number of * times by mock() later. * * @param[in] #function The function which should return the given value. * * @param[in] value The value to be returned by mock(). * * @param[in] count The parameter indicates the number of times the value * should be returned by mock_uint(). If count is set to -1, the value will * always be returned but must be returned at least once. If count is set to -2, * the value will always be returned by mock_uint(), but is not required to be * returned. * * @code * uint32_t return_uint32(void) * { * return (uint32_t)mock_uint(); * } * * static void test_integer_return(void **state) * { * will_return_uint_count(return_uint32, 42, 3); * * assert_uint_equal(my_function_calling_return_uint32(), 42); * assert_uint_equal(my_function_calling_return_uint32(), 42); * assert_uint_equal(my_function_calling_return_uint32(), 42); * } * @endcode * * @see mock_uint() * @see will_return_uint() */ void will_return_uint_count(#function, uintmax_t value, int count); #else #define will_return_uint_count(function, value, count) \ _will_return(#function, \ __FILE__, \ __LINE__, \ "uintmax_t", \ assign_uint_to_cmocka_value(value), \ count) #endif #ifdef DOXYGEN /** * @brief Store a float value to be returned by mock() later. * * @param[in] #function The function which should return the given value. * * @param[in] value The float value to be returned by mock(). * * @code * float return_float(void) * { * return mock_float(); * } * * static void test_float_return(void **state) * { * will_return_float(return_float, 1.0f); * * assert_float_equal(my_function_calling_return_float(), 1.0f, 0.01f); * } * @endcode * * @see mock_float() * @see mock_double() */ void will_return_float(#function, float value); #else #define will_return_float(function, value) \ _will_return(#function, \ __FILE__, \ __LINE__, \ "float", \ assign_float_to_cmocka_value(value), \ 1) #endif #ifdef DOXYGEN /** * @brief Store a float value to be returned a specified number of times by * mock() later. * * @param[in] #function The function which should return the given value. * * @param[in] value The float value to be returned by mock(). * * @param[in] count The parameter indicates the number of times the value * should be returned by mock_float(). If count is set to -1, the value will * always be returned but must be returned at least once. If count is set to -2, * the value will always be returned by mock_float(), but is not required to be * returned. * * @code * float return_float(void) * { * return mock_float(); * } * * static void test_float_return(void **state) * { * will_return_float_count(return_float, 1.0f, 3); * * assert_float_equal(my_function_calling_return_float(), 1.0f, 0.01f); * assert_float_equal(my_function_calling_return_float(), 1.0f, 0.01f); * assert_float_equal(my_function_calling_return_float(), 1.0f, 0.01f); * } * @endcode * * @see mock_float() * @see will_return_float() */ void will_return_float_count(#function, float value, int count); #else #define will_return_float_count(function, value, count) \ _will_return(#function, \ __FILE__, \ __LINE__, \ "float", \ assign_float_to_cmocka_value(value), \ count) #endif #ifdef DOXYGEN /** * @brief Store a double precision floating point value to be returned by * mock() later. * * @param[in] #function The function which should return the given value. * * @param[in] value The double value to be returned by mock(). * * @code * double return_double(void) * { * return mock_double(); * } * * static void test_double_return(void **state) * { * will_return_double(return_double, 2.5); * * assert_double_equal(my_function_calling_return_double(), 2.5, 0.01); * } * @endcode * * @see mock_double() */ void will_return_double(#function, double value); #else #define will_return_double(function, value) \ _will_return(#function, \ __FILE__, \ __LINE__, \ "double", \ assign_double_to_cmocka_value(value), \ 1) #endif #ifdef DOXYGEN /** * @brief Store a double precision floating point value to be returned a * specified number of times by mock() later. * * @param[in] #function The function which should return the given value. * * @param[in] value The double value to be returned by mock(). * * @param[in] count The parameter indicates the number of times the value * should be returned by mock_double(). If count is set to -1, the value will * always be returned but must be returned at least once. If count is set to -2, * the value will always be returned by mock_double(), but is not required to be * returned. * * @code * double return_double(void) * { * return mock_double(); * } * * static void test_double_return(void **state) * { * will_return_double_count(return_double, 2.5, 3); * * assert_double_equal(my_function_calling_return_double(), 2.5, 0.01); * assert_double_equal(my_function_calling_return_double(), 2.5, 0.01); * assert_double_equal(my_function_calling_return_double(), 2.5, 0.01); * } * @endcode * * @see mock_double() * @see will_return_double() */ void will_return_double_count(#function, double value, int count); #else #define will_return_double_count(function, value, count) \ _will_return(#function, \ __FILE__, \ __LINE__, \ "double", \ assign_double_to_cmocka_value(value), \ count) #endif #ifdef DOXYGEN /** * @brief Store an integer value that will always be returned by mock_int(). * * @param[in] #function The function which should return the given value. * * @param[in] value The value to be returned by mock_int(). * * This is equivalent to: * @code * will_return_int_count(function, value, -1); * @endcode * * @see will_return_int_count() * @see mock_int() */ void will_return_int_always(#function, intmax_t value); #else #define will_return_int_always(function, value) \ will_return_int_count(function, (value), WILL_RETURN_ALWAYS) #endif #ifdef DOXYGEN /** * @brief Store an unsigned integer value that will always be returned by * mock_uint(). * * @param[in] #function The function which should return the given value. * * @param[in] value The value to be returned by mock_uint(). * * This is equivalent to: * @code * will_return_uint_count(function, value, -1); * @endcode * * @see will_return_uint_count() * @see mock_uint() */ void will_return_uint_always(#function, uintmax_t value); #else #define will_return_uint_always(function, value) \ will_return_uint_count(function, (value), WILL_RETURN_ALWAYS) #endif #ifdef DOXYGEN /** * @brief Store a float value that will always be returned by mock_float(). * * @param[in] #function The function which should return the given value. * * @param[in] value The value to be returned by mock_float(). * * This is equivalent to: * @code * will_return_float_count(function, value, -1); * @endcode * * @see will_return_float_count() * @see mock_float() */ void will_return_float_always(#function, float value); #else #define will_return_float_always(function, value) \ will_return_float_count(function, (value), WILL_RETURN_ALWAYS) #endif #ifdef DOXYGEN /** * @brief Store a double value that will always be returned by mock_double(). * * @param[in] #function The function which should return the given value. * * @param[in] value The value to be returned by mock_double(). * * This is equivalent to: * @code * will_return_double_count(function, value, -1); * @endcode * * @see will_return_double_count() * @see mock_double() */ void will_return_double_always(#function, double value); #else #define will_return_double_always(function, value) \ will_return_double_count(function, (value), WILL_RETURN_ALWAYS) #endif #ifdef DOXYGEN /** * @deprecated Use will_return_int_count() or will_return_uint_count() */ void will_return_count(#function, uintmax_t value, int count); #else #define will_return_count(function, value, count) \ do { \ CMOCKA_DEPRECATION_WARNING( \ "will_return_count: use will_return_int_count or " \ "will_return_uint_count instead") \ _will_return(cmocka_tostring(function), \ __FILE__, \ __LINE__, \ NULL, \ cast_int_to_cmocka_value(value), \ count); \ } while (0) #endif #ifdef DOXYGEN /** * @deprecated Use will_return_int_always() or will_return_uint_always() */ void will_return_always(#function, uintmax_t value); #else #define will_return_always(function, value) \ do { \ CMOCKA_DEPRECATION_WARNING( \ "will_return_always: use will_return_int_always or " \ "will_return_uint_always instead") \ will_return_count(function, (value), WILL_RETURN_ALWAYS); \ } while (0) #endif #ifdef DOXYGEN /** * @brief Store an integer value that may always be returned by mock_int(). * * This stores a value which will always be returned by mock_int() but is not * required to be returned by at least one call to mock_int(). Therefore, * in contrast to will_return_int_always() which causes a test failure if it * is not returned at least once, will_return_int_maybe() will never cause a * test to fail if its value is not returned. * * @param[in] #function The function which should return the given value. * * @param[in] value The value to be returned by mock_int(). * * This is equivalent to: * @code * will_return_int_count(function, value, -2); * @endcode * * @see will_return_int_count() * @see mock_int() */ void will_return_int_maybe(#function, intmax_t value); #else #define will_return_int_maybe(function, value) \ will_return_int_count(function, (value), WILL_RETURN_ONCE) #endif #ifdef DOXYGEN /** * @brief Store an unsigned integer value that may always be returned by * mock_uint(). * * This stores a value which will always be returned by mock_uint() but is not * required to be returned by at least one call to mock_uint(). Therefore, * in contrast to will_return_uint_always() which causes a test failure if it * is not returned at least once, will_return_uint_maybe() will never cause a * test to fail if its value is not returned. * * @param[in] #function The function which should return the given value. * * @param[in] value The value to be returned by mock_uint(). * * This is equivalent to: * @code * will_return_uint_count(function, value, -2); * @endcode * * @see will_return_uint_count() * @see mock_uint() */ void will_return_uint_maybe(#function, uintmax_t value); #else #define will_return_uint_maybe(function, value) \ will_return_uint_count(function, (value), WILL_RETURN_ONCE) #endif #ifdef DOXYGEN /** * @brief Store a float value that may always be returned by mock_float(). * * This stores a value which will always be returned by mock_float() but is not * required to be returned by at least one call to mock_float(). Therefore, * in contrast to will_return_float_always() which causes a test failure if it * is not returned at least once, will_return_float_maybe() will never cause a * test to fail if its value is not returned. * * @param[in] #function The function which should return the given value. * * @param[in] value The value to be returned by mock_float(). * * This is equivalent to: * @code * will_return_float_count(function, value, -2); * @endcode * * @see will_return_float_count() * @see mock_float() */ void will_return_float_maybe(#function, float value); #else #define will_return_float_maybe(function, value) \ will_return_float_count(function, (value), WILL_RETURN_ONCE) #endif #ifdef DOXYGEN /** * @brief Store a double value that may always be returned by mock_double(). * * This stores a value which will always be returned by mock_double() but is not * required to be returned by at least one call to mock_double(). Therefore, * in contrast to will_return_double_always() which causes a test failure if it * is not returned at least once, will_return_double_maybe() will never cause a * test to fail if its value is not returned. * * @param[in] #function The function which should return the given value. * * @param[in] value The value to be returned by mock_double(). * * This is equivalent to: * @code * will_return_double_count(function, value, -2); * @endcode * * @see will_return_double_count() * @see mock_double() */ void will_return_double_maybe(#function, double value); #else #define will_return_double_maybe(function, value) \ will_return_double_count(function, (value), WILL_RETURN_ONCE) #endif #ifdef DOXYGEN /** * @deprecated Use will_return_int_maybe() or will_return_uint_maybe() */ void will_return_maybe(#function, uintmax_t value); #else #define will_return_maybe(function, value) \ do { \ CMOCKA_DEPRECATION_WARNING( \ "will_return_maybe: use will_return_int_maybe or " \ "will_return_uint_maybe instead") \ will_return_count(function, (value), WILL_RETURN_ONCE); \ } while (0) #endif #ifdef DOXYGEN /** * @brief Store a pointer value to be returned by mock_ptr_type() later. * * @param[in] #function The function which should return the given value. * * @param[in] value The value to be returned by mock_ptr_type(). * * @code * const char * return_pointer(void) * { * return mock_ptr_type(const char *); * } * * static void test_pointer_return(void **state) * { * will_return_ptr_type(return_pointer, "hello world", const char *); * * assert_string_equal(my_func_calling_return_pointer(), "hello world"); * } * @endcode * * @see mock_ptr_type() * @see will_return_ptr_count() */ void will_return_ptr(#function, void *value); #else #define will_return_ptr(function, value) \ _will_return(#function, \ __FILE__, \ __LINE__, \ NULL, \ cast_ptr_to_cmocka_value(value), \ 1) #endif #ifdef DOXYGEN /** * @brief Store a pointer value to be returned by mock_ptr_type_checked() later. * * This will also check that the type matches and if not will fail(). The type * checking only works when used in conjunction with mock_ptr_type_checked(). * If you use mock_ptr_type() to retrieve the value, no type checking will occur. * * @param[in] #function The function which should return the given value. * * @param[in] value The value to be returned by mock_ptr_type_checked(). * * @param[in] #type The type of the pointer. * @code * const char *return_pointer(void) * { * return mock_ptr_type_checked(const char *); * } * * static void test_pointer_return(void **state) * { * will_return_ptr_type(return_pointer, "hello world", const char *); * * assert_string_equal(my_func_calling_return_pointer(), "hello world"); * } * @endcode * * @see mock_ptr_type_checked() */ void will_return_ptr_type(#function, void *value, type); #else #define will_return_ptr_type(function, value, type) \ _will_return(#function, \ __FILE__, \ __LINE__, \ #type, \ cast_ptr_to_cmocka_value(value), \ 1) #endif #ifdef DOXYGEN /** * @brief Store a pointer value to be returned by mock_ptr_type() later. * * @param[in] #function The function which should return the given value. * * @param[in] value The value to be returned by mock_ptr_type(). * * @param[in] count The parameter indicates the number of times the value should * be returned by mock(). If count is set to -1, the value * will always be returned but must be returned at least once. * If count is set to -2, the value will always be returned * by mock(), but is not required to be returned. * * @see mock_ptr_type() */ void will_return_ptr_count(#function, void *value, int count); #else #define will_return_ptr_count(function, value, count) \ _will_return(#function, \ __FILE__, \ __LINE__, \ NULL, \ cast_ptr_to_cmocka_value(value), \ count) #endif #ifdef DOXYGEN /** * @brief Store a value that will be always returned by mock_ptr_type(). * * @param[in] #function The function which should return the given value. * * @param[in] #value The value to be returned by mock_ptr_type(). * * This is equivalent to: * @code * will_return_ptr_count(function, value, -1); * @endcode * * @see will_return_ptr_count() * @see mock_ptr_type() */ void will_return_ptr_always(#function, void *value); #else #define will_return_ptr_always(function, value) \ will_return_ptr_count(function, (value), WILL_RETURN_ALWAYS) #endif #ifdef DOXYGEN /** * @brief Store a value that may be always returned by mock_ptr_type(). * * This stores a value which will always be returned by mock_ptr_type() but is * not required to be returned by at least one call to mock_ptr_type(). * Therefore, in contrast to will_return_ptr_always() which causes a test * failure if it is not returned at least once, will_return_ptr_maybe() will * never cause a test to fail if its value is not returned. * * @param[in] #function The function which should return the given value. * * @param[in] #value The value to be returned by mock_ptr_type(). * * This is equivalent to: * @code * will_return_ptr_count(function, value, -2); * @endcode * * @see will_return_ptr_count() * @see mock_ptr_type() */ void will_return_ptr_maybe(#function, void *value); #else #define will_return_ptr_maybe(function, value) \ will_return_ptr_count(function, (value), WILL_RETURN_ONCE) #endif #ifdef DOXYGEN /** * @brief Store a named value to be returned by mock_parameter() later. * * @param[in] #function The function in which the given value should be return. * * @param[in] #name The name under which the given value should be returned. * * @param[in] value The value to be returned by mock_parameter(). * * @code * void return_integer(int *result) * { * *result = (int)mock_parameter(result); * } * * static void test_integer_return(void **state) * { * will_set_parameter(return_integer, result, 42); * * int retVal = 0; * my_function_calling_return_integer(&retVal); * assert_int_equal(result, 42); * } * @endcode * * @see mock_parameter() * @see mock_parameter() * @see mock_parameter_int() * @see mock_parameter_uint() * @see mock_parameter_float() * @see mock_parameter_ptr() * @see mock_parameter_ptr_type() * @see will_set_parameter_int() * @see will_set_parameter_uint() * @see will_set_parameter_float() * @see will_set_parameter_ptr() * @see will_set_parameter_ptr_type() * @see will_set_parameter_count() * @see will_set_parameter_always() * @see will_set_parameter_maybe() * @see will_set_parameter_ptr_count() * @see will_set_parameter_ptr_always() * @see will_set_parameter_ptr_maybe() */ void will_set_parameter(#function, #name, uintmax_t value); #else #define will_set_parameter(function, name, value) \ _will_set_parameter(cmocka_tostring(function), \ #name, \ __FILE__, \ __LINE__, \ NULL, \ cast_int_to_cmocka_value(value), \ 1) #endif #ifdef DOXYGEN /** * @brief Store a named integer value to be returned by mock_parameter() later. * * And adds some type checking information to be able to check * with call to mock_parameter_int(). * * @param[in] #function The function in which the given value should be return. * * @param[in] #name The name under which the given value should be returned. * * @param[in] value The value to be returned by mock_parameter(). * * @code * void return_int32(int32_t *result) * { * *result = (int32_t)mock_parameter_int(result); * } * * static void test_integer_return(void **state) * { * will_set_parameter_int(return_int32, result, -42); * int32_t result_param = 0; * return_int32(&result_param); * assert_int_equal(result_param, -42); * } * @endcode * * @see mock_parameter() * @see mock_parameter_int() * @see will_set_parameter() */ void will_set_parameter_int(#function, #name, intmax_t value); #else #define will_set_parameter_int(function, name, value) \ _will_set_parameter(#function, \ #name, \ __FILE__, \ __LINE__, \ "intmax_t", \ assign_int_to_cmocka_value(value), \ 1) #endif #ifdef DOXYGEN /** * @brief Store a named unsigned integer value to be returned by * mock_parameter() later. * * And adds some type checking information to be able to check * with call to mock_parameter_uint(). * * @param[in] #function The function in which the given value should be * return. * * @param[in] #name The name under which the given value should be returned. * * @param[in] value The value to be returned by mock_parameter(). * * @code * void return_uint32(uint32_t *result) * { * *result =(uint32_t)mock_parameter_uint(result); * } * * static void test_integer_return(void **state) * { * will_set_parameter_uint(return_uint32, result, 42); * uint32_t result_param = 0; * return_uint32(&result_param); * assert_uint_equal(result_param, 42); * } * @endcode * * @see mock_parameter() * @see mock_parameter_uint() * @see will_set_parameter() */ void will_set_parameter_uint(#function, #name, uintmax_t value); #else #define will_set_parameter_uint(function, name, value) \ _will_set_parameter(#function, \ #name, \ __FILE__, \ __LINE__, \ "uintmax_t", \ assign_uint_to_cmocka_value(value), \ 1) #endif #ifdef DOXYGEN /** * @brief Store a named float value to be returned by mock_parameter() later. * * And adds some type checking information to be able to check * with call to mock_parameter_float(). * * @param[in] #function The function in which the given value should be * return. * * @param[in] #name The name under which the given value should be returned. * * @param[in] value The float value to be returned by mock_parameter(). * * @code * void return_float(float *result) * { * *result = mock_parameter_float(result); * } * * static void test_float_return(void **state) * { * will_set_parameter_float(return_float, result, 34.7f); * float result_param = NAN; * return_float(&result_param); * assert_float_equal(result_param, 34.7f, 0.01f); * } * @endcode * * @see mock_parameter() * @see mock_parameter_float() * @see will_set_parameter() */ void will_set_parameter_float(#function, #name, float value); #else #define will_set_parameter_float(function, name, value) \ _will_set_parameter(#function, \ #name, \ __FILE__, \ __LINE__, \ "float", \ assign_float_to_cmocka_value(value), \ 1) #endif #ifdef DOXYGEN /** * @brief Store a named double precision floating point value to be returned * by mock_parameter() later. * * And adds some type checking information to be able to check * with call to mock_parameter_double(). * * @param[in] #function The function in which the given value should be * return. * * @param[in] #name The name under which the given value should be returned. * * @param[in] value The double value to be returned by mock_parameter(). * * @code * void return_double(double *result) * { * *result = mock_parameter_double(result); * } * * static void test_double_return(void **state) * { * will_set_parameter_double(return_double, result, 34.7); * double result_param = NAN; * return_double(&result_param); * assert_double_equal(result_param, 34.7, 0.0); * } * @endcode * * @see mock_parameter() * @see mock_parameter_double() * @see will_set_parameter() */ void will_set_parameter_double(#function, #name, double value); #else #define will_set_parameter_double(function, name, value) \ _will_set_parameter(#function, \ #name, \ __FILE__, \ __LINE__, \ "double", \ assign_double_to_cmocka_value(value), \ 1) #endif #ifdef DOXYGEN /** * @brief Store a named integer value to be returned a specified number of times * by mock_parameter_int() later. * * @param[in] #function The function in which the given value should be * return. * * @param[in] #name The name under which the given value should be returned. * * @param[in] value The value to be returned by mock_parameter_int(). * * @param[in] count The parameter indicates the number of times the value * should be returned. If count is set to -1, the value will always be returned * but must be returned at least once. If count is set to -2, the value will * always be returned, but is not required to be returned. * * @see mock_parameter_int() * @see will_set_parameter_int() */ void will_set_parameter_int_count(#function, #name, intmax_t value, int count); #else #define will_set_parameter_int_count(function, name, value, count) \ _will_set_parameter(#function, \ #name, \ __FILE__, \ __LINE__, \ "intmax_t", \ assign_int_to_cmocka_value(value), \ count) #endif #ifdef DOXYGEN /** * @brief Store a named unsigned integer value to be returned a specified * number of times by mock_parameter_uint() later. * * @param[in] #function The function in which the given value should be * return. * * @param[in] #name The name under which the given value should be returned. * * @param[in] value The value to be returned by mock_parameter_uint(). * * @param[in] count The parameter indicates the number of times the value * should be returned. If count is set to -1, the value will always be returned * but must be returned at least once. If count is set to -2, the value will * always be returned, but is not required to be returned. * * @see mock_parameter_uint() * @see will_set_parameter_uint() */ void will_set_parameter_uint_count(#function, #name, uintmax_t value, int count); #else #define will_set_parameter_uint_count(function, name, value, count) \ _will_set_parameter(#function, \ #name, \ __FILE__, \ __LINE__, \ "uintmax_t", \ assign_uint_to_cmocka_value(value), \ count) #endif #ifdef DOXYGEN /** * @brief Store a named float value to be returned a specified number of times * by mock_parameter_float() later. * * @param[in] #function The function in which the given value should be * return. * * @param[in] #name The name under which the given value should be returned. * * @param[in] value The value to be returned by mock_parameter_float(). * * @param[in] count The parameter indicates the number of times the value * should be returned. If count is set to -1, the value will always be returned * but must be returned at least once. If count is set to -2, the value will * always be returned, but is not required to be returned. * * @see mock_parameter_float() * @see will_set_parameter_float() */ void will_set_parameter_float_count(#function, #name, float value, int count); #else #define will_set_parameter_float_count(function, name, value, count) \ _will_set_parameter(#function, \ #name, \ __FILE__, \ __LINE__, \ "float", \ assign_float_to_cmocka_value(value), \ count) #endif #ifdef DOXYGEN /** * @brief Store a named double value to be returned a specified number of times * by mock_parameter_double() later. * * @param[in] #function The function in which the given value should be * return. * * @param[in] #name The name under which the given value should be returned. * * @param[in] value The value to be returned by mock_parameter_double(). * * @param[in] count The parameter indicates the number of times the value * should be returned. If count is set to -1, the value will always be returned * but must be returned at least once. If count is set to -2, the value will * always be returned, but is not required to be returned. * * @see mock_parameter_double() * @see will_set_parameter_double() */ void will_set_parameter_double_count(#function, #name, double value, int count); #else #define will_set_parameter_double_count(function, name, value, count) \ _will_set_parameter(#function, \ #name, \ __FILE__, \ __LINE__, \ "double", \ assign_double_to_cmocka_value(value), \ count) #endif #ifdef DOXYGEN /** * @deprecated Use will_set_parameter_int_count() or * will_set_parameter_uint_count() */ void will_set_parameter_count(#function, #name, uintmax_t value, int count); #else #define will_set_parameter_count(function, name, value, count) \ do { \ CMOCKA_DEPRECATION_WARNING( \ "will_set_parameter_count: use will_set_parameter_int_count or " \ "will_set_parameter_uint_count instead") \ _will_set_parameter(cmocka_tostring(function), \ #name, \ __FILE__, \ __LINE__, \ NULL, \ cast_int_to_cmocka_value(value), \ count); \ } while (0) #endif #ifdef DOXYGEN /** * @brief Store a named integer value that will always be returned by * mock_parameter_int(). * * @param[in] #function The function in which the given value should be * return. * * @param[in] #name The name under which the given value should be returned. * * @param[in] value The value to be returned by mock_parameter_int(). * * This is equivalent to: * @code * will_set_parameter_int_count(function, name, value, -1); * @endcode * * @see mock_parameter_int() * @see will_set_parameter_int_count() */ void will_set_parameter_int_always(#function, #name, intmax_t value); #else #define will_set_parameter_int_always(function, name, value) \ will_set_parameter_int_count(function, name, (value), WILL_RETURN_ALWAYS) #endif #ifdef DOXYGEN /** * @brief Store a named unsigned integer value that will always be returned by * mock_parameter_uint(). * * @param[in] #function The function in which the given value should be * return. * * @param[in] #name The name under which the given value should be returned. * * @param[in] value The value to be returned by mock_parameter_uint(). * * This is equivalent to: * @code * will_set_parameter_uint_count(function, name, value, -1); * @endcode * * @see mock_parameter_uint() * @see will_set_parameter_uint_count() */ void will_set_parameter_uint_always(#function, #name, uintmax_t value); #else #define will_set_parameter_uint_always(function, name, value) \ will_set_parameter_uint_count(function, name, (value), WILL_RETURN_ALWAYS) #endif #ifdef DOXYGEN /** * @brief Store a named float value that will always be returned by * mock_parameter_float(). * * @param[in] #function The function in which the given value should be * return. * * @param[in] #name The name under which the given value should be returned. * * @param[in] value The value to be returned by mock_parameter_float(). * * This is equivalent to: * @code * will_set_parameter_float_count(function, name, value, -1); * @endcode * * @see mock_parameter_float() * @see will_set_parameter_float_count() */ void will_set_parameter_float_always(#function, #name, float value); #else #define will_set_parameter_float_always(function, name, value) \ will_set_parameter_float_count(function, name, (value), WILL_RETURN_ALWAYS) #endif #ifdef DOXYGEN /** * @brief Store a named double value that will always be returned by * mock_parameter_double(). * * @param[in] #function The function in which the given value should be * return. * * @param[in] #name The name under which the given value should be returned. * * @param[in] value The value to be returned by mock_parameter_double(). * * This is equivalent to: * @code * will_set_parameter_double_count(function, name, value, -1); * @endcode * * @see mock_parameter_double() * @see will_set_parameter_double_count() */ void will_set_parameter_double_always(#function, #name, double value); #else #define will_set_parameter_double_always(function, name, value) \ will_set_parameter_double_count(function, name, (value), WILL_RETURN_ALWAYS) #endif #ifdef DOXYGEN /** * @deprecated Use will_set_parameter_int_always() or * will_set_parameter_uint_always() */ void will_set_parameter_always(#function, #name, uintmax_t value); #else #define will_set_parameter_always(function, name, value) \ do { \ CMOCKA_DEPRECATION_WARNING( \ "will_set_parameter_always: use will_set_parameter_int_always or " \ "will_set_parameter_uint_always instead") \ will_set_parameter_count(function, name, (value), WILL_RETURN_ALWAYS); \ } while (0) #endif #ifdef DOXYGEN /** * @brief Store a named integer value that may always be returned by mock_parameter_int(). * * This stores a value which will always be returned by mock_parameter_int() but is not * required to be returned by at least one call to mock_parameter_int(). * * @param[in] #function The function in which the given value should be return. * * @param[in] #name The name under which the given value should be returned. * * @param[in] value The value to be returned by mock_parameter_int(). * * This is equivalent to: * @code * will_set_parameter_int_count(function, name, value, -2); * @endcode * * @see mock_parameter_int() * @see will_set_parameter_int_count() */ void will_set_parameter_int_maybe(#function, #name, intmax_t value); #else #define will_set_parameter_int_maybe(function, name, value) \ will_set_parameter_int_count(function, name, (value), WILL_RETURN_ONCE) #endif #ifdef DOXYGEN /** * @brief Store a named unsigned integer value that may always be returned by mock_parameter_uint(). * * This stores a value which will always be returned by mock_parameter_uint() but is not * required to be returned by at least one call to mock_parameter_uint(). * * @param[in] #function The function in which the given value should be return. * * @param[in] #name The name under which the given value should be returned. * * @param[in] value The value to be returned by mock_parameter_uint(). * * This is equivalent to: * @code * will_set_parameter_uint_count(function, name, value, -2); * @endcode * * @see mock_parameter_uint() * @see will_set_parameter_uint_count() */ void will_set_parameter_uint_maybe(#function, #name, uintmax_t value); #else #define will_set_parameter_uint_maybe(function, name, value) \ will_set_parameter_uint_count(function, name, (value), WILL_RETURN_ONCE) #endif #ifdef DOXYGEN /** * @brief Store a named float value that may always be returned by mock_parameter_float(). * * This stores a value which will always be returned by mock_parameter_float() but is not * required to be returned by at least one call to mock_parameter_float(). * * @param[in] #function The function in which the given value should be return. * * @param[in] #name The name under which the given value should be returned. * * @param[in] value The value to be returned by mock_parameter_float(). * * This is equivalent to: * @code * will_set_parameter_float_count(function, name, value, -2); * @endcode * * @see mock_parameter_float() * @see will_set_parameter_float_count() */ void will_set_parameter_float_maybe(#function, #name, float value); #else #define will_set_parameter_float_maybe(function, name, value) \ will_set_parameter_float_count(function, name, (value), WILL_RETURN_ONCE) #endif #ifdef DOXYGEN /** * @brief Store a named double value that may always be returned by mock_parameter_double(). * * This stores a value which will always be returned by mock_parameter_double() but is not * required to be returned by at least one call to mock_parameter_double(). * * @param[in] #function The function in which the given value should be return. * * @param[in] #name The name under which the given value should be returned. * * @param[in] value The value to be returned by mock_parameter_double(). * * This is equivalent to: * @code * will_set_parameter_double_count(function, name, value, -2); * @endcode * * @see mock_parameter_double() * @see will_set_parameter_double_count() */ void will_set_parameter_double_maybe(#function, #name, double value); #else #define will_set_parameter_double_maybe(function, name, value) \ will_set_parameter_double_count(function, name, (value), WILL_RETURN_ONCE) #endif #ifdef DOXYGEN /** * @deprecated Use will_set_parameter_int_maybe() or * will_set_parameter_uint_maybe() */ void will_set_parameter_maybe(#function, #name, uintmax_t value); #else #define will_set_parameter_maybe(function, name, value) \ do { \ CMOCKA_DEPRECATION_WARNING( \ "will_set_parameter_maybe: use will_set_parameter_int_maybe or " \ "will_set_parameter_uint_maybe instead") \ will_set_parameter_count(function, name, (value), WILL_RETURN_ONCE); \ } while (0) #endif #ifdef DOXYGEN /** * @brief Store a named pointer value to be returned by mock_parameter() later. * * @param[in] #function The function in which the given value should be * return. * * @param[in] #name The name under which the given value should be returned. * * @param[in] value The value to be returned by mock_parameter(). * * @code * void return_pointer(const char **result) * { * *result = (const char *)mock_parameter_ptr(result); * } * static void test_pointer_return(void **state) * { * will_set_parameter_ptr(return_pointer, result, "hello world"); * const char *returned = NULL; * my_func_calling_return_pointer(&returned); * assert_string_equal(returned, "hello world"); * } * @endcode * * @see mock_parameter() * @see mock_parameter_ptr() * @see will_set_parameter() */ void will_set_parameter_ptr(#function, #name, void *value); #else #define will_set_parameter_ptr(function, name, value) \ _will_set_parameter(#function, \ #name, \ __FILE__, \ __LINE__, \ NULL, \ cast_ptr_to_cmocka_value(value), \ 1) #endif #ifdef DOXYGEN /** * @brief Store a named pointer value to be returned by mock_parameter() later. * * This will also check that the type matches and if not will fail(). * * @param[in] #function The function in which the given value should be return. * * @param[in] #name The name under which the given value should be returned. * * @param[in] value The value to be returned by mock_parameter(). * * @param[in] type The type of the pointer. * * @code * void return_pointer(const char **result) * { * *result = mock_parameter_ptr_typed(result, const char*); * } * static void test_pointer_return(void **state) * { * will_set_parameter_ptr_type(return_pointer, result, "hello world", const char*); * const char *returned = NULL; * my_func_calling_return_pointer(&returned); * assert_string_equal(returned, "hello world"); * } * @endcode * * @see mock_parameter() * @see mock_parameter_ptr() * @see mock_parameter_ptr_type() * @see will_set_parameter() * @see will_set_parameter_ptr() */ void will_set_parameter_ptr_type(#function, #name, void *value, #type); #else #define will_set_parameter_ptr_type(function, name, value, type) \ _will_set_parameter(#function, \ #name, \ __FILE__, \ __LINE__, \ #type, \ cast_ptr_to_cmocka_value(value), \ 1) #endif #ifdef DOXYGEN /** * @brief Store a named pointer value to be returned a specified number of times * by mock_parameter_ptr() later. * * @param[in] #function The function in which the given value should be return. * * @param[in] #name The name under which the given value should be returned. * * @param[in] value The value to be returned by mock_parameter_ptr(). * * @param[in] count The parameter indicates the number of times the value should * be returned by mock_parameter_ptr(). If count is set to -1, the value * will always be returned but must be returned at least once. * If count is set to -2, the value will always be returned * by mock_parameter_ptr(), but is not required to be returned. * * @code * void return_pointer(const char **resultA, const char **resultB) * { * *resultA = (const char *)mock_parameter_ptr(result); * *resultB = (const char *)mock_parameter_ptr(result); * } * static void test_pointer_return(void **state) * { * will_set_parameter_ptr_count(return_pointer, result, "hello world", const char*, 2); * const char *returnedA = NULL; * const char *returnedB = NULL; * my_func_calling_return_pointer(&returnedA, &returnedB); * assert_string_equal(returnedA, "hello world"); * assert_string_equal(returnedB, "hello world"); * } * @endcode * * @see mock_parameter() * @see mock_parameter_ptr() * @see will_named_return() * @see will_named_return_ptr() */ void will_set_parameter_ptr_count(#function, #name, void *value, int count); #else #define will_set_parameter_ptr_count(function, name, value, count) \ _will_set_parameter(#function, \ #name, \ __FILE__, \ __LINE__, \ NULL, \ cast_ptr_to_cmocka_value(value), \ count) #endif #ifdef DOXYGEN /** * @brief Store a named pointer value that will be always returned by * mock_parameter_ptr(). * * This stores a value which will always be returned by mock_parameter_ptr() * and is required to be returned by at least one call to mock_parameter_ptr(). * If it is not returned at least once the test will fail. * * @param[in] #function The function in which the given value should be * return. * * @param[in] #name The name under which the given value should be returned. * * @param[in] value The value to be returned by mock_parameter_ptr(). * * This is equivalent to: * @code * will_set_parameter_ptr_count(function, name, value, -1); * @endcode * * @see mock_parameter() * @see mock_parameter_ptr() * @see will_set_parameter() * @see will_set_parameter_ptr() * @see will_set_parameter_ptr_count() */ void will_set_parameter_ptr_always(#function, #name, void *value); #else #define will_set_parameter_ptr_always(function, name, value) \ will_set_parameter_ptr_count(function, name, (value), WILL_RETURN_ALWAYS) #endif #ifdef DOXYGEN /** * @brief Store a named pointer value that may be always returned by * mock_parameter_ptr(). * * This stores a value which will always be returned by mock_parameter_ptr() but * is not required to be returned by at least one call to mock_parameter_ptr(). * Therefore, in contrast to will_set_parameter_ptr_always() which causes a test * failure if it is not returned at least once, will_set_parameter_ptr_maybe() * will never cause a test to fail if its value is not returned. * * @param[in] #function The function in which the given value should be * return. * * @param[in] #name The name under which the given value should be returned. * * @param[in] value The value to be returned by mock_parameter_ptr(). * * This is equivalent to: * @code * will_set_parameter_ptr_count(function, name, value, -2); * @endcode * * @see mock_parameter() * @see mock_parameter_ptr() * @see will_set_parameter() * @see will_set_parameter_ptr() * @see will_set_parameter_ptr_count() */ void will_set_parameter_ptr_maybe(#function, #name, void *value); #else #define will_set_parameter_ptr_maybe(function, name, value) \ will_set_parameter_ptr_count(function, name, (value), WILL_RETURN_ONCE) #endif #ifdef DOXYGEN /** * @brief Store an integer value to set errno to by mock_errno() later. * * @param[in] #function The function in which errno * should be set to the given value. * * @param[in] value The value to set errno to by the call to mock_errno(). * * @code * void sets_errno(void) * { * mock_errno(); * } * * static void test_sets_errno(void **state) * { * will_set_errno(sets_errno, -3); * * assert_int_equal(errno, -3); * } * @endcode * * @see mock_errno() */ void will_set_errno(#function, intmax_t value); #else #define will_set_errno(function, value) \ _will_set_parameter(#function, \ "/errno", \ __FILE__, \ __LINE__, \ "errno", \ assign_int_to_cmocka_value(value), \ 1) #endif #ifdef DOXYGEN /** * @brief Store an integer value to always set errno to by mock_errno(). * * * * @param[in] #function The function in which errno * should be set to the given value. * * @param[in] value The value to set errno to by the call to mock_errno(). * * @param[in] count The count parameter gives the number of times the value * should be validated by check_expected(). If count is set * to @ref EXPECT_ALWAYS the value will always be returned, * and cmocka expects check_expected() to be issued at least * once. If count is set to @ref EXPECT_MAYBE, any number of * calls to check_expected() is accepted, including zero. * * @code * void sets_errno(void) * { * mock_errno(); * } * static void test_sets_errno(void **state) * { * will_set_errno_count(sets_errno, -3, 2); * sets_errno(); * assert_int_equal(errno, -3); * errno = 0; * sets_errno(); * assert_int_equal(errno, -3); * } * @endcode * * @see mock_errno() * @see will_set_errno() * @see will_set_errno_always() * @see will_set_errno_maybe() */ void will_set_errno_count(#function, intmax_t value, size_t count); #else #define will_set_errno_count(function, value, count) \ _will_set_parameter(#function, \ "/errno", \ __FILE__, \ __LINE__, \ "errno", \ assign_int_to_cmocka_value(value), \ (count)) #endif #ifdef DOXYGEN /** * @brief Store an integer value to set errno to by mock_errno() later, * for a specified number of times. * * This stores a value which will errno will always be set to by mock_errno() * but is required to be set least once by a call to mock_errno(). * * @param[in] #function The function in which errno * should be set to the given value. * * @param[in] value The value to set errno to by the call to mock_errno(). * * This is equivalent to: * @code * will_set_parameter_count(function, name, value, -1); * @endcode * * @see mock_errno() * @see will_set_errno() * @see will_set_errno_count() * @see will_set_errno_maybe() */ void will_set_errno_always(#function, intmax_t value); #else #define will_set_errno_always(function, value) \ will_set_errno_count(function, (value), WILL_RETURN_ALWAYS); #endif #ifdef DOXYGEN /** * @brief Store an integer value to set errno to by mock_errno() later, * for a specified number of times. * * This stores a value which will errno will always be set to by mock_errno() * and won't fail if mock_errno() is never called. * * @param[in] #function The function in which errno * should be set to the given value. * * @param[in] value The value to set errno to by the call to mock_errno(). * * This is equivalent to: * @code * will_set_parameter_count(function, name, value, -2); * @endcode * * @see mock_errno() * @see will_set_errno() * @see will_set_errno_count() * @see will_set_errno_always() */ void will_set_errno_maybe(#function, intmax_t value); #else #define will_set_errno_maybe(function, value) \ will_set_errno_count(function, (value), WILL_RETURN_ONCE); #endif /** @} */ /* cmocka_mock */ /** * @defgroup cmocka_param ✅ Checking Parameters * @ingroup cmocka * @brief 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: * * @code * static void test_driver(void **state) * { * expect_string(chef_cook, order, "hotdog"); * } * @endcode * * 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: * * @code * int chef_cook(const char *order, char **dish_out) * { * check_expected_ptr(order); * } * @endcode * * For a complete example please take a look * here * * @{ */ #ifdef DOXYGEN /** * @deprecated Use expect_check_data() */ void expect_check(function, parameter, CheckParameterValue check_function, const void *check_data); #else #define expect_check(function, parameter, check_function, check_data) \ do { \ CMOCKA_DEPRECATION_WARNING( \ "expect_check: use expect_check_data instead") \ _expect_check(cmocka_tostring(function), \ cmocka_tostring(parameter), \ __FILE__, \ __LINE__, \ check_function, \ cast_to_uintmax_type(check_data), \ NULL, \ 1); \ } while (0) #endif #ifdef DOXYGEN /** * @deprecated Use expect_check_data_count() */ void expect_check_count(function, parameter, CheckParameterValue check_function, const void *check_data, size_t count); #else #define expect_check_count( \ function, parameter, check_function, check_data, count) \ do { \ CMOCKA_DEPRECATION_WARNING( \ "expect_check_count: use expect_check_data_count instead") \ _expect_check(cmocka_tostring(function), \ cmocka_tostring(parameter), \ __FILE__, \ __LINE__, \ check_function, \ cast_to_uintmax_type(check_data), \ NULL, \ count); \ } while (0) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add a custom parameter checking * function for. * * @param[in] #parameter The parameters passed to the function. * * @param[in] #check_function The check function to call (CheckParameterValueData). * * @param[in] check_data The data to pass to the check function (CMockaValueData). * * ## Checker Function Interface * * The checker function must have the following signature: * @code * int checker_function(CMockaValueData value, CMockaValueData check_data); * @endcode * * ### 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 * * 1. **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. * * 2. **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. * * 3. **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. * * @code * // 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 * } * @endcode * * @code * // 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 * } * @endcode * * @code * // 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) * } * @endcode * * @see check_expected_int() * @see check_expected_uint() * @see check_expected_float() * @see check_expected_double() * @see check_expected_ptr() * @see expect_check_data_count() */ void expect_check_data(function, parameter, CheckParameterValueData check_function, CMockaValueData check_data); #else #define expect_check_data(function, parameter, check_function, check_data) \ _expect_check_data(cmocka_tostring(function), \ cmocka_tostring(parameter), \ __FILE__, \ __LINE__, \ check_function, \ check_data, \ NULL, \ 1) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add a custom parameter checking * function for. * * @param[in] #parameter The parameters passed to the function. * * @param[in] #check_function The check function to call * (CheckParameterValueData). * * @param[in] check_data The data to pass to the check function (CMockaValueData). * * @param[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. * * @code * // 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); * @endcode * * @code * // 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 * @endcode * * @code * // 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 * @endcode * * @see expect_check_data() */ void expect_check_data_count(function, parameter, CheckParameterValueData check_function, CMockaValueData check_data, size_t count); #else #define expect_check_data_count(function, \ parameter, \ check_function, \ check_data, \ count) \ _expect_check_data(cmocka_tostring(function), \ cmocka_tostring(parameter), \ __FILE__, \ __LINE__, \ check_function, \ check_data, \ NULL, \ count) #endif #ifdef DOXYGEN /** * @deprecated Use expect_int_in_set() or expect_uint_in_set() */ void expect_in_set(#function, #parameter, uintmax_t value_array[]); #else #define expect_in_set(function, parameter, value_array) \ do { \ CMOCKA_DEPRECATION_WARNING("expect_in_set: use expect_int_in_set or " \ "expect_uint_in_set instead") \ expect_in_set_count(function, parameter, value_array, 1); \ } while (0) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] value_array[] The array to check for the value. * * @see check_expected(). */ void expect_in_set(#function, #parameter, intmax_t value_array[]); #else #define expect_int_in_set(function, parameter, value_array) \ expect_int_in_set_count(function, parameter, value_array, 1) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] value_array[] The array to check for the value. * * @see check_expected(). */ void expect_in_set(#function, #parameter, intmax_t value_array[]); #else #define expect_uint_in_set(function, parameter, value_array) \ expect_uint_in_set_count(function, parameter, value_array, 1) #endif #ifdef DOXYGEN /** * @deprecated Use expect_int_in_set_count() or expect_uint_in_set_count() */ void expect_in_set_count(#function, #parameter, uintmax_t value_array[], size_t count); #else #define expect_in_set_count(function, parameter, value_array, count) \ do { \ CMOCKA_DEPRECATION_WARNING( \ "expect_in_set_count: use expect_int_in_set_count or " \ "expect_uint_in_set_count instead") \ _expect_uint_in_set(cmocka_tostring(function), \ cmocka_tostring(parameter), \ __FILE__, \ __LINE__, \ value_array, \ sizeof(value_array) / sizeof((value_array)[0]), \ count); \ } while (0) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] value_array[] The array to check for the value. * * @param[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 check_expected(). */ void expect_int_in_set_count(#function, #parameter, intmax_t value_array[], size_t count); #else #define expect_int_in_set_count(function, parameter, value_array, count) \ _expect_int_in_set(cmocka_tostring(function), \ cmocka_tostring(parameter), \ __FILE__, \ __LINE__, \ value_array, \ sizeof(value_array) / sizeof((value_array)[0]), \ count) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] value_array[] The array to check for the value. * * @param[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 check_expected(). */ void expect_uint_in_set_count(#function, #parameter, uintmax_t value_array[], size_t count); #else #define expect_uint_in_set_count(function, parameter, value_array, count) \ _expect_uint_in_set(cmocka_tostring(function), \ cmocka_tostring(parameter), \ __FILE__, \ __LINE__, \ value_array, \ sizeof(value_array) / sizeof((value_array)[0]), \ count) #endif #ifdef DOXYGEN /** * @deprecated Use expect_int_not_in_set() or expect_uint_not_in_set() */ void expect_not_in_set(#function, #parameter, uintmax_t value_array[]); #else #define expect_not_in_set(function, parameter, value_array) \ do { \ CMOCKA_DEPRECATION_WARNING( \ "expect_not_in_set: use expect_int_not_in_set or " \ "expect_uint_not_in_set instead") \ expect_not_in_set_count(function, parameter, value_array, 1); \ } while (0) #endif #ifdef DOXYGEN /** * @deprecated Use expect_int_not_in_set_count() or expect_uint_not_in_set_count() */ void expect_not_in_set_count(#function, #parameter, uintmax_t value_array[], size_t count); #else #define expect_not_in_set_count(function, parameter, value_array, count) \ do { \ CMOCKA_DEPRECATION_WARNING( \ "expect_not_in_set_count: use expect_int_not_in_set_count or " \ "expect_uint_not_in_set_count instead") \ _expect_not_in_set(cmocka_tostring(function), \ cmocka_tostring(parameter), \ __FILE__, \ __LINE__, \ value_array, \ sizeof(value_array) / sizeof((value_array)[0]), \ count); \ } while (0) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] value_array[] The array to check for the value. * * @see check_expected(). */ void expect_int_not_in_set(#function, #parameter, intmax_t value_array[]); #else #define expect_int_not_in_set(function, parameter, value_array) \ expect_int_not_in_set_count(function, parameter, value_array, 1) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] value_array[] The array to check for the value. * * @param[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 check_expected(). */ void expect_int_not_in_set_count(#function, #parameter, intmax_t value_array[], size_t count); #else #define expect_int_not_in_set_count(function, parameter, value_array, count) \ _expect_int_not_in_set(cmocka_tostring(function), \ cmocka_tostring(parameter), \ __FILE__, \ __LINE__, \ value_array, \ sizeof(value_array) / sizeof((value_array)[0]), \ count) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] value_array[] The array to check for the value. * * @see check_expected(). */ void expect_uint_not_in_set(#function, #parameter, uintmax_t value_array[]); #else #define expect_uint_not_in_set(function, parameter, value_array) \ expect_uint_not_in_set_count(function, parameter, value_array, 1) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] value_array[] The array to check for the value. * * @param[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 check_expected(). */ void expect_uint_not_in_set_count(#function, #parameter, uintmax_t value_array[], size_t count); #else #define expect_uint_not_in_set_count(function, parameter, value_array, count) \ _expect_uint_not_in_set(cmocka_tostring(function), \ cmocka_tostring(parameter), \ __FILE__, \ __LINE__, \ value_array, \ sizeof(value_array) / sizeof((value_array)[0]), \ count) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] epsilon The epsilon used as margin for float comparison. * * @param[in] value_array[] The array to check for the value. * * @see check_expected_float(). */ void expect_float_in_set(#function, #parameter, double value_array[], double epsilon); #else #define expect_float_in_set(function, parameter, value_array, epsilon) \ expect_float_in_set_count(function, parameter, value_array, epsilon, 1) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] value_array[] The array to check for the value. * * @param[in] epsilon The epsilon used as margin for float comparison. * * @param[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 check_expected_float(). */ void expect_float_in_set_count(#function, #parameter, double value_array[], double epsilon, size_t count); #else #define expect_float_in_set_count(function, parameter, value_array, epsilon, count) \ _expect_float_in_set(cmocka_tostring(function), \ cmocka_tostring(parameter), \ __FILE__, \ __LINE__, \ value_array, \ sizeof(value_array) / sizeof((value_array)[0]), \ epsilon, \ count) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] epsilon The epsilon used as margin for float comparison. * * @param[in] value_array[] The array to check for the value. * * @see check_expected_float(). */ void expect_float_not_in_set(#function, #parameter, double value_array[], double epsilon); #else #define expect_float_not_in_set(function, parameter, value_array, epsilon) \ expect_float_not_in_set_count(function, parameter, value_array, epsilon, 1) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] value_array[] The array to check for the value. * * @param[in] epsilon The epsilon used as margin for float comparison. * * @param[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 check_expected_float(). */ void expect_float_not_in_set_count(#function, #parameter, double value_array[], double epsilon, size_t count); #else #define expect_float_not_in_set_count(function, parameter, value_array, epsilon, count) \ _expect_float_not_in_set(cmocka_tostring(function), \ cmocka_tostring(parameter), \ __FILE__, \ __LINE__, \ value_array, \ sizeof(value_array) / sizeof((value_array)[0]), \ epsilon, \ count) #endif #ifdef DOXYGEN /** * @deprecated Use expect_int_in_range() */ void expect_in_range(#function, #parameter, uintmax_t minimum, uintmax_t maximum); #else #define expect_in_range(function, parameter, minimum, maximum) \ do { \ CMOCKA_DEPRECATION_WARNING( \ "expect_in_range: use expect_int_in_range or " \ "expect_uint_in_range instead") \ expect_in_range_count(function, parameter, minimum, maximum, 1); \ } while (0) #endif #ifdef DOXYGEN /** * @deprecated Use expect_int_in_range_count() */ void expect_in_range_count(#function, #parameter, uintmax_t minimum, uintmax_t maximum, size_t count); #else #define expect_in_range_count(function, parameter, minimum, maximum, count) \ do { \ CMOCKA_DEPRECATION_WARNING( \ "expect_in_range_count: use expect_int_in_range_count or " \ "expect_uint_in_range_count instead") \ _expect_in_range(cmocka_tostring(function), \ cmocka_tostring(parameter), \ __FILE__, \ __LINE__, \ minimum, \ maximum, \ count); \ } while (0) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] minimum The lower boundary of the interval to check against. * * @param[in] maximum The upper boundary of the interval to check against. * * @see check_expected(). */ void expect_int_in_range(#function, #parameter, intmax_t minimum, intmax_t maximum); #else #define expect_int_in_range(function, parameter, minimum, maximum) \ expect_int_in_range_count(function, parameter, minimum, maximum, 1) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] minimum The lower boundary of the interval to check against. * * @param[in] maximum The upper boundary of the interval to check against. * * @param[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 check_expected(). */ void expect_int_in_range_count(#function, #parameter, intmax_t minimum, intmax_t maximum, size_t count); #else #define expect_int_in_range_count( \ function, parameter, minimum, maximum, count) \ _expect_int_in_range(cmocka_tostring(function), \ cmocka_tostring(parameter), \ __FILE__, \ __LINE__, \ minimum, \ maximum, \ count) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] minimum The lower boundary of the interval to check against. * * @param[in] maximum The upper boundary of the interval to check against. * * @see check_expected(). */ void expect_uint_in_range(#function, #parameter, uintmax_t minimum, uintmax_t maximum); #else #define expect_uint_in_range(function, parameter, minimum, maximum) \ expect_uint_in_range_count(function, parameter, minimum, maximum, 1) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] minimum The lower boundary of the interval to check against. * * @param[in] maximum The upper boundary of the interval to check against. * * @param[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 check_expected(). */ void expect_uint_in_range_count(#function, #parameter, uintmax_t minimum, uintmax_t maximum, size_t count); #else #define expect_uint_in_range_count( \ function, parameter, minimum, maximum, count) \ _expect_uint_in_range(cmocka_tostring(function), \ cmocka_tostring(parameter), \ __FILE__, \ __LINE__, \ minimum, \ maximum, \ count) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] minimum The lower boundary of the interval to check against. * * @param[in] maximum The upper boundary of the interval to check against. * * @see check_expected(). */ void expect_not_in_range(#function, #parameter, uintmax_t minimum, uintmax_t maximum); #else #define expect_not_in_range(function, parameter, minimum, maximum) \ expect_not_in_range_count(function, parameter, minimum, maximum, 1) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] minimum The lower boundary of the interval to check against. * * @param[in] maximum The upper boundary of the interval to check against. * * @param[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 check_expected(). */ void expect_not_in_range_count(#function, #parameter, uintmax_t minimum, uintmax_t maximum, size_t count); #else #define expect_not_in_range_count(function, parameter, minimum, maximum, \ count) \ _expect_not_in_range(cmocka_tostring(function), cmocka_tostring(parameter), __FILE__, __LINE__, \ minimum, maximum, count) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] minimum The lower boundary of the interval to check against. * * @param[in] maximum The upper boundary of the interval to check against. * * @see check_expected(). */ void expect_int_not_in_range(#function, #parameter, intmax_t minimum, intmax_t maximum); #else #define expect_int_not_in_range(function, parameter, minimum, maximum) \ expect_int_not_in_range_count(function, parameter, minimum, maximum, 1) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] minimum The lower boundary of the interval to check against. * * @param[in] maximum The upper boundary of the interval to check against. * * @param[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 check_expected(). */ void expect_int_not_in_range_count(#function, #parameter, intmax_t minimum, intmax_t maximum, size_t count); #else #define expect_int_not_in_range_count( \ function, parameter, minimum, maximum, count) \ _expect_int_not_in_range(cmocka_tostring(function), \ cmocka_tostring(parameter), \ __FILE__, \ __LINE__, \ minimum, \ maximum, \ count) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] minimum The lower boundary of the interval to check against. * * @param[in] maximum The upper boundary of the interval to check against. * * @see check_expected(). */ void expect_uint_not_in_range(#function, #parameter, uintmax_t minimum, uintmax_t maximum); #else #define expect_uint_not_in_range(function, parameter, minimum, maximum) \ expect_uint_not_in_range_count(function, parameter, minimum, maximum, 1) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] minimum The lower boundary of the interval to check against. * * @param[in] maximum The upper boundary of the interval to check against. * * @param[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 check_expected(). */ void expect_uint_not_in_range_count(#function, #parameter, uintmax_t minimum, uintmax_t maximum, size_t count); #else #define expect_uint_not_in_range_count( \ function, parameter, minimum, maximum, count) \ _expect_uint_not_in_range(cmocka_tostring(function), \ cmocka_tostring(parameter), \ __FILE__, \ __LINE__, \ minimum, \ maximum, \ count) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] minimum The lower boundary of the interval to check against. * * @param[in] maximum The upper boundary of the interval to check against. * * @param[in] epsilon The epsilon used as margin for float comparison. * * @see check_expected_float(). */ void expect_float_in_range(#function, #parameter, double minimum, double maximum, double epsilon); #else #define expect_float_in_range(function, parameter, minimum, maximum, epsilon) \ expect_float_in_range_count(function, parameter, minimum, maximum, epsilon, 1) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] minimum The lower boundary of the interval to check against. * * @param[in] maximum The upper boundary of the interval to check against. * * @param[in] epsilon The epsilon used as margin for float comparison. * * @param[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 check_expected_float() */ void expect_float_in_range_count(#function, #parameter, double minimum, double maximum, double epsilon, size_t count); #else #define expect_float_in_range_count(function, parameter, minimum, maximum, epsilon, count) \ _expect_float_in_range(cmocka_tostring(function), \ cmocka_tostring(parameter), \ __FILE__, \ __LINE__, \ cast_to_double_type(minimum), \ cast_to_double_type(maximum), \ cast_to_double_type(epsilon), \ count) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] minimum The lower boundary of the interval to check against. * * @param[in] maximum The upper boundary of the interval to check against. * * @param[in] epsilon The epsilon used as margin for float comparison. * * @see check_expected(). */ void expect_float_not_in_range(#function, #parameter, double minimum, double maximum, double epsilon); #else #define expect_float_not_in_range(function, parameter, minimum, maximum, epsilon) \ expect_float_not_in_range_count(function, parameter, minimum, maximum, epsilon, 1) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] minimum The lower boundary of the interval to check against. * * @param[in] maximum The upper boundary of the interval to check against. * * @param[in] epsilon The epsilon used as margin for float comparison. * * @param[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 check_expected(). */ void expect_float_not_in_range_count(#function, #parameter, double minimum, double maximum, double epsilon, size_t count); #else #define expect_float_not_in_range_count(function, parameter, minimum, maximum, \ epsilon, count) \ _expect_float_not_in_range(cmocka_tostring(function), \ cmocka_tostring(parameter), \ __FILE__, \ __LINE__, \ cast_to_double_type(minimum), \ cast_to_double_type(maximum), \ cast_to_double_type(epsilon), \ count) #endif #ifdef DOXYGEN /** * @deprecated Use expect_int_value() or expect_uint_value() */ void expect_value(#function, #parameter, uintmax_t value); #else #define expect_value(function, parameter, value) \ do { \ CMOCKA_DEPRECATION_WARNING("expect_value: use expect_int_value or " \ "expect_uint_value instead") \ expect_value_count(function, parameter, value, 1); \ } while (0) #endif #ifdef DOXYGEN /** * @deprecated Use expect_int_value_count() or expect_uint_value_count() */ void expect_value_count(#function, #parameter, uintmax_t value, size_t count); #else #define expect_value_count(function, parameter, value, count) \ do { \ CMOCKA_DEPRECATION_WARNING( \ "expect_value_count: use expect_int_value_count or " \ "expect_uint_value_count instead") \ _expect_value(cmocka_tostring(function), \ cmocka_tostring(parameter), \ __FILE__, \ __LINE__, \ cast_to_uintmax_type(value), \ count); \ } while (0) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] value The value to check. * * @see check_expected(). */ void expect_int_value(#function, #parameter, intmax_t value); #else #define expect_int_value(function, parameter, value) \ expect_int_value_count(function, parameter, value, 1) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] value The value to check. * * @param[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 check_expected(). */ void expect_int_value_count(#function, #parameter, intmax_t value, size_t count); #else #define expect_int_value_count(function, parameter, value, count) \ _expect_int_value(cmocka_tostring(function), \ cmocka_tostring(parameter), \ __FILE__, \ __LINE__, \ value, \ count) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] value The value to check. * * @see check_expected(). */ void expect_uint_value(#function, #parameter, uintmax_t value); #else #define expect_uint_value(function, parameter, value) \ expect_uint_value_count(function, parameter, value, 1) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] value The value to check. * * @param[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 check_expected(). */ void expect_uint_value_count(#function, #parameter, uintmax_t value, size_t count); #else #define expect_uint_value_count(function, parameter, value, count) \ _expect_uint_value(cmocka_tostring(function), \ cmocka_tostring(parameter), \ __FILE__, \ __LINE__, \ value, \ count) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] value The value (intmax_t) to check. * * @see check_expected(). */ void expect_int_not_value(#function, #parameter, intmax_t value); #else #define expect_int_not_value(function, parameter, value) \ expect_int_not_value_count(function, parameter, value, 1) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] value The value (intmax_t) to check. * * @param[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 check_expected(). */ void expect_int_not_value_count(#function, #parameter, intmax_t value, size_t count); #else #define expect_int_not_value_count(function, parameter, value, count) \ _expect_int_not_value(cmocka_tostring(function), \ cmocka_tostring(parameter), \ __FILE__, \ __LINE__, \ value, \ count) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] value The value (uintmax_t) to check. * * @see check_expected(). */ void expect_uint_not_value(#function, #parameter, uintmax_t value); #else #define expect_uint_not_value(function, parameter, value) \ expect_uint_not_value_count(function, parameter, value, 1) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] value The value (uintmax_t) to check. * * @param[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 check_expected(). */ void expect_uint_not_value_count(#function, #parameter, uintmax_t value, size_t count); #else #define expect_uint_not_value_count(function, parameter, value, count) \ _expect_uint_not_value(cmocka_tostring(function), \ cmocka_tostring(parameter), \ __FILE__, \ __LINE__, \ value, \ count) #endif #ifdef DOXYGEN /** * @deprecated Use expect_int_not_value() or expect_uint_not_value() */ void expect_not_value(#function, #parameter, uintmax_t value); #else #define expect_not_value(function, parameter, value) \ do { \ CMOCKA_DEPRECATION_WARNING( \ "expect_not_value: use expect_int_not_value or " \ "expect_uint_not_value instead") \ expect_not_value_count(function, parameter, value, 1); \ } while (0) #endif #ifdef DOXYGEN /** * @deprecated Use expect_int_not_value_count() or expect_uint_not_value_count() */ void expect_not_value_count(#function, #parameter, uintmax_t value, size_t count); #else #define expect_not_value_count(function, parameter, value, count) \ do { \ CMOCKA_DEPRECATION_WARNING( \ "expect_not_value_count: use expect_int_not_value_count or " \ "expect_uint_not_value_count instead") \ _expect_not_value(cmocka_tostring(function), \ cmocka_tostring(parameter), \ __FILE__, \ __LINE__, \ cast_to_uintmax_type(value), \ count); \ } while (0) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] value The value to check. * * @param[in] epsilon The epsilon used as margin for float comparison. * * @see check_expected_float() * @see expect_string() * @see expect_memory() * @see expect_any() */ void expect_float(#function, #parameter, double value, double epsilon); #else #define expect_float(function, parameter, value, epsilon) \ expect_float_count(function, parameter, cast_to_double_type(value), \ cast_to_double_type(epsilon), 1) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] value The value to check. * * @param[in] epsilon The epsilon used as margin for float comparison. * * @param[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 check_expected_float(). * @see expect_not_string() * @see expect_not_memory() */ void expect_float_count(#function, #parameter, double value, double epsilon, size_t count); #else #define expect_float_count(function, parameter, value, epsilon, count) \ _expect_float(cmocka_tostring(function), cmocka_tostring(parameter), __FILE__, __LINE__, \ cast_to_double_type(value), cast_to_double_type(epsilon), count) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] value The value to check. * * @param[in] epsilon The epsilon used as margin for float comparison. * * @see check_expected_float() * @see expect_string() * @see expect_memory() * @see expect_any() */ void expect_not_float(#function, #parameter, double value, double epsilon); #else #define expect_not_float(function, parameter, value, epsilon) \ expect_not_float_count(function, \ parameter, \ cast_to_float_type(value), \ cast_to_float_type(epsilon), \ 1) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] value The value to check. * * @param[in] epsilon The epsilon used as margin for float comparison. * * @param[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 check_expected_float(). * @see expect_not_string() * @see expect_not_memory() */ void expect_not_float_count(#function, #parameter, double value, double epsilon, size_t count); #else #define expect_not_float_count(function, parameter, value, epsilon, count) \ _expect_not_float(cmocka_tostring(function), \ cmocka_tostring(parameter), \ __FILE__, \ __LINE__, \ cast_to_float_type(value), \ cast_to_float_type(epsilon), \ count) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] value The value to check. * * @param[in] epsilon The epsilon used as margin for double comparison. * * @see check_expected_double() */ void expect_double(#function, #parameter, double value, double epsilon); #else #define expect_double(function, parameter, value, epsilon) \ expect_double_count(function, \ parameter, \ cast_to_double_type(value), \ cast_to_double_type(epsilon), \ 1) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] value The value to check. * * @param[in] epsilon The epsilon used as margin for double comparison. * * @param[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 check_expected_double(). */ void expect_double_count(#function, #parameter, double value, double epsilon, size_t count); #else #define expect_double_count(function, parameter, value, epsilon, count) \ _expect_double(cmocka_tostring(function), \ cmocka_tostring(parameter), \ __FILE__, \ __LINE__, \ cast_to_double_type(value), \ cast_to_double_type(epsilon), \ count) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] value The value to check. * * @param[in] epsilon The epsilon used as margin for double comparison. * * @see check_expected_double() */ void expect_not_double(#function, #parameter, double value, double epsilon); #else #define expect_not_double(function, parameter, value, epsilon) \ expect_not_double_count(function, \ parameter, \ cast_to_double_type(value), \ cast_to_double_type(epsilon), \ 1) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] value The value to check. * * @param[in] epsilon The epsilon used as margin for double comparison. * * @param[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 check_expected_double(). */ void expect_not_double_count(#function, #parameter, double value, double epsilon, size_t count); #else #define expect_not_double_count(function, parameter, value, epsilon, count) \ _expect_not_double(cmocka_tostring(function), \ cmocka_tostring(parameter), \ __FILE__, \ __LINE__, \ cast_to_double_type(value), \ cast_to_double_type(epsilon), \ count) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] string The string value to compare. * * @see check_expected(). */ void expect_string(#function, #parameter, const char *string); #else #define expect_string(function, parameter, string) \ expect_string_count(function, parameter, string, 1) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] string The string value to compare. * * @param[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 check_expected(). */ void expect_string_count(#function, #parameter, const char *string, size_t count); #else #define expect_string_count(function, parameter, string, count) \ _expect_string(cmocka_tostring(function), cmocka_tostring(parameter), __FILE__, __LINE__, \ (const char*)(string), count) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] string The string value to compare. * * @see check_expected(). */ void expect_not_string(#function, #parameter, const char *string); #else #define expect_not_string(function, parameter, string) \ expect_not_string_count(function, parameter, string, 1) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] string The string value to compare. * * @param[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 check_expected(). */ void expect_not_string_count(#function, #parameter, const char *string, size_t count); #else #define expect_not_string_count(function, parameter, string, count) \ _expect_not_string(cmocka_tostring(function), cmocka_tostring(parameter), __FILE__, __LINE__, \ (const char*)(string), count) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] memory The memory to compare. * * @param[in] size The size of the memory to compare. * * @see check_expected(). */ void expect_memory(#function, #parameter, void *memory, size_t size); #else #define expect_memory(function, parameter, memory, size) \ expect_memory_count(function, parameter, memory, size, 1) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] memory The memory to compare. * * @param[in] size The size of the memory to compare. * * @param[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 check_expected(). */ void expect_memory_count(#function, #parameter, void *memory, size_t size, size_t count); #else #define expect_memory_count(function, parameter, memory, size, count) \ _expect_memory(cmocka_tostring(function), cmocka_tostring(parameter), __FILE__, __LINE__, \ (const void*)(memory), size, count) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] memory The memory to compare. * * @param[in] size The size of the memory to compare. * * @see check_expected(). */ void expect_not_memory(#function, #parameter, void *memory, size_t size); #else #define expect_not_memory(function, parameter, memory, size) \ expect_not_memory_count(function, parameter, memory, size, 1) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[in] memory The memory to compare. * * @param[in] size The size of the memory to compare. * * @param[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 check_expected(). */ void expect_not_memory_count(#function, #parameter, void *memory, size_t size, size_t count); #else #define expect_not_memory_count(function, parameter, memory, size, count) \ _expect_not_memory(cmocka_tostring(function), cmocka_tostring(parameter), __FILE__, __LINE__, \ (const void*)(memory), size, count) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @see check_expected(). */ void expect_any(#function, #parameter); #else #define expect_any(function, parameter) \ expect_any_count(function, parameter, 1) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @see check_expected(). */ void expect_any_always(#function, #parameter); #else #define expect_any_always(function, parameter) \ expect_any_count(function, parameter, WILL_RETURN_ALWAYS) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #function The function to add the check for. * * @param[in] #parameter The name of the parameter passed to the function. * * @param[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 check_expected(). */ void expect_any_count(#function, #parameter, size_t count); #else #define expect_any_count(function, parameter, count) \ _expect_any(cmocka_tostring(function), cmocka_tostring(parameter), __FILE__, __LINE__, count) #endif #ifdef DOXYGEN /** * @deprecated Use check_expected_int(), check_expected_uint(), * check_expected_float or check_expetecd_double() instead. */ void check_expected(#parameter); #else #define check_expected(parameter) \ do { \ CMOCKA_DEPRECATION_WARNING( \ "check_expected: use check_expected_int or " \ "check_expected_uint instead") \ _check_expected(__func__, \ #parameter, \ __FILE__, \ __LINE__, \ cast_int_to_cmocka_value(parameter)); \ } while (0) #endif #ifdef DOXYGEN /** * @brief 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 * * @param[in] #parameter The parameter to check. * * @see check_expected_int() * @see check_expected_uint() * @see check_expected_float() * @see check_expected_double() * @see check_expected_ptr() * @see expect_check_data() */ void check_expected_any(#parameter); #else #define check_expected_any(parameter) \ _check_expected(__func__, #parameter, __FILE__, __LINE__, \ cast_ptr_to_cmocka_value(&(parameter))) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #parameter The pointer to check. */ void check_expected_ptr(#parameter); #else #define check_expected_ptr(parameter) \ _check_expected(__func__, #parameter, __FILE__, __LINE__, \ cast_ptr_to_cmocka_value(parameter)) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #parameter The parameter to check. */ void check_expected_int(#parameter); #else #define check_expected_int(parameter) \ _check_expected(__func__, \ #parameter, \ __FILE__, \ __LINE__, \ assign_int_to_cmocka_value(parameter)) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #parameter The parameter to check. */ void check_expected_uint(#parameter); #else #define check_expected_uint(parameter) \ _check_expected(__func__, \ #parameter, \ __FILE__, \ __LINE__, \ assign_uint_to_cmocka_value(parameter)) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #parameter The parameter to check. * * @see expect_float * @see expect_not_float * @see expect_float_count * @see expect_not_float_count */ void check_expected_float(#parameter); #else #define check_expected_float(parameter) \ _check_expected(__func__, \ #parameter, \ __FILE__, \ __LINE__, \ assign_float_to_cmocka_value(parameter)) #endif #ifdef DOXYGEN /** * @brief 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. * * @param[in] #parameter The parameter to check. * * @see expect_double * @see expect_not_double * @see expect_double_count * @see expect_not_double_count */ void check_expected_double(#parameter); #else #define check_expected_double(parameter) \ _check_expected(__func__, \ #parameter, \ __FILE__, \ __LINE__, \ assign_double_to_cmocka_value(parameter)) #endif /** @} */ /* cmocka_param */ /** * @defgroup cmocka_asserts 🛡️ Assert Macros * @ingroup cmocka * @brief Verify conditions and fail tests when assertions don't hold. * * Assertion macros for validating test conditions. * * CMocka provides type-specific assertion macros that display detailed * information about failures, making debugging easier than the standard C * library's assert(3) macro. * * On an assertion failure a cmocka assert macro will write the failure to * the standard error stream and signal a test failure. Due to limitations * of the C language the general C standard library assert() and cmocka's * assert_true() and assert_false() macros can only display the expression * that caused the assert failure. cmocka's type specific assert macros, * assert_{type}_equal() and assert_{type}_not_equal(), display the data * that caused the assertion failure which increases data visibility aiding * debugging of failing test cases. * * @{ */ #ifdef DOXYGEN /** * @brief Assert that the given expression is true. * * The function prints an error message to standard error and terminates the * test by calling fail() if expression is false (i.e., compares equal to * zero). * * @param[in] expression The expression to evaluate. * * @see assert_int_equal() * @see assert_string_equal() */ void assert_true(scalar expression); #else #define assert_true(c) _assert_true(cast_to_uintmax_type(c), #c, \ __FILE__, __LINE__) #endif #ifdef DOXYGEN /** * @brief Assert that the given expression is false. * * The function prints an error message to standard error and terminates the * test by calling fail() if expression is true. * * @param[in] expression The expression to evaluate. * * @see assert_int_equal() * @see assert_string_equal() */ void assert_false(scalar expression); #else #define assert_false(c) _assert_false(cast_to_uintmax_type(c), #c, \ __FILE__, __LINE__) #endif #ifdef DOXYGEN /** * @brief Assert that the return_code is greater than or equal to 0. * * The function prints an error message to standard error and terminates the * test by calling fail() if the return code is smaller than 0. If the function * you check sets an errno if it fails you can pass it to the function and * it will be printed as part of the error message. * * @param[in] rc The return code to evaluate. * * @param[in] error Pass errno here or 0. */ void assert_return_code(intmax_t rc, int32_t error); #else #define assert_return_code(rc, error) \ _assert_return_code((rc), \ (error), \ #rc, __FILE__, __LINE__) #endif #ifdef DOXYGEN /** * @brief Assert that the given pointer is non-NULL. * * The function prints an error message to standard error and terminates the * test by calling fail() if the pointer is NULL. * * @param[in] pointer The pointer to evaluate. * * @see assert_null() */ void assert_non_null(void *pointer); #else #define assert_non_null(c) assert_ptr_not_equal((c), NULL) #endif #ifdef DOXYGEN /** * @brief Assert that the given pointer is non-NULL. * * The function prints an error message extended by message to standard error * and terminates the test by calling fail() if the pointer is NULL. * * @param[in] pointer The pointer to evaluate. * * @param[in] message The message to print when the pointer is NULL. * * @see assert_null_msg() */ void assert_non_null_msg(void *pointer, const char *const message); #else #define assert_non_null_msg(c, msg) assert_ptr_not_equal_msg((c), NULL, (msg)) #endif #ifdef DOXYGEN /** * @brief Assert that the given pointer is NULL. * * The function prints an error message to standard error and terminates the * test by calling fail() if the pointer is non-NULL. * * @param[in] pointer The pointer to evaluate. * * @see assert_non_null() */ void assert_null(void *pointer); #else #define assert_null(c) assert_ptr_equal((c), NULL) #endif #ifdef DOXYGEN /** * @brief Assert that the given pointer is NULL. * * The function prints an error message extended by message to standard error * and terminates the test by calling fail() if the pointer is non-NULL. * * @param[in] pointer The pointer to evaluate. * * @param[in] message The message to print when the pointer is not NULL. * * @see assert_non_null_msg() */ void assert_null_msg(void *pointer, const char *const message); #else #define assert_null_msg(c, msg) assert_ptr_equal_msg((c), NULL, (msg)) #endif #ifdef DOXYGEN /** * @brief Assert that the two given pointers are equal. * * The function prints an error message and terminates the test by calling * fail() if the pointers are not equal. * * @param[in] a The first pointer to compare. * * @param[in] b The pointer to compare against the first one. */ void assert_ptr_equal(void *a, void *b); #else #define assert_ptr_equal(a, b) assert_ptr_equal_msg((a), (b), NULL) #endif #ifdef DOXYGEN /** * @brief Assert that the two given pointers are equal. * * The function prints the failing comparison and the error message given by the user * and then terminates the test by calling fail() if the pointers are not equal. * * @param[in] a The first pointer to compare. * * @param[in] b The pointer to compare against the first one. * * @param[in] msg The error message to print when a & b are not equal. */ void assert_ptr_equal_msg(void *a, void *b, const char *const msg); #else #define assert_ptr_equal_msg(a, b, msg) \ _assert_ptr_equal_msg(cast_to_void_pointer(a), \ cast_to_void_pointer(b), \ __FILE__, __LINE__, (msg)) #endif #ifdef DOXYGEN /** * @brief Assert that the two given pointers are not equal. * * The function prints an error message and terminates the test by calling * fail() if the pointers are equal. * * @param[in] a The first pointer to compare. * * @param[in] b The pointer to compare against the first one. */ void assert_ptr_not_equal(void *a, void *b); #else #define assert_ptr_not_equal(a, b) \ assert_ptr_not_equal_msg((a), (b), NULL) #endif #ifdef DOXYGEN /** * @brief Assert that the two given pointers are not equal. * * The function prints the failing comparison and the error message given by the user * and then terminates the test by calling fail() if the pointers are equal. * * @param[in] a The first pointer to compare. * * @param[in] b The pointer to compare against the first one. * * @param[in] msg The error message to print when a & b are equal. */ void assert_ptr_not_equal_msg(void *a, void *b, const char *const msg); #else /* DOXYGEN */ #if defined(__has_builtin) #if __has_builtin(__builtin_unreachable) #define assert_ptr_not_equal_msg(a, b, msg) \ do { \ const void *cmocka_p1 = cast_to_void_pointer(a), \ *cmocka_p2 = cast_to_void_pointer(b); \ _assert_ptr_not_equal_msg( \ cmocka_p1, cmocka_p2, __FILE__, __LINE__, (msg)); \ if (cmocka_p1 == cmocka_p2) { \ __builtin_unreachable(); \ } \ } while (0) #else /* __has_builtin(__builtin_unreachable) */ #define assert_ptr_not_equal_msg(a, b, msg) \ _assert_ptr_not_equal_msg(cast_to_void_pointer(a), \ cast_to_void_pointer(b), \ __FILE__, \ __LINE__, \ (msg)) #endif /* __has_builtin(__builtin_unreachable) */ #else /* defined(__has_builtin) */ #define assert_ptr_not_equal_msg(a, b, msg) \ _assert_ptr_not_equal_msg(cast_to_void_pointer(a), \ cast_to_void_pointer(b), \ __FILE__, \ __LINE__, \ (msg)) #endif /* __has_builtin(__builtin_unreachable) */ #endif /* DOXYGEN */ #ifdef DOXYGEN /** * @brief Assert that the two given integers are equal. * * The function prints an error message to standard error and terminates the * test by calling fail() if the integers are not equal. * * @param[in] a The first integer to compare. * * @param[in] b The integer to compare against the first one. */ void assert_int_equal(intmax_t a, intmax_t b); #else #define assert_int_equal(a, b) \ _assert_int_equal(cast_to_intmax_type(a), \ cast_to_intmax_type(b), \ __FILE__, __LINE__) #endif #ifdef DOXYGEN /** * @brief Assert that the two given unsigned integers are equal. * * The function prints an error message to standard error and terminates the * test by calling fail() if the integers are not equal. * * @param[in] a The first unsigned integer to compare. * * @param[in] b The unsigned integer to compare against the first one. */ void assert_uint_equal(uintmax_t a, uintmax_t b); #else #define assert_uint_equal(a, b) \ _assert_uint_equal(cast_to_uintmax_type(a), \ cast_to_uintmax_type(b), \ __FILE__, __LINE__) #endif #ifdef DOXYGEN /** * @brief Assert that the two given integers are not equal. * * The function prints an error message to standard error and terminates the * test by calling fail() if the integers are equal. * * @param[in] a The first integer to compare. * * @param[in] b The integer to compare against the first one. * * @see assert_int_equal() */ void assert_int_not_equal(intmax_t a, intmax_t b); #else #define assert_int_not_equal(a, b) \ _assert_int_not_equal(cast_to_intmax_type(a), \ cast_to_intmax_type(b), \ __FILE__, __LINE__) #endif #ifdef DOXYGEN /** * @brief Assert that the two given unsigned integers are not equal. * * The function prints an error message to standard error and terminates the * test by calling fail() if the integers are not equal. * * @param[in] a The first unsigned integer to compare. * * @param[in] b The unsigned integer to compare against the first one. */ void assert_uint_not_equal(uintmax_t a, uintmax_t b); #else #define assert_uint_not_equal(a, b) \ _assert_uint_not_equal(cast_to_uintmax_type(a), \ cast_to_uintmax_type(b), \ __FILE__, __LINE__) #endif #ifdef DOXYGEN /** * @brief Assert that the two given float are equal given an epsilon. * * The function prints an error message to standard error and terminates the * test by calling fail() if the float are not equal (given an epsilon). * * @param[in] a The first float to compare. * * @param[in] b The float to compare against the first one. * * @param[in] epsilon The epsilon used as margin for float comparison. */ void assert_float_equal(float a, float b, float epsilon); #else #define assert_float_equal(a, b, epsilon) \ _assert_float_equal((float)a, \ (float)b, \ (float)epsilon, \ __FILE__, __LINE__) #endif #ifdef DOXYGEN /** * @brief Assert that the two given float are not equal given an epsilon. * * The function prints an error message to standard error and terminates the * test by calling fail() if the float are not equal (given an epsilon). * * @param[in] a The first float to compare. * * @param[in] b The float to compare against the first one. * * @param[in] epsilon The epsilon used as margin for float comparison. */ void assert_float_not_equal(float a, float b, float epsilon); #else #define assert_float_not_equal(a, b, epsilon) \ _assert_float_not_equal((float)a, \ (float)b, \ (float)epsilon, \ __FILE__, __LINE__) #endif #ifdef DOXYGEN /** * @brief Assert that the two given double are equal given an epsilon. * * The function prints an error message to standard error and terminates the * test by calling fail() if the double are not equal (given an epsilon). * * @param[in] a The first double to compare. * * @param[in] b The double to compare against the first one. * * @param[in] epsilon The epsilon used as margin for double comparison. */ void assert_double_equal(double a, double b, double epsilon); #else #define assert_double_equal(a, b, epsilon) \ _assert_double_equal((double)a, \ (double)b, \ (double)epsilon, \ __FILE__, __LINE__) #endif #ifdef DOXYGEN /** * @brief Assert that the two given double are not equal given an epsilon. * * The function prints an error message to standard error and terminates the * test by calling fail() if the double are not equal (given an epsilon). * * @param[in] a The first double to compare. * * @param[in] b The double to compare against the first one. * * @param[in] epsilon The epsilon used as margin for double comparison. */ void assert_double_not_equal(double a, double b, double epsilon); #else #define assert_double_not_equal(a, b, epsilon) \ _assert_double_not_equal((double)a, \ (double)b, \ (double)epsilon, \ __FILE__, __LINE__) #endif #ifdef DOXYGEN /** * @brief Assert that the two given strings are equal. * * The function prints an error message to standard error and terminates the * test by calling fail() if the strings are not equal. * * @param[in] a The string to check. * * @param[in] b The other string to compare. */ void assert_string_equal(const char *a, const char *b); #else #define assert_string_equal(a, b) \ _assert_string_equal((a), (b), __FILE__, __LINE__) #endif #ifdef DOXYGEN /** * @brief Assert that the two given strings are not equal. * * The function prints an error message to standard error and terminates the * test by calling fail() if the strings are equal. * * @param[in] a The string to check. * * @param[in] b The other string to compare. */ void assert_string_not_equal(const char *a, const char *b); #else #define assert_string_not_equal(a, b) \ _assert_string_not_equal((a), (b), __FILE__, __LINE__) #endif #ifdef DOXYGEN /** * @brief Assert that the two given areas of memory are equal, otherwise fail. * * The function prints an error message to standard error and terminates the * test by calling fail() if the memory is not equal. * * @param[in] a The first memory area to compare * (interpreted as unsigned char). * * @param[in] b The second memory area to compare * (interpreted as unsigned char). * * @param[in] size The first n bytes of the memory areas to compare. */ void assert_memory_equal(const void *a, const void *b, size_t size); #else #define assert_memory_equal(a, b, size) \ _assert_memory_equal((const void*)(a), (const void*)(b), size, __FILE__, \ __LINE__) #endif #ifdef DOXYGEN /** * @brief Assert that the two given areas of memory are not equal. * * The function prints an error message to standard error and terminates the * test by calling fail() if the memory is equal. * * @param[in] a The first memory area to compare * (interpreted as unsigned char). * * @param[in] b The second memory area to compare * (interpreted as unsigned char). * * @param[in] size The first n bytes of the memory areas to compare. */ void assert_memory_not_equal(const void *a, const void *b, size_t size); #else #define assert_memory_not_equal(a, b, size) \ _assert_memory_not_equal((const void*)(a), (const void*)(b), size, \ __FILE__, __LINE__) #endif #ifdef DOXYGEN /** * @brief Assert that the specified integer value is not smaller than the * minimum and and not greater than the maximum. * * The function prints an error message to standard error and terminates the * test by calling fail() if value is not in range. * * @param[in] value The value to check. * * @param[in] minimum The minimum value allowed. * * @param[in] maximum The maximum value allowed. */ void assert_int_in_range(intmax_t value, intmax_t minimum, intmax_t maximum); #else #define assert_int_in_range(value, minimum, maximum) \ _assert_int_in_range( \ cast_to_intmax_type(value), \ cast_to_intmax_type(minimum), \ cast_to_intmax_type(maximum), __FILE__, __LINE__) #endif #ifdef DOXYGEN /** * @brief Assert that the specified unsigned integer value is not smaller than * the minimum and and not greater than the maximum. * * The function prints an error message to standard error and terminates the * test by calling fail() if value is not in range. * * @param[in] value The value to check. * * @param[in] minimum The minimum value allowed. * * @param[in] maximum The maximum value allowed. */ void assert_uint_in_range(uintmax_t value, uintmax_t minimum, uintmax_t maximum); #else #define assert_uint_in_range(value, minimum, maximum) \ _assert_uint_in_range( \ cast_to_intmax_type(value), \ cast_to_intmax_type(minimum), \ cast_to_intmax_type(maximum), __FILE__, __LINE__) #endif #ifdef DOXYGEN /** * @brief Assert that the specified value is smaller than the minimum or * greater than the maximum. * * The function prints an error message to standard error and terminates the * test by calling fail() if value is in range. * * The function prints an error message to standard error and terminates the * test by calling fail() if value is not in range. * * @param[in] value The value to check. * * @param[in] minimum The minimum value allowed. * * @param[in] maximum The maximum value allowed. */ void assert_int_not_in_range(intmax_t value, intmax_t minimum, intmax_t maximum); #else #define assert_int_not_in_range(value, minimum, maximum) \ _assert_int_not_in_range(cast_to_intmax_type(value), \ cast_to_intmax_type(minimum), \ cast_to_intmax_type(maximum), \ __FILE__, \ __LINE__) #endif #ifdef DOXYGEN /** * @brief Assert that the specified value is smaller than the minimum or * greater than the maximum. * * The function prints an error message to standard error and terminates the * test by calling fail() if value is in range. * * The function prints an error message to standard error and terminates the * test by calling fail() if value is not in range. * * @param[in] value The value to check. * * @param[in] minimum The minimum value allowed. * * @param[in] maximum The maximum value allowed. */ void assert_uint_not_in_range(uintmax_t value, uintmax_t minimum, uintmax_t maximum); #else #define assert_uint_not_in_range(value, minimum, maximum) \ _assert_uint_not_in_range(cast_to_uintmax_type(value), \ cast_to_uintmax_type(minimum), \ cast_to_uintmax_type(maximum), \ __FILE__, \ __LINE__) #endif #ifdef DOXYGEN /** * @deprecated Use assert_int_in_range() and assert_uint_in_range() */ void assert_in_range(uintmax_t value, uintmax_t minimum, uintmax_t maximum); #else #define assert_in_range(value, minimum, maximum) \ do { \ CMOCKA_DEPRECATION_WARNING( \ "assert_in_range: use assert_int_in_range or " \ "assert_uint_in_range instead") \ _assert_uint_in_range(cast_to_uintmax_type(value), \ cast_to_uintmax_type(minimum), \ cast_to_uintmax_type(maximum), \ __FILE__, \ __LINE__); \ } while (0) #endif #ifdef DOXYGEN /** * @deprecated Use assert_int_not_in_range() or assert_uint_not_in_range() */ void assert_not_in_range(uintmax_t value, uintmax_t minimum, uintmax_t maximum); #else #define assert_not_in_range(value, minimum, maximum) \ do { \ CMOCKA_DEPRECATION_WARNING( \ "assert_not_in_range: use assert_int_not_in_range or " \ "assert_uint_not_in_range instead") \ _assert_uint_not_in_range(cast_to_uintmax_type(value), \ cast_to_uintmax_type(minimum), \ cast_to_uintmax_type(maximum), \ __FILE__, \ __LINE__); \ } while (0) #endif #ifdef DOXYGEN /** * @brief Assert that the specified float value is smaller than the minimum or * greater than the maximum. * * The function prints an error message to standard error and terminates the * test by calling fail() if value is in range. * * The function prints an error message to standard error and terminates the * test by calling fail() if value is not in range. * * @param[in] value The value to check. * * @param[in] minimum The minimum value allowed. * * @param[in] maximum The maximum value allowed. * * @param[in] epsilon The epsilon used as margin for float comparison. */ void assert_float_not_in_range(double value, double minimum, double maximum, double epsilon); #else #define assert_float_not_in_range(value, minimum, maximum, epsilon) \ _assert_float_not_in_range(cast_to_double_type(value), \ cast_to_double_type(minimum), \ cast_to_double_type(maximum), \ cast_to_double_type(epsilon), \ __FILE__, \ __LINE__) #endif #ifdef DOXYGEN /** * @brief Assert that the specified float value is not smaller than * the minimum and and not greater than the maximum. * * The function prints an error message to standard error and terminates the * test by calling fail() if value is not in range. * * @param[in] value The value to check. * * @param[in] minimum The minimum value allowed. * * @param[in] maximum The maximum value allowed. * * @param[in] epsilon The epsilon used as margin for float comparison. */ void assert_float_in_range(double value, double minimum, double maximum, double epsilon); #else #define assert_float_in_range(value, minimum, maximum, epsilon) \ _assert_float_in_range( \ cast_to_double_type(value), \ cast_to_double_type(minimum), \ cast_to_double_type(maximum), \ cast_to_double_type(epsilon), __FILE__, __LINE__) #endif #ifdef DOXYGEN /** * @deprecated Use assert_int_in_set() or assert_uint_in_set() */ void assert_in_set(uintmax_t value, uintmax_t values[], size_t count); #else #define assert_in_set(value, values, number_of_values) \ do { \ CMOCKA_DEPRECATION_WARNING("assert_in_set: use assert_int_in_set or " \ "assert_uint_in_set instead") \ _assert_uint_in_set( \ value, values, number_of_values, __FILE__, __LINE__); \ } while (0) #endif #ifdef DOXYGEN /** * @brief Assert that the specified value is not within a set. * * The function prints an error message to standard error and terminates the * test by calling fail() if value is within a set. * * @param[in] value The value to look up * * @param[in] values[] The array to check for the value. * * @param[in] count The size of the values array. */ void assert_not_in_set(uintmax_t value, uintmax_t values[], size_t count); #else #define assert_not_in_set(value, values, number_of_values) \ _assert_not_in_set(value, values, number_of_values, __FILE__, __LINE__) #endif #ifdef DOXYGEN /** * @brief Assert that the specified integer value is within a set. * * The function prints an error message to standard error and terminates the * test by calling fail() if value is not within a set. * * @param[in] value The value to look up * * @param[in] values[] The array to check for the value. * * @param[in] count The size of the values array. */ void assert_int_in_set(intmax_t value, intmax_t values[], size_t count); #else #define assert_int_in_set(value, values, number_of_values) \ if (number_of_values > 0) { \ intmax_t _cmocka_set[number_of_values]; \ for (size_t _i = 0; _i < number_of_values; _i++) { \ _cmocka_set[_i] = values[_i]; \ } \ _assert_int_in_set(value, _cmocka_set, number_of_values, __FILE__, __LINE__); \ } #endif #ifdef DOXYGEN /** * @brief Assert that the specified value is not within a set. * * The function prints an error message to standard error and terminates the * test by calling fail() if value is within a set. * * @param[in] value The value to look up * * @param[in] values[] The array to check for the value. * * @param[in] count The size of the values array. */ void assert_int_not_in_set(intmax_t value, intmax_t values[], size_t count); #else #define assert_int_not_in_set(value, values, number_of_values) \ if (number_of_values > 0) { \ intmax_t _cmocka_set[number_of_values]; \ for (size_t _i = 0; _i < number_of_values; _i++) { \ _cmocka_set[_i] = values[_i]; \ } \ _assert_int_not_in_set(value, _cmocka_set, number_of_values, __FILE__, __LINE__); \ } #endif #ifdef DOXYGEN /** * @brief Assert that the specified unsigned integer value is within a set. * * The function prints an error message to standard error and terminates the * test by calling fail() if value is not within a set. * * @param[in] value The value to look up * * @param[in] values[] The array to check for the value. * * @param[in] count The size of the values array. */ void assert_uint_in_set(uintmax_t value, uintmax_t values[], size_t count); #else #define assert_uint_in_set(value, values, number_of_values) \ if (number_of_values > 0) { \ uintmax_t _cmocka_set[number_of_values]; \ for (size_t _i = 0; _i < number_of_values; _i++) { \ _cmocka_set[_i] = values[_i]; \ } \ _assert_uint_in_set(value, _cmocka_set, number_of_values, __FILE__, __LINE__); \ } #endif #ifdef DOXYGEN /** * @brief Assert that the specified unsigned integer value is not within a set. * * The function prints an error message to standard error and terminates the * test by calling fail() if value is within a set. * * @param[in] value The value to look up * * @param[in] values[] The array to check for the value. * * @param[in] count The size of the values array. */ void assert_uint_not_in_set(uintmax_t value, uintmax_t values[], size_t count); #else #define assert_uint_not_in_set(value, values, number_of_values) \ if (number_of_values > 0) { \ uintmax_t _cmocka_set[number_of_values]; \ for (size_t _i = 0; _i < number_of_values; _i++) { \ _cmocka_set[_i] = values[_i]; \ } \ _assert_uint_not_in_set(value, _cmocka_set, number_of_values, __FILE__, __LINE__); \ } #endif #ifdef DOXYGEN /** * @brief Assert that the specified float value is within a set. * * The function prints an error message to standard error and terminates the * test by calling fail() if value is not within a set. * * @param[in] value The value to look up * * @param[in] values[] The array to check for the value. * * @param[in] count The size of the values array. * * @param[in] epsilon The epsilon used as margin for float comparison. */ void assert_float_in_set(double value, double values[], size_t count, double epsilon); #else #define assert_float_in_set(value, values, number_of_values, epsilon) \ if (number_of_values > 0) { \ double _cmocka_set[number_of_values]; \ for (size_t _i = 0; _i < number_of_values; _i++) { \ _cmocka_set[_i] = values[_i]; \ } \ _assert_float_in_set(value, _cmocka_set, number_of_values, epsilon, __FILE__, __LINE__); \ } #endif #ifdef DOXYGEN /** * @brief Assert that the specified float value is not within a set. * * The function prints an error message to standard error and terminates the * test by calling fail() if value is not within a set. * * @param[in] value The value to look up * * @param[in] values[] The array to check for the value. * * @param[in] count The size of the values array. * * @param[in] epsilon The epsilon used as margin for float comparison. */ void assert_float_not_in_set(double value, double values[], size_t count, double epsilon); #else #define assert_float_not_in_set(value, values, number_of_values, epsilon) \ if (number_of_values > 0) { \ double _cmocka_set[number_of_values]; \ for (size_t _i = 0; _i < number_of_values; _i++) { \ _cmocka_set[_i] = values[_i]; \ } \ _assert_float_not_in_set(value, _cmocka_set, number_of_values, epsilon, __FILE__, __LINE__); \ } #endif /** @} */ /* cmocka_asserts */ /** * @defgroup cmocka_call_order 🔢 Call Ordering * @ingroup cmocka * @brief Ensure functions are called in the correct sequence. * * Verify that functions are called in the expected order. * * This module provides functionality to ensure functions are called in a * specific sequence, independent of mock return values and parameter * checking. Both of the aforementioned do not verify the order in which * functions are called. * *
    *
  • expect_function_call(function) - The * expect_function_call() macro pushes an expectation onto the stack of * expected calls.
    • * *
  • function_called() - pops a value from the stack of * expected calls. function_called() is invoked within the mock object * that uses it. *
* * expect_function_call() and function_called() are intended to be used in * pairs. Cmocka will fail a test if there are more or less expected calls * created (e.g. expect_function_call()) than consumed with function_called(). * There are provisions such as ignore_function_calls() which allow this * restriction to be circumvented in tests where mock calls for the code under * test are not the focus of the test. function_called() must be called from * the same thread as expect_function_call(), and that thread must have been * initialized for use by cmocka (see also the [Threading section of the main * documentation page](index.html#main-threads)). * * The following example illustrates how a unit test instructs cmocka * to expect a function_called() from a particular mock, * chef_sing(): * * @code * void chef_sing(void); * * void code_under_test() * { * chef_sing(); * } * * void some_test(void **state) * { * expect_function_call(chef_sing); * code_under_test(); * } * @endcode * * The implementation of the mock then must check whether it was meant to * be called by invoking function_called(): * * @code * void chef_sing() * { * function_called(); * } * @endcode * * @{ */ #ifdef DOXYGEN /** * @brief Check that current mocked function is being called in the expected * order * * @see expect_function_call() */ void function_called(void); #else #define function_called() _function_called(__func__, __FILE__, __LINE__) #endif #ifdef DOXYGEN /** * @brief Store expected call(s) to a mock to be checked by function_called() * later. * * @param[in] #function The function which should should be called * * @param[in] times number of times this mock must be called * * @see function_called() */ void expect_function_calls(#function, const int times); #else #define expect_function_calls(function, times) \ _expect_function_call(cmocka_tostring(function), __FILE__, __LINE__, times) #endif #ifdef DOXYGEN /** * @brief Store expected single call to a mock to be checked by * function_called() later. * * @param[in] #function The function which should should be called * * @see function_called() */ void expect_function_call(#function); #else #define expect_function_call(function) \ _expect_function_call(cmocka_tostring(function), __FILE__, __LINE__, 1) #endif #ifdef DOXYGEN /** * @brief Expects function_called() from given mock at least once * * @param[in] #function The function which should should be called * * @see function_called() */ void expect_function_call_any(#function); #else #define expect_function_call_any(function) \ _expect_function_call(cmocka_tostring(function), __FILE__, __LINE__, -1) #endif #ifdef DOXYGEN /** * @brief Ignores function_called() invocations from given mock function. * * @param[in] #function The function which should should be called * * @see function_called() */ void ignore_function_calls(#function); #else #define ignore_function_calls(function) \ _expect_function_call(cmocka_tostring(function), __FILE__, __LINE__, -2) #endif /** @} */ /* cmocka_call_order */ /** * @defgroup cmocka_exec ▶️ Running Tests * @ingroup cmocka * @brief Execute test suites with setup and teardown functions. * * Test execution framework and test runners. * * This module provides the infrastructure for defining, organizing, and * running tests, including support for setup/teardown functions (fixtures), * test grouping, and multiple test runner macros. * * The following example illustrates how to define and run tests with * CMocka. * * @code * void Test0(void **state); * void Test1(void **state); * * int main(void) * { * const struct CMUnitTest tests[] = { * cmocka_unit_test(Test0), * cmocka_unit_test(Test1), * }; * * return cmocka_run_group_tests(tests, NULL, NULL); * } * @endcode * * @{ */ #ifdef DOXYGEN /** * @brief Forces the test to fail immediately and quit. */ void fail(void); #else #define fail() _fail(__FILE__, __LINE__) #endif #ifdef DOXYGEN /** * @brief Forces the test to not be executed, but marked as skipped. */ void skip(void); #else #define skip() _skip(__FILE__, __LINE__) #endif #ifdef DOXYGEN /** * @brief Forces the test to be stopped immediately. * * Call stop() to stop a running test. * The test is considered passed if there are no leftover values, otherwise a test failure * is signaled. * Calling stop() is especially useful in mocked functions that do not return, e.g reset the CPU. */ void stop(void); #else #define stop() _stop() #endif #ifdef DOXYGEN /** * @brief Forces the test to fail immediately and quit, printing the reason. * * @code * fail_msg("This is some error message for test"); * @endcode * * or * * @code * char *error_msg = "This is some error message for test"; * fail_msg("%s", error_msg); * @endcode */ void fail_msg(const char *msg, ...); #else #define fail_msg(msg, ...) do { \ cmocka_print_error("ERROR: " msg "\n", ##__VA_ARGS__); \ fail(); \ } while (0) #endif static inline void _unit_test_dummy(void **state) { (void)state; } /** Initializes a UnitTest structure. * * @deprecated This function was deprecated in favor of cmocka_unit_test */ #define unit_test(f) \ (CMOCKA_DEPRECATION_WARNING("unit_test: use cmocka_unit_test instead")( \ UnitTest){#f, f, UNIT_TEST_FUNCTION_TYPE_TEST}) /** @cond INTERNAL */ #define _unit_test_setup(test, setup) \ { #test "_" #setup, setup, UNIT_TEST_FUNCTION_TYPE_SETUP } /** @endcond */ /** Initializes a UnitTest structure with a setup function. * * @deprecated This function was deprecated in favor of cmocka_unit_test_setup */ #define unit_test_setup(test, setup) \ CMOCKA_DEPRECATION_WARNING( \ "unit_test_setup: use cmocka_unit_test_setup instead") \ _unit_test_setup(test, setup), unit_test(test), \ _unit_test_teardown(test, _unit_test_dummy) /** @cond INTERNAL */ #define _unit_test_teardown(test, teardown) \ { #test "_" #teardown, teardown, UNIT_TEST_FUNCTION_TYPE_TEARDOWN } /** @endcond */ /** Initializes a UnitTest structure with a teardown function. * * @deprecated This function was deprecated in favor of cmocka_unit_test_teardown */ #define unit_test_teardown(test, teardown) \ CMOCKA_DEPRECATION_WARNING( \ "unit_test_teardown: use cmocka_unit_test_teardown instead") \ _unit_test_setup(test, _unit_test_dummy), unit_test(test), \ _unit_test_teardown(test, teardown) /** Initializes a UnitTest structure for a group setup function. * * @deprecated This function was deprecated in favor of cmocka_run_group_tests */ #define group_test_setup(setup) \ (CMOCKA_DEPRECATION_WARNING( \ "group_test_setup: use cmocka_run_group_tests instead")(UnitTest){ \ "group_" #setup, setup, UNIT_TEST_FUNCTION_TYPE_GROUP_SETUP}) /** Initializes a UnitTest structure for a group teardown function. * * @deprecated This function was deprecated in favor of cmocka_run_group_tests */ #define group_test_teardown(teardown) \ (CMOCKA_DEPRECATION_WARNING( \ "group_test_teardown: use cmocka_run_group_tests instead")(UnitTest){ \ "group_" #teardown, teardown, UNIT_TEST_FUNCTION_TYPE_GROUP_TEARDOWN}) /** * Initialize an array of UnitTest structures with a setup function for a test * and a teardown function. Either setup or teardown can be NULL. * * @deprecated This function was deprecated in favor of * cmocka_unit_test_setup_teardown */ #define unit_test_setup_teardown(test, setup, teardown) \ CMOCKA_DEPRECATION_WARNING("unit_test_setup_teardown: use " \ "cmocka_unit_test_setup_teardown instead") \ _unit_test_setup(test, setup), unit_test(test), \ _unit_test_teardown(test, teardown) /** Initializes a CMUnitTest structure. */ #define cmocka_unit_test(f) { #f, f, NULL, NULL, NULL } /** Initializes a CMUnitTest structure with a setup function. */ #define cmocka_unit_test_setup(f, setup) { #f, f, setup, NULL, NULL } /** Initializes a CMUnitTest structure with a teardown function. */ #define cmocka_unit_test_teardown(f, teardown) { #f, f, NULL, teardown, NULL } /** * Initialize an array of CMUnitTest structures with a setup function for a test * and a teardown function. Either setup or teardown can be NULL. */ #define cmocka_unit_test_setup_teardown(f, setup, teardown) { #f, f, setup, teardown, NULL } /** * Initialize a CMUnitTest structure with given initial state. It will be passed * to test function as an argument later. It can be used when test state does * not need special initialization or was initialized already. * @note If the group setup function initialized the state already, it won't be * overridden by the initial state defined here. */ #define cmocka_unit_test_prestate(f, state) { #f, f, NULL, NULL, state } /** * Initialize a CMUnitTest structure with given initial state, setup and * teardown function. Any of these values can be NULL. Initial state is passed * later to setup function, or directly to test if none was given. * @note If the group setup function initialized the state already, it won't be * overridden by the initial state defined here. */ #define cmocka_unit_test_prestate_setup_teardown(f, setup, teardown, state) { #f, f, setup, teardown, state } #ifdef DOXYGEN /** * @brief Run tests specified by an array of CMUnitTest structures. * * @param[in] group_tests[] The array of unit tests to execute. * * @param[in] group_setup The setup function which should be called before * all unit tests are executed. * * @param[in] group_teardown The teardown function to be called after all * tests have finished. * * @return 0 on success, or the number of failed tests. * * @code * static int setup(void **state) { * int *answer = malloc(sizeof(int)); * if (answer == NULL) { * return -1; * } * *answer = 42; * * *state = answer; * * return 0; * } * * static int teardown(void **state) { * free(*state); * * return 0; * } * * static void null_test_success(void **state) { * (void) state; * } * * static void int_test_success(void **state) { * int *answer = *state; * assert_int_equal(*answer, 42); * } * * int main(void) { * const struct CMUnitTest tests[] = { * cmocka_unit_test(null_test_success), * cmocka_unit_test_setup_teardown(int_test_success, setup, teardown), * }; * * return cmocka_run_group_tests(tests, NULL, NULL); * } * @endcode * * @see cmocka_unit_test * @see cmocka_unit_test_setup * @see cmocka_unit_test_teardown * @see cmocka_unit_test_setup_teardown */ int cmocka_run_group_tests(const struct CMUnitTest group_tests[], CMFixtureFunction group_setup, CMFixtureFunction group_teardown); #else # define cmocka_run_group_tests(group_tests, group_setup, group_teardown) \ _cmocka_run_group_tests(#group_tests, group_tests, sizeof(group_tests) / sizeof((group_tests)[0]), group_setup, group_teardown) #endif #ifdef DOXYGEN /** * @brief Run tests specified by an array of CMUnitTest structures and specify * a name. * * @param[in] group_name The name of the group test. * * @param[in] group_tests[] The array of unit tests to execute. * * @param[in] group_setup The setup function which should be called before * all unit tests are executed. * * @param[in] group_teardown The teardown function to be called after all * tests have finished. * * @return 0 on success, or the number of failed tests. * * @code * static int setup(void **state) { * int *answer = malloc(sizeof(int)); * if (answer == NULL) { * return -1; * } * *answer = 42; * * *state = answer; * * return 0; * } * * static int teardown(void **state) { * free(*state); * * return 0; * } * * static void null_test_success(void **state) { * (void) state; * } * * static void int_test_success(void **state) { * int *answer = *state; * assert_int_equal(*answer, 42); * } * * int main(void) { * const struct CMUnitTest tests[] = { * cmocka_unit_test(null_test_success), * cmocka_unit_test_setup_teardown(int_test_success, setup, teardown), * }; * * return cmocka_run_group_tests_name("success_test", tests, NULL, NULL); * } * @endcode * * @see cmocka_unit_test * @see cmocka_unit_test_setup * @see cmocka_unit_test_teardown * @see cmocka_unit_test_setup_teardown */ int cmocka_run_group_tests_name(const char *group_name, const struct CMUnitTest group_tests[], CMFixtureFunction group_setup, CMFixtureFunction group_teardown); #else # define cmocka_run_group_tests_name(group_name, group_tests, group_setup, group_teardown) \ _cmocka_run_group_tests(group_name, group_tests, sizeof(group_tests) / sizeof((group_tests)[0]), group_setup, group_teardown) #endif /** @} */ /* cmocka_exec */ /** * @defgroup cmocka_alloc 🧩 Dynamic Memory Allocation * @ingroup cmocka * @brief Detect memory leaks, buffer overflows, and allocation errors. * * @warning This shouldn't be used anymore, better use * AddressSanitizer. * * To test for memory leaks, buffer overflows and underflows a module being * tested by cmocka should replace calls to malloc(), calloc() and free() to * test_malloc(), test_calloc() and test_free() respectively. Each time a block * is deallocated using test_free() it is checked for corruption, if a corrupt * block is found a test failure is signalled. All blocks allocated using the * test_*() allocation functions are tracked by the cmocka library. When a test * completes if any allocated blocks (memory leaks) remain they are reported * and a test failure is signalled. * * For simplicity cmocka currently executes all tests in one process. Therefore * all test cases in a test application share a single address space which * means memory corruption from a single test case could potentially cause the * test application to exit prematurely. * * Automatic Allocation Redirection (Deprecated): * * When both UNIT_TESTING and ALLOCATION_TESTING are defined, the standard * C library allocation functions (malloc, calloc, realloc, free) are * automatically redirected to cmocka's test allocators. This enables * automatic memory leak detection and helps ensure proper memory management * in tested code. * * @note This feature is deprecated and should not be used in new code. * Better use * AddressSanitizer. * * To enable allocation testing, define both macros before including cmocka.h: * * @code * #include * * #define UNIT_TESTING 1 * #define ALLOCATION_TESTING 1 * #include * * // This code will have malloc/free automatically redirected * void* ptr = malloc(100); // Actually calls test_malloc() * free(ptr); // Actually calls test_free() * @endcode * * With ALLOCATION_TESTING enabled: * - malloc() → test_malloc() * - calloc() → test_calloc() * - realloc() → test_realloc() * - free() → test_free() * * @warning Mixing regular allocations with test allocations can lead to * memory corruption. Ensure consistent usage throughout your * test code. * @{ */ #ifdef DOXYGEN /** * @brief Test function overriding malloc. * * @param[in] size The bytes which should be allocated. * * @return A pointer to the allocated memory or NULL on error. * * @code * #ifdef UNIT_TESTING * extern void* _test_malloc(const size_t size, const char* file, const int line); * * #define malloc(size) _test_malloc(size, __FILE__, __LINE__) * #endif * * void leak_memory() { * int * const temporary = (int*)malloc(sizeof(int)); * *temporary = 0; * } * @endcode * * @see malloc(3) */ void *test_malloc(size_t size); #else #define test_malloc(size) _test_malloc(size, __FILE__, __LINE__) #endif #ifdef DOXYGEN /** * @brief Test function overriding calloc. * * The memory is set to zero. * * @param[in] nmemb The number of elements for an array to be allocated. * * @param[in] size The size in bytes of each array element to allocate. * * @return A pointer to the allocated memory, NULL on error. * * @see calloc(3) */ void *test_calloc(size_t nmemb, size_t size); #else #define test_calloc(num, size) _test_calloc(num, size, __FILE__, __LINE__) #endif #ifdef DOXYGEN /** * @brief Test function overriding realloc which detects buffer overruns * and memory leaks. * * @param[in] ptr The memory block which should be changed. * * @param[in] size The bytes which should be allocated. * * @return The newly allocated memory block, NULL on error. */ void *test_realloc(void *ptr, size_t size); #else #define test_realloc(ptr, size) _test_realloc(ptr, size, __FILE__, __LINE__) #endif #ifdef DOXYGEN /** * @brief Test function overriding free(3). * * @param[in] ptr The pointer to the memory space to free. * * @see free(3). */ void test_free(void *ptr); #else #define test_free(ptr) _test_free(ptr, __FILE__, __LINE__) #endif #if defined(UNIT_TESTING) && defined(ALLOCATION_TESTING) #define malloc test_malloc #define realloc test_realloc #define calloc test_calloc #define free test_free #endif /* UNIT_TESTING && ALLOCATION_TESTING */ /** @} */ /* cmocka_alloc */ /** * @defgroup cmocka_mock_assert 🎯 Standard Assertions * @ingroup cmocka * @brief Test code that uses assert(3) from the standard C library. * * How to handle assert(3) of the standard C library. * * Runtime assert macros like the standard C library's assert() should be * redefined in modules being tested to use cmocka's mock_assert() function. * Normally mock_assert() signals a test failure. If a function is called using * the expect_assert_failure() macro, any calls to mock_assert() within the * function will result in the execution of the test. If no calls to * mock_assert() occur during the function called via expect_assert_failure() a * test failure is signalled. * * @{ */ /** * @brief Function to replace assert(3) in tested code. * * In conjunction with check_assert() it's possible to determine whether an * assert condition has failed without stopping a test. * * @param[in] result The expression to assert. * * @param[in] expression The expression as string. * * @param[in] file The file mock_assert() is called. * * @param[in] line The line mock_assert() is called. * * @code * #ifdef UNIT_TESTING * extern void mock_assert(const int result, const char* const expression, * const char * const file, const int line); * * #undef assert * #define assert(expression) \ * mock_assert((int)(expression), #expression, __FILE__, __LINE__); * #endif * * void increment_value(int * const value) { * assert(value); * (*value) ++; * } * @endcode * * @see assert(3) * @see expect_assert_failure */ void mock_assert(const int result, const char* const expression, const char * const file, const int line); #ifdef DOXYGEN /** * @brief Ensure that mock_assert() is called. * * If mock_assert() is called the assert expression string is returned. * * @param[in] fn_call The function will will call mock_assert(). * * @code * #define assert mock_assert * * void showmessage(const char *message) { * assert(message); * } * * int main(int argc, const char* argv[]) { * expect_assert_failure(show_message(NULL)); * printf("succeeded\n"); * return 0; * } * @endcode * */ void expect_assert_failure(function fn_call); #else #define expect_assert_failure(function_call) \ { \ global_expecting_assert = 1; \ if (setjmp(global_expect_assert_env) != 0) { \ print_message("Expected assertion %s occurred\n", \ global_last_failed_assert); \ global_expecting_assert = 0; \ } else { \ function_call ; \ global_expecting_assert = 0; \ print_error("Expected assert in %s\n", #function_call); \ _fail(__FILE__, __LINE__); \ } \ } #endif /** @} */ /* cmocka_mock_assert */ /** * @ingroup cmocka_util * * CMocka value data type. * * Allows storing multiple types of values in CMocka functions without using * undefined behavior. */ typedef union { /** Holds signed integral types */ intmax_t int_val; /** Holds integral types */ uintmax_t uint_val; /** Holds floating-point type */ float float_val; /** Holds double/real floating-pointing types*/ double real_val; // TODO: Should we use `long double` instead /** Holds pointer data */ void *ptr; /** Holds pointer data (const) */ const void *const_ptr; // The following aren't used by CMocka currently, but are added to avoid // breaking ABI compatibility in the future /** Holds function pointer data */ void *(*func)(void); } CMockaValueData; #ifndef DOXYGEN /** * @deprecated This type was replaced by uintmax_t for better type clarity. * Use uintmax_t directly instead. */ #define LargestIntegralType uintmax_t /** * @deprecated Use cast_ptr_to_uintmax_type instead */ #if defined(__GNUC__) #define cast_ptr_to_largest_integral_type(value) \ __extension__({ \ CMOCKA_DEPRECATION_WARNING( \ "cast_ptr_to_largest_integral_type: " \ "use cast_ptr_to_uintmax_type instead"); \ cast_ptr_to_uintmax_type(value); \ }) #else #define cast_ptr_to_largest_integral_type(value) \ cast_ptr_to_uintmax_type(value) #endif #endif /** * @ingroup cmocka_exec * * Function prototype for setup, test and teardown functions. */ typedef void (*UnitTestFunction)(void **state); /** * @ingroup cmocka_param * * Function that determines whether a function parameter value is correct (old API). */ typedef int (*CheckParameterValue)(const uintmax_t value, const uintmax_t check_value_data); /** * @ingroup cmocka_param * * Function that determines whether a function parameter value is correct (new API with CMockaValueData). */ typedef int (*CheckParameterValueData)(const CMockaValueData value, const CMockaValueData check_value_data); /** * @ingroup cmocka_param * * Function that determines whether a function parameter value is correct. */ typedef int (*CheckIntParameterValue)(const intmax_t value, const intmax_t check_value_data); /** * @ingroup cmocka_param * * Function that determines whether a function parameter value is correct. */ typedef int (*CheckUintParameterValue)(const uintmax_t value, const uintmax_t check_value_data); /** * @ingroup cmocka_exec * * Type of the unit test function. */ typedef enum UnitTestFunctionType { UNIT_TEST_FUNCTION_TYPE_TEST = 0, UNIT_TEST_FUNCTION_TYPE_SETUP, UNIT_TEST_FUNCTION_TYPE_TEARDOWN, UNIT_TEST_FUNCTION_TYPE_GROUP_SETUP, UNIT_TEST_FUNCTION_TYPE_GROUP_TEARDOWN, } UnitTestFunctionType; /** * @ingroup cmocka_exec * * Stores a unit test function with its name and type. * NOTE: Every setup function must be paired with a teardown function. It's * possible to specify NULL function pointers. */ typedef struct UnitTest { const char* name; UnitTestFunction function; UnitTestFunctionType function_type; } UnitTest; /** * @ingroup cmocka_exec */ typedef struct GroupTest { UnitTestFunction setup; UnitTestFunction teardown; const UnitTest *tests; const size_t number_of_tests; } GroupTest; /** * @ingroup cmocka_exec * * Function prototype for test functions. */ typedef void (*CMUnitTestFunction)(void **state); /** * @ingroup cmocka_exec * * Function prototype for setup and teardown functions. */ typedef int (*CMFixtureFunction)(void **state); /** * @ingroup cmocka_exec */ struct CMUnitTest { const char *name; CMUnitTestFunction test_func; CMFixtureFunction setup_func; CMFixtureFunction teardown_func; void *initial_state; }; /** * @ingroup cmocka_param * * Location within some source code. */ typedef struct SourceLocation { const char* file; int line; } SourceLocation; /** * @ingroup cmocka_param * * Event that's called to check a parameter value (old API). */ typedef struct CheckParameterEvent { SourceLocation location; const char *parameter_name; CheckParameterValue check_value; uintmax_t check_value_data; } CheckParameterEvent; /** * @ingroup cmocka_param * * Event that's called to check a parameter value (new API with CMockaValueData). */ typedef struct CheckParameterEventData { SourceLocation location; const char *parameter_name; CheckParameterValueData check_value; CMockaValueData check_value_data; } CheckParameterEventData; /** * @defgroup cmocka_config 🔧 Configuration and Output * @ingroup cmocka * @brief Control test output formats and execution behavior. * * Configure test execution behavior and output formatting. * * This module provides functions to customize CMocka's behavior, including * setting custom output callbacks, controlling output format (STANDARD, * SUBUNIT, TAP, XML), and filtering which tests to run or skip. * * @{ */ /* Standard output and error print methods. */ void print_message(const char* const format, ...) CMOCKA_PRINTF_ATTRIBUTE(1, 2); void print_error(const char* const format, ...) CMOCKA_PRINTF_ATTRIBUTE(1, 2); void vprint_message(const char* const format, va_list args) CMOCKA_PRINTF_ATTRIBUTE(1, 0); void vprint_error(const char* const format, va_list args) CMOCKA_PRINTF_ATTRIBUTE(1, 0); /** * Callbacks which can be set via cmocka_set_callbacks(). * * @ingroup cmocka_config * @sa cmocka_set_callbacks() */ struct CMCallbacks { /** A callback for printing out standard messages. * The supplied callback function will be invoked by the standard output * print methods. If no callback has been supplied, the default action * is to print to `stdout`. * * The one exception at present is XML output, which is always written directly * to a file handle, even if that is set to `stdout`. */ void (*vprint_message)(const char * const format, va_list args); /** A callback for printing out error messages. * The supplied callback function will be invoked by the standard output * print methods. If no callback has been supplied, the default action * is to print to `stdout`. * * The one exception at present is XML output, which is always written directly * to a file handle, even if that is set to `stdout`. */ void (*vprint_error)(const char * const format, va_list args); }; /** * @brief Set callback functions for CMocka. * * Input is a structure containing function pointers to one or more * user-supplied callback functions. A NULL pointer for a particular * callback will set that callback to the default implementation. * * See the CMCallbacks documentation for details of each callback. * * @param[in] f_callbacks A structure containing the user callbacks to use. * * @ingroup cmocka_config * @sa CMCallbacks */ void cmocka_set_callbacks(const struct CMCallbacks *f_callbacks); /** * @brief Output format options for test results. * * These are bitfield flags that can be combined using bitwise OR to enable * multiple output formats simultaneously. * * @ingroup cmocka_config */ enum cm_message_output { /** Standard CMocka output format (bit 0) */ CM_OUTPUT_STANDARD = 0x00000001, /** Alias for CM_OUTPUT_STANDARD (for API compatibility) */ CM_OUTPUT_STDOUT = 0x00000001, /** Subunit output format for test result aggregation (bit 1) */ CM_OUTPUT_SUBUNIT = 0x00000002, /** Test Anything Protocol (TAP) output format (bit 2) */ CM_OUTPUT_TAP = 0x00000004, /** JUnit-compatible XML output format (bit 3) */ CM_OUTPUT_XML = 0x00000008, }; #ifdef DOXYGEN /** * @deprecated Use cmocka_print_error() */ void cm_print_error(const char* const format, ...); #else #define cm_print_error(format, ...) \ do { \ CMOCKA_DEPRECATION_WARNING( \ "cm_print_error: use cmocka_print_error instead") \ cmocka_print_error(format, ##__VA_ARGS__); \ } while (0) #endif /** * @brief Print error message using the cmocka output format. * * This prints an error message using the message output defined by the * environment variable CMOCKA_MESSAGE_OUTPUT or * cmocka_set_message_output(). * * @param format The format string fprintf(3) uses. * @param ... The parameters used to fill format. * * @ingroup cmocka_config */ void cmocka_print_error(const char* const format, ...) CMOCKA_PRINTF_ATTRIBUTE(1, 2); /** * @brief Function to set the output format for a test. * * The output format(s) for the test can either be set globally using this * function or overwritten with environment variable CMOCKA_MESSAGE_OUTPUT. * * The environment variable can be set to STANDARD, SUBUNIT, TAP or XML. * Multiple outputs separated with comma are permitted. * (e.g. export CMOCKA_MESSAGE_OUTPUT=STANDARD,XML) * * @param[in] output The output format from cm_message_output to use * for the test. For multiple outputs OR options * together. * * @ingroup cmocka_config */ void cmocka_set_message_output(uint32_t output); /** * @brief Set a pattern to only run the test matching the pattern. * * This allows to filter tests and only run the ones matching the pattern. * The pattern can include two wildcards. The first is '*', a wildcard that * matches zero or more characters, or '?', a wildcard that matches exactly * one character. * * The same can also be achieved by setting the environment variable * CMOCKA_TEST_FILTER, without needing to recompile the application. * * @param[in] pattern The pattern to match, e.g. "test_wurst*" * * @ingroup cmocka_config */ void cmocka_set_test_filter(const char *pattern); /** * @brief Set a pattern to skip tests matching the pattern. * * This allows to filter tests and skip the ones matching the pattern. The * pattern can include two wildcards. The first is '*', a wildcard that * matches zero or more characters, or '?', a wildcard that matches exactly * one character. * * The same can also be achieved by setting the environment variable * CMOCKA_SKIP_FILTER, without needing to recompile the application. * * @param[in] pattern The pattern to match, e.g. "test_wurst*" * * @ingroup cmocka_config */ void cmocka_set_skip_filter(const char *pattern); /** @} */ /* cmocka_config */ /** * @cond INTERNAL * * Internal functions used by CMocka macros. * * These functions are implementation details and should not be called directly. * Users should only use the documented macros that wrap these functions. * These are excluded from the documentation to avoid confusion. */ /* Used by expect_assert_failure() and mock_assert(). */ CMOCKA_DLLEXTERN extern int global_expecting_assert; CMOCKA_DLLEXTERN extern jmp_buf global_expect_assert_env; CMOCKA_DLLEXTERN extern const char * global_last_failed_assert; /* Retrieves a value for the given function, as set by "will_return". */ CMockaValueData _mock(const char *const function, const char *const file, const int line, const char *name); CMockaValueData _mock_parameter(const char *const function, const char *name, const char *const file, const int line, const char *type); bool _has_mock(const char *const function); void _expect_function_call( const char * const function_name, const char * const file, const int line, const int count); void _function_called(const char * const function, const char* const file, const int line); /* Old API function using uintmax_t */ void _expect_check( const char* const function, const char* const parameter, const char* const file, const int line, const CheckParameterValue check_function, const uintmax_t check_data, CheckParameterEvent * const event, const int count) CMOCKA_DEPRECATED; /* New API function using CMockaValueData */ void _expect_check_data( const char* const function, const char* const parameter, const char* const file, const int line, const CheckParameterValueData check_function, const CMockaValueData check_data, CheckParameterEventData * const event, const int count); void _expect_int_in_set(const char *const function, const char *const parameter, const char *const file, const size_t line, const intmax_t values[], const size_t number_of_values, const size_t count); void _expect_uint_in_set(const char *const function, const char *const parameter, const char *const file, const size_t line, const uintmax_t values[], const size_t number_of_values, const size_t count); void _expect_float_in_set(const char *const function, const char *const parameter, const char *const file, const size_t line, const double values[], const size_t number_of_values, const double epsilon, const size_t count); void _expect_not_in_set( const char* const function, const char* const parameter, const char* const file, const int line, const uintmax_t values[], const size_t number_of_values, const int count); void _expect_int_not_in_set(const char *const function, const char *const parameter, const char *const file, const size_t line, const intmax_t values[], const size_t number_of_values, const size_t count); void _expect_uint_not_in_set(const char *const function, const char *const parameter, const char *const file, const size_t line, const uintmax_t values[], const size_t number_of_values, const size_t count); void _expect_float_not_in_set( const char* const function, const char* const parameter, const char* const file, const size_t line, const double values[], const size_t number_of_values, const double epsilon, const size_t count); void _expect_in_range(const char *const function, const char *const parameter, const char *const file, const int line, const uintmax_t minimum, const uintmax_t maximum, const int count) CMOCKA_DEPRECATED; void _expect_int_in_range(const char *const function, const char *const parameter, const char *const file, const size_t line, const intmax_t minimum, const intmax_t maximum, const size_t count); void _expect_uint_in_range(const char *const function, const char *const parameter, const char *const file, const size_t line, const uintmax_t minimum, const uintmax_t maximum, const size_t count); void _expect_not_in_range( const char* const function, const char* const parameter, const char* const file, const int line, const uintmax_t minimum, const uintmax_t maximum, const int count); void _expect_int_not_in_range(const char *const function, const char *const parameter, const char *const file, const size_t line, const intmax_t minimum, const intmax_t maximum, const size_t count); void _expect_uint_not_in_range(const char *const function, const char *const parameter, const char *const file, const size_t line, const uintmax_t minimum, const uintmax_t maximum, const size_t count); void _expect_float_in_range( const char* const function, const char* const parameter, const char* const file, const int line, const double minimum, const double maximum, const double epsilon, const int count); void _expect_float_not_in_range( const char* const function, const char* const parameter, const char* const file, const int line, const double minimum, const double maximum, const double epsilon, const int count); void _expect_value( const char* const function, const char* const parameter, const char* const file, const int line, const uintmax_t value, const int count); void _expect_int_value(const char *const function, const char *const parameter, const char *const file, const size_t line, const intmax_t value, const size_t count); void _expect_uint_value(const char *const function, const char *const parameter, const char *const file, const size_t line, const uintmax_t value, const size_t count); void _expect_int_not_value(const char *const function, const char *const parameter, const char *const file, const size_t line, const intmax_t value, const size_t count); void _expect_uint_not_value(const char *const function, const char *const parameter, const char *const file, const size_t line, const uintmax_t value, const size_t count); void _expect_not_value( const char* const function, const char* const parameter, const char* const file, const int line, const uintmax_t value, const int count); void _expect_float( const char* const function, const char* const parameter, const char* const file, const int line, const double value, const double epsilon, const int count); void _expect_not_float( const char* const function, const char* const parameter, const char* const file, const int line, const double value, const double epsilon, const int count); void _expect_double(const char *const function, const char *const parameter, const char *const file, const int line, const double value, const double epsilon, const int count); void _expect_not_double(const char *const function, const char *const parameter, const char *const file, const int line, const double value, const double epsilon, const int count); void _expect_string( const char* const function, const char* const parameter, const char* const file, const int line, const char* string, const int count); void _expect_not_string( const char* const function, const char* const parameter, const char* const file, const int line, const char* string, const int count); void _expect_memory( const char* const function, const char* const parameter, const char* const file, const int line, const void* const memory, const size_t size, const int count); void _expect_not_memory( const char* const function, const char* const parameter, const char* const file, const int line, const void* const memory, const size_t size, const int count); void _expect_any( const char* const function, const char* const parameter, const char* const file, const int line, const int count); void _check_expected( const char * const function_name, const char * const parameter_name, const char* file, const int line, const CMockaValueData value); void _will_return(const char *const function_name, const char *const file, const int line, const char *name, const CMockaValueData value, const int count); void _will_set_parameter(const char *const function_name, const char *name, const char *const file, const int line, const char *type, const CMockaValueData value, const int count); void _assert_true(const uintmax_t result, const char* const expression, const char * const file, const int line); void _assert_false(const uintmax_t result, const char * const expression, const char * const file, const int line); void _assert_return_code(const intmax_t result, const int32_t error, const char * const expression, const char * const file, const int line); void _assert_float_equal(const float a, const float n, const float epsilon, const char* const file, const int line); void _assert_float_not_equal(const float a, const float n, const float epsilon, const char* const file, const int line); void _assert_double_equal(const double a, const double n, const double epsilon, const char* const file, const int line); void _assert_double_not_equal(const double a, const double n, const double epsilon, const char* const file, const int line); void _assert_int_equal(const intmax_t a, const intmax_t b, const char * const file, const int line); void _assert_int_not_equal(const intmax_t a, const intmax_t b, const char * const file, const int line); void _assert_uint_equal(const uintmax_t a, const uintmax_t b, const char * const file, const int line); void _assert_uint_not_equal(const uintmax_t a, const uintmax_t b, const char * const file, const int line); CMOCKA_NO_ACCESS_ATTRIBUTE void _assert_ptr_equal_msg(const void *a, const void *b, const char *const file, const int line, const char *const msg); CMOCKA_NO_ACCESS_ATTRIBUTE void _assert_ptr_not_equal_msg(const void *a, const void *b, const char *const file, const int line, const char *const msg); void _assert_string_equal(const char * const a, const char * const b, const char * const file, const int line); void _assert_string_not_equal(const char * const a, const char * const b, const char *file, const int line); void _assert_memory_equal(const void * const a, const void * const b, const size_t size, const char* const file, const int line); void _assert_memory_not_equal(const void * const a, const void * const b, const size_t size, const char* const file, const int line); void _assert_int_in_range(const intmax_t value, const intmax_t minimum, const intmax_t maximum, const char* const file, const int line); void _assert_int_not_in_range(const intmax_t value, const intmax_t minimum, const intmax_t maximum, const char *const file, const int line); void _assert_uint_in_range(const uintmax_t value, const uintmax_t minimum, const uintmax_t maximum, const char* const file, const int line); void _assert_uint_not_in_range(const uintmax_t value, const uintmax_t minimum, const uintmax_t maximum, const char* const file, const int line); void _assert_float_in_range(const double value, const double minimum, const double maximum, const double epsilon, const char* const file, const int line); void _assert_float_not_in_range(const double value, const double minimum, const double maximum, const double epsilon, const char* const file, const int line); void _assert_not_in_set( const uintmax_t value, const uintmax_t values[], const size_t number_of_values, const char* const file, const int line); void _assert_int_in_set(const intmax_t value, const intmax_t values[], const size_t number_of_values, const char *const file, const int line); void _assert_int_not_in_set(const intmax_t value, const intmax_t values[], const size_t number_of_values, const char *const file, const int line); void _assert_uint_in_set(const uintmax_t value, const uintmax_t values[], const size_t number_of_values, const char *const file, const int line); void _assert_uint_not_in_set(const uintmax_t value, const uintmax_t values[], const size_t number_of_values, const char *const file, const int line); void _assert_float_in_set(const double value, const double values[], const size_t number_of_values, const double epsilon, const char *const file, const int line); void _assert_float_not_in_set(const double value, const double values[], const size_t number_of_values, const double epsilon, const char *const file, const int line); void* _test_malloc(const size_t size, const char* file, const int line); void* _test_realloc(void *ptr, const size_t size, const char* file, const int line); void* _test_calloc(const size_t number_of_elements, const size_t size, const char* file, const int line); void _test_free(void* const ptr, const char* file, const int line); CMOCKA_NORETURN void _fail(const char * const file, const int line); CMOCKA_NORETURN void _skip(const char * const file, const int line); CMOCKA_NORETURN void _stop(void); /* Test runner */ int _cmocka_run_group_tests(const char *group_name, const struct CMUnitTest * const tests, const size_t num_tests, CMFixtureFunction group_setup, CMFixtureFunction group_teardown); /** @endcond */ #ifdef __cplusplus } /* extern "C" */ #endif #endif /* CMOCKA_H_ */