| /* |
| * Copyright 2008 Google Inc. |
| * |
| * 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 |
| #if _MSC_VER < 1500 |
| #ifdef __cplusplus |
| extern "C" { |
| #endif /* __cplusplus */ |
| int __stdcall IsDebuggerPresent(); |
| #ifdef __cplusplus |
| } /* extern "C" */ |
| #endif /* __cplusplus */ |
| #endif /* _MSC_VER < 1500 */ |
| #endif /* _WIN32 */ |
| |
| /* |
| * These headers or their equivalents should be included prior to including |
| * this header file. |
| * |
| * #include <stdarg.h> |
| * #include <stddef.h> |
| * #include <setjmp.h> |
| * |
| * This allows test applications to use custom definitions of C standard |
| * library functions and types. |
| */ |
| |
| /* For those who are used to __func__ from gcc. */ |
| #ifndef __func__ |
| #define __func__ __FUNCTION__ |
| #endif |
| |
| /* GCC have printf type attribute check. */ |
| #ifdef __GNUC__ |
| #define PRINTF_ATTRIBUTE(a,b) __attribute__ ((__format__ (__printf__, a, b))) |
| #else |
| #define PRINTF_ATTRIBUTE(a,b) |
| #endif /* __GNUC__ */ |
| |
| /** |
| * @defgroup cmocka The CMocka API |
| * |
| * TODO Describe cmocka. |
| * |
| * @{ |
| */ |
| |
| /* |
| * Largest integral type. This type should be large enough to hold any |
| * pointer or integer supported by the compiler. |
| */ |
| #ifndef LargestIntegralType |
| #define LargestIntegralType unsigned long long |
| #endif /* LargestIntegralType */ |
| |
| /* Printf format used to display LargestIntegralType. */ |
| #ifndef LargestIntegralTypePrintfFormat |
| #ifdef _WIN32 |
| #define LargestIntegralTypePrintfFormat "0x%I64x" |
| #else |
| #define LargestIntegralTypePrintfFormat "%#llx" |
| #endif /* _WIN32 */ |
| #endif /* LargestIntegralTypePrintfFormat */ |
| |
| /* Perform an unsigned cast to LargestIntegralType. */ |
| #define cast_to_largest_integral_type(value) \ |
| ((LargestIntegralType)((size_t)(value))) |
| |
| /* Smallest integral type capable of holding a pointer. */ |
| #if !defined(_UINTPTR_T) && !defined(_UINTPTR_T_DEFINED) |
| # if defined(_WIN32) |
| /* WIN32 is an ILP32 platform */ |
| typedef unsigned int uintptr_t; |
| # elif defined(_WIN64) |
| typedef unsigned long int uintptr_t |
| # else /* _WIN32 */ |
| |
| /* ILP32 and LP64 platforms */ |
| # ifdef __WORDSIZE /* glibc */ |
| # if __WORDSIZE == 64 |
| typedef unsigned long int uintptr_t; |
| # else |
| typedef unsigned int uintptr_t; |
| # endif /* __WORDSIZE == 64 */ |
| # else /* __WORDSIZE */ |
| # if defined(_LP64) || defined(_I32LPx) |
| typedef unsigned long int uintptr_t; |
| # else |
| typedef unsigned int uintptr_t; |
| # endif |
| # endif /* __WORDSIZE */ |
| # endif /* _WIN32 */ |
| |
| # define _UINTPTR_T |
| # define _UINTPTR_T_DEFINED |
| #endif /* !defined(_UINTPTR_T) || !defined(_UINTPTR_T_DEFINED) */ |
| |
| /* Perform an unsigned cast to uintptr_t. */ |
| #define cast_to_pointer_integral_type(value) \ |
| ((uintptr_t)(value)) |
| |
| /* Perform a cast of a pointer to uintmax_t */ |
| #define cast_ptr_to_largest_integral_type(value) \ |
| cast_to_largest_integral_type(cast_to_pointer_integral_type(value)) |
| |
| /** |
| * @defgroup cmocka_mock Mock Objects |
| * @ingroup cmocka |
| * |
| * Mock objects 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. |
| * |
| * <ul> |
| * <li><strong>will_return(function, value)</strong> - The will_return() macro |
| * pushes a value onto a stack of mock values. This macro is intended to be |
| * used by the unit test itself, while programming the behaviour of the mocked |
| * object.</li> |
| * |
| * <li><strong>mock()</strong> - the mock macro pops a value from a stack of |
| * test values. The user of the mock() macro is the mocked object that uses it |
| * to learn how it should behave.</li> |
| * </ul> |
| * |
| * 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 |
| * stack 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(chef_cook, "hotdog"); |
| * will_return(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) |
| * { |
| * check_expected(order); |
| * } |
| * @endcode |
| * |
| * For a complete example please at a look |
| * <a href="http://git.cryptomilk.org/projects/cmocka.git/tree/example/chef_wrap/waiter_test_wrap.c">here</a>. |
| * |
| * @{ |
| */ |
| |
| #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() |
| */ |
| void *mock(void); |
| #else |
| #define mock() _mock(__func__, __FILE__, __LINE__) |
| #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. |
| * |
| * @param[in] #type The expected type of the return value |
| * |
| * @return The value which was stored to return by this function. |
| * |
| * @code |
| * int param; |
| * |
| * param = mock_type(int); |
| * @endcode |
| * |
| * @see will_return() |
| * @see mock() |
| * @see mock_ptr_type() |
| */ |
| void *mock_type(#type); |
| #else |
| #define mock_type(type) ((type) mock()) |
| #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 but also casted to uintptr_t to make |
| * sure the result has a valid size to be used as a pointer. |
| * |
| * @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() |
| * @see mock() |
| * @see mock_type() |
| */ |
| void *mock_ptr_type(#type); |
| #else |
| #define mock_ptr_type(type) ((type) (uintptr_t) mock()) |
| #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 will_return_count() |
| */ |
| void will_return(#function, void *value); |
| #else |
| #define will_return(function, value) \ |
| _will_return(#function, __FILE__, __LINE__, \ |
| cast_to_largest_integral_type(value), 1) |
| #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(). |
| * |
| * @param[in] count The parameter returns the number of times the value should |
| * be returned by mock(). If count is set to -1 the value will |
| * always be returned. |
| * |
| * @see mock() |
| */ |
| void will_return_count(#function, void *value, int count); |
| #else |
| #define will_return_count(function, value, count) \ |
| _will_return(#function, __FILE__, __LINE__, \ |
| cast_to_largest_integral_type(value), count) |
| #endif |
| |
| #ifdef DOXYGEN |
| /** |
| * @brief Store a value that will be always returned by mock(). |
| * |
| * @param[in] #function The function which should return the given value. |
| * |
| * @param[in] value The value to be returned by mock(). |
| * |
| * This is equivalent to: |
| * @code |
| * will_return_count(function, value, -1); |
| * @endcode |
| * |
| * @see will_return_count() |
| * @see mock() |
| */ |
| void will_return_always(#function, void *value); |
| #else |
| #define will_return_always(function, value) \ |
| will_return_count(function, (value), -1) |
| #endif |
| |
| /** @} */ |
| |
| /** |
| * @defgroup cmocka_param Checking Parameters |
| * @ingroup cmocka |
| * |
| * 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() macro. |
| * |
| * 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(order); |
| * } |
| * @endcode |
| * |
| * For a complete example please at a look at |
| * <a href="http://git.cryptomilk.org/projects/cmocka.git/tree/example/chef_wrap/waiter_test_wrap.c">here</a> |
| * |
| * @{ |
| */ |
| |
| /* |
| * Add a custom parameter checking function. If the event parameter is NULL |
| * the event structure is allocated internally by this function. If event |
| * parameter is provided it must be allocated on the heap and doesn't need to |
| * be deallocated by the caller. |
| */ |
| #ifdef DOXYGEN |
| /** |
| * @brief Add a custom parameter checking function. |
| * |
| * If the event parameter is NULL the event structure is allocated internally |
| * by this function. If the parameter is provided it must be allocated on the |
| * heap and doesn't need to be deallocated by the caller. |
| * |
| * @param[in] #function The fuction to add a custom paramater checking function |
| * for. |
| * |
| * @param[in] #parameter The parametes passed to the function. |
| * |
| * @param[in] #check_function The check function to call. |
| * |
| * @param[in] check_data The data to pass to the check function. |
| */ |
| void expect_check(#function, #parameter, #check_function, const void *check_data); |
| #else |
| #define expect_check(function, parameter, check_function, check_data) \ |
| _expect_check(#function, #parameter, __FILE__, __LINE__, check_function, \ |
| cast_to_largest_integral_type(check_data), NULL, 0) |
| #endif |
| |
| #if DOXYGEN |
| /** |
| * @brief Add an event to check if the parameter value is part of the provided |
| * 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, uintmax_t value_array[]); |
| #else |
| #define expect_in_set(function, parameter, value_array) \ |
| expect_in_set_count(function, parameter, value_array, 1) |
| #endif |
| |
| #if DOXYGEN |
| /** |
| * @brief Add an event to check if the parameter value is part of the provided |
| * 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_in_set_count(#function, #parameter, uintmax_t value_array[], size_t count); |
| #else |
| #define expect_in_set_count(function, parameter, value_array, count) \ |
| _expect_in_set(#function, #parameter, __FILE__, __LINE__, value_array, \ |
| sizeof(value_array) / sizeof((value_array)[0]), count) |
| #endif |
| |
| #if DOXYGEN |
| /** |
| * @brief Add an event to check if the parameter value is not part of the |
| * provided 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_not_in_set(#function, #parameter, uintmax_t value_array[]); |
| #else |
| #define expect_not_in_set(function, parameter, value_array) \ |
| expect_not_in_set_count(function, parameter, value_array, 1) |
| #endif |
| |
| #if DOXYGEN |
| /** |
| * @brief Add an event to check if the parameter value is not part of the |
| * provided 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_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) \ |
| _expect_not_in_set( \ |
| #function, #parameter, __FILE__, __LINE__, value_array, \ |
| sizeof(value_array) / sizeof((value_array)[0]), count) |
| #endif |
| |
| |
| #if 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() 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_in_range(#function, #parameter, uintmax_t minimum, uintmax_t maximum); |
| #else |
| #define expect_in_range(function, parameter, minimum, maximum) \ |
| expect_in_range_count(function, parameter, minimum, maximum, 1) |
| #endif |
| |
| #if 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() 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_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) \ |
| _expect_in_range(#function, #parameter, __FILE__, __LINE__, minimum, \ |
| maximum, count) |
| #endif |
| |
| #if 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 |
| |
| #if 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(#function, #parameter, __FILE__, __LINE__, \ |
| minimum, maximum, count) |
| #endif |
| |
| #if DOXYGEN |
| /** |
| * @brief Add an event to check if a 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_value(#function, #parameter, uintmax_t value); |
| #else |
| #define expect_value(function, parameter, value) \ |
| expect_value_count(function, parameter, value, 1) |
| #endif |
| |
| #if DOXYGEN |
| /** |
| * @brief Add an event to repeatedly check if a 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_value_count(#function, #parameter, uintmax_t value, size_t count); |
| #else |
| #define expect_value_count(function, parameter, value, count) \ |
| _expect_value(#function, #parameter, __FILE__, __LINE__, \ |
| cast_to_largest_integral_type(value), count) |
| #endif |
| |
| #if DOXYGEN |
| /** |
| * @brief Add an event to check if a parameter 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 to check. |
| * |
| * @see check_expected(). |
| */ |
| void expect_not_value(#function, #parameter, uintmax_t value); |
| #else |
| #define expect_not_value(function, parameter, value) \ |
| expect_not_value_count(function, parameter, value, 1) |
| #endif |
| |
| #if DOXYGEN |
| /** |
| * @brief Add an event to repeatedly check if a parameter 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 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_not_value_count(#function, #parameter, uintmax_t value, size_t count); |
| #else |
| #define expect_not_value_count(function, parameter, value, count) \ |
| _expect_not_value(#function, #parameter, __FILE__, __LINE__, \ |
| cast_to_largest_integral_type(value), count) |
| #endif |
| |
| #if 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 |
| |
| #if 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(#function, #parameter, __FILE__, __LINE__, \ |
| (const char*)(string), count) |
| #endif |
| |
| #if 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 |
| |
| #if 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(#function, #parameter, __FILE__, __LINE__, \ |
| (const char*)(string), count) |
| #endif |
| |
| #if 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 |
| |
| #if 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(#function, #parameter, __FILE__, __LINE__, \ |
| (const void*)(memory), size, count) |
| #endif |
| |
| #if 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 |
| |
| #if 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(#function, #parameter, __FILE__, __LINE__, \ |
| (const void*)(memory), size, count) |
| #endif |
| |
| |
| #if 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 |
| |
| #if 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(#function, #parameter, __FILE__, __LINE__, count) |
| #endif |
| |
| #if 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 parameter to check. |
| */ |
| void check_expected(#parameter); |
| #else |
| #define check_expected(parameter) \ |
| _check_expected(__func__, #parameter, __FILE__, __LINE__, \ |
| cast_to_largest_integral_type(parameter)) |
| #endif |
| |
| /** @} */ |
| |
| /** |
| * @defgroup cmocka_asserts Assert Macros |
| * @ingroup cmocka |
| * |
| * This is a set of useful assert macros like the standard C libary'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_largest_integral_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_true(!(cast_to_largest_integral_type(c)), #c, \ |
| __FILE__, __LINE__) |
| #endif |
| |
| #ifdef DOXYGEN |
| /** |
| * @brief Assert if the return_code is smaller than 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(int rc, int error); |
| #else |
| #define assert_return_code(rc, error) \ |
| _assert_return_code(cast_to_largest_integral_type(rc), \ |
| sizeof(rc), \ |
| cast_to_largest_integral_type(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 non-NULL. |
| * |
| * @param[in] pointer The pointer to evaluate. |
| * |
| * @see assert_null() |
| */ |
| void assert_non_null(void *pointer); |
| #else |
| #define assert_non_null(c) _assert_true(cast_ptr_to_largest_integral_type(c), #c, \ |
| __FILE__, __LINE__) |
| #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_true(!(cast_ptr_to_largest_integral_type(c)), #c, \ |
| __FILE__, __LINE__) |
| #endif |
| |
| #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(int a, int b); |
| #else |
| #define assert_int_equal(a, b) \ |
| _assert_int_equal(cast_to_largest_integral_type(a), \ |
| cast_to_largest_integral_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(int a, int b); |
| #else |
| #define assert_int_not_equal(a, b) \ |
| _assert_int_not_equal(cast_to_largest_integral_type(a), \ |
| cast_to_largest_integral_type(b), \ |
| __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((const char*)(a), (const char*)(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((const char*)(a), (const char*)(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 value is bigger than the minimum and |
| * smaller 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_in_range(uintmax_t value, uintmax_t minimum, uintmax_t maximum); |
| #else |
| #define assert_in_range(value, minimum, maximum) \ |
| _assert_in_range( \ |
| cast_to_largest_integral_type(value), \ |
| cast_to_largest_integral_type(minimum), \ |
| cast_to_largest_integral_type(maximum), __FILE__, __LINE__) |
| #endif |
| |
| #ifdef DOXYGEN |
| /** |
| * @brief Assert that the specified value is smaller than the minimum and |
| * bigger than the maximum. |
| * |
| * The function prints an error message to standard error and terminates the |
| * test by calling fail() if value is in range. |
| * |
| * @param[in] value The value to check. |
| * |
| * @param[in] minimum The minimum value to compare. |
| * |
| * @param[in] maximum The maximum value to compare. |
| */ |
| void assert_not_in_range(uintmax_t value, uintmax_t minimum, uintmax_t maximum); |
| #else |
| #define assert_not_in_range(value, minimum, maximum) \ |
| _assert_not_in_range( \ |
| cast_to_largest_integral_type(value), \ |
| cast_to_largest_integral_type(minimum), \ |
| cast_to_largest_integral_type(maximum), __FILE__, __LINE__) |
| #endif |
| |
| #ifdef DOXYGEN |
| /** |
| * @brief Assert that the specified 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_in_set(uintmax_t value, uintmax_t values[], size_t count); |
| #else |
| #define assert_in_set(value, values, number_of_values) \ |
| _assert_in_set(value, values, 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_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 |
| |
| /** @} */ |
| |
| /** |
| * @defgroup cmocka_exec Running Tests |
| * @ingroup cmocka |
| * |
| * This is the way tests are executed with CMocka. |
| * |
| * The following example illustrates this macro's use with the unit_test macro. |
| * |
| * @code |
| * void Test0(void **state); |
| * void Test1(void **state); |
| * |
| * int main(void) |
| * { |
| * const UnitTest tests[] = { |
| * unit_test(Test0), |
| * unit_test(Test1), |
| * }; |
| * |
| * return run_tests(tests); |
| * } |
| * @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 fail immediately and quit, printing the reason. |
| */ |
| void fail_msg(const char *msg, ...); |
| #else |
| #define fail_msg(msg, ...) do { \ |
| print_error("ERROR: " msg "\n", ##__VA_ARGS__); \ |
| fail(); \ |
| } while (0) |
| #endif |
| |
| #ifdef DOXYGEN |
| /** |
| * @brief Generic method to run a single test. |
| * |
| * @param[in] #function The function to test. |
| * |
| * @return 0 on success, 1 if an error occured. |
| * |
| * @code |
| * // A test case that does nothing and succeeds. |
| * void null_test_success(void **state) { |
| * } |
| * |
| * int main(void) { |
| * return run_test(null_test_success); |
| * } |
| * @endcode |
| */ |
| int run_test(#function); |
| #else |
| #define run_test(f) _run_test(#f, f, NULL, UNIT_TEST_FUNCTION_TYPE_TEST, NULL) |
| #endif |
| |
| /** Initializes a UnitTest structure. */ |
| #define unit_test(f) { #f, f, UNIT_TEST_FUNCTION_TYPE_TEST } |
| |
| #define _unit_test_setup(test, setup) \ |
| { #test "_" #setup, setup, UNIT_TEST_FUNCTION_TYPE_SETUP } |
| |
| /** Initializes a UnitTest structure with a setup function. */ |
| #define unit_test_setup(test, setup) \ |
| _unit_test_setup(test, setup), \ |
| unit_test(test) |
| |
| #define _unit_test_teardown(test, teardown) \ |
| { #test "_" #teardown, teardown, UNIT_TEST_FUNCTION_TYPE_TEARDOWN } |
| |
| /** Initializes a UnitTest structure with a teardown function. */ |
| #define unit_test_teardown(test, teardown) \ |
| unit_test(test), \ |
| _unit_test_teardown(test, 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. |
| */ |
| #define unit_test_setup_teardown(test, setup, teardown) \ |
| _unit_test_setup(test, setup), \ |
| unit_test(test), \ |
| _unit_test_teardown(test, teardown) |
| |
| #ifdef DOXYGEN |
| /** |
| * @brief Run tests specified by an array of UnitTest structures. |
| * |
| * @param[in] tests[] The array of unit tests to execute. |
| * |
| * @return 0 on success, 1 if an error occured. |
| * |
| * @code |
| * static void setup(void **state) { |
| * int *answer = malloc(sizeof(int)); |
| * assert_non_null(answer); |
| * |
| * *answer = 42; |
| * |
| * *state = answer; |
| * } |
| * |
| * static void teardown(void **state) { |
| * free(*state); |
| * } |
| * |
| * 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 UnitTest tests[] = { |
| * unit_test(null_test_success), |
| * unit_test_setup_teardown(int_test_success, setup, teardown), |
| * }; |
| * |
| * return run_tests(tests); |
| * } |
| * @endcode |
| * |
| * @see unit_test |
| * @see unit_test_setup |
| * @see unit_test_teardown |
| * @see unit_test_setup_teardown |
| */ |
| int run_tests(const UnitTest tests[]); |
| #else |
| #define run_tests(tests) _run_tests(tests, sizeof(tests) / sizeof(tests)[0]) |
| #endif |
| |
| /** @} */ |
| |
| /** |
| * @defgroup cmocka_alloc Dynamic Memory Allocation |
| * @ingroup cmocka |
| * |
| * Memory leaks, buffer overflows and underflows can be checked using cmocka. |
| * |
| * 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. |
| * |
| * @{ |
| */ |
| |
| #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 |
| * #if 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 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 |
| |
| /* Redirect malloc, calloc and free to the unit test allocators. */ |
| #if UNIT_TESTING |
| #define malloc test_malloc |
| #define calloc test_calloc |
| #define free test_free |
| #endif /* UNIT_TESTING */ |
| |
| /** @} */ |
| |
| |
| /** |
| * @defgroup cmocka_mock_assert Standard Assertions |
| * @ingroup cmocka |
| * |
| * 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 conjuction 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 |
| * #if 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) \ |
| { \ |
| const int result = setjmp(global_expect_assert_env); \ |
| global_expecting_assert = 1; \ |
| if (result) { \ |
| 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 |
| |
| /** @} */ |
| |
| /* Function prototype for setup, test and teardown functions. */ |
| typedef void (*UnitTestFunction)(void **state); |
| |
| /* Function that determines whether a function parameter value is correct. */ |
| typedef int (*CheckParameterValue)(const LargestIntegralType value, |
| const LargestIntegralType check_value_data); |
| |
| /* 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, |
| } UnitTestFunctionType; |
| |
| /* |
| * 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; |
| |
| |
| /* Location within some source code. */ |
| typedef struct SourceLocation { |
| const char* file; |
| int line; |
| } SourceLocation; |
| |
| /* Event that's called to check a parameter value. */ |
| typedef struct CheckParameterEvent { |
| SourceLocation location; |
| const char *parameter_name; |
| CheckParameterValue check_value; |
| LargestIntegralType check_value_data; |
| } CheckParameterEvent; |
| |
| /* Used by expect_assert_failure() and mock_assert(). */ |
| extern int global_expecting_assert; |
| extern jmp_buf global_expect_assert_env; |
| extern const char * global_last_failed_assert; |
| |
| /* Retrieves a value for the given function, as set by "will_return". */ |
| LargestIntegralType _mock(const char * const function, const char* const file, |
| const int line); |
| |
| void _expect_check( |
| const char* const function, const char* const parameter, |
| const char* const file, const int line, |
| const CheckParameterValue check_function, |
| const LargestIntegralType check_data, CheckParameterEvent * const event, |
| const int count); |
| |
| void _expect_in_set( |
| const char* const function, const char* const parameter, |
| const char* const file, const int line, const LargestIntegralType values[], |
| const size_t number_of_values, const int count); |
| void _expect_not_in_set( |
| const char* const function, const char* const parameter, |
| const char* const file, const int line, const LargestIntegralType values[], |
| const size_t number_of_values, const int count); |
| |
| void _expect_in_range( |
| const char* const function, const char* const parameter, |
| const char* const file, const int line, |
| const LargestIntegralType minimum, |
| const LargestIntegralType maximum, const int count); |
| void _expect_not_in_range( |
| const char* const function, const char* const parameter, |
| const char* const file, const int line, |
| const LargestIntegralType minimum, |
| const LargestIntegralType maximum, const int count); |
| |
| void _expect_value( |
| const char* const function, const char* const parameter, |
| const char* const file, const int line, const LargestIntegralType value, |
| const int count); |
| void _expect_not_value( |
| const char* const function, const char* const parameter, |
| const char* const file, const int line, const LargestIntegralType value, |
| 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 LargestIntegralType value); |
| |
| void _will_return(const char * const function_name, const char * const file, |
| const int line, const LargestIntegralType value, |
| const int count); |
| void _assert_true(const LargestIntegralType result, |
| const char* const expression, |
| const char * const file, const int line); |
| void _assert_return_code(const LargestIntegralType result, |
| size_t rlen, |
| const LargestIntegralType error, |
| const char * const expression, |
| const char * const file, |
| const int line); |
| void _assert_int_equal( |
| const LargestIntegralType a, const LargestIntegralType b, |
| const char * const file, const int line); |
| void _assert_int_not_equal( |
| const LargestIntegralType a, const LargestIntegralType b, |
| const char * const file, const int line); |
| 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_in_range( |
| const LargestIntegralType value, const LargestIntegralType minimum, |
| const LargestIntegralType maximum, const char* const file, const int line); |
| void _assert_not_in_range( |
| const LargestIntegralType value, const LargestIntegralType minimum, |
| const LargestIntegralType maximum, const char* const file, const int line); |
| void _assert_in_set( |
| const LargestIntegralType value, const LargestIntegralType values[], |
| const size_t number_of_values, const char* const file, const int line); |
| void _assert_not_in_set( |
| const LargestIntegralType value, const LargestIntegralType values[], |
| const size_t number_of_values, const char* const file, const int line); |
| |
| void* _test_malloc(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); |
| |
| void _fail(const char * const file, const int line); |
| int _run_test( |
| const char * const function_name, const UnitTestFunction Function, |
| void ** const volatile state, const UnitTestFunctionType function_type, |
| const void* const heap_check_point); |
| int _run_tests(const UnitTest * const tests, const size_t number_of_tests); |
| |
| /* Standard output and error print methods. */ |
| void print_message(const char* const format, ...) PRINTF_ATTRIBUTE(1, 2); |
| void print_error(const char* const format, ...) PRINTF_ATTRIBUTE(1, 2); |
| void vprint_message(const char* const format, va_list args) PRINTF_ATTRIBUTE(1, 0); |
| void vprint_error(const char* const format, va_list args) PRINTF_ATTRIBUTE(1, 0); |
| |
| /** @} */ |
| |
| #endif /* CMOCKA_H_ */ |