7093 lines
239 KiB
C
7093 lines
239 KiB
C
/*
|
|
* Copyright 2008 Google Inc.
|
|
* Copyright 2014-2022 Andreas Schneider <asn@cryptomilk.org>
|
|
*
|
|
* 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 <stdarg.h>
|
|
* #include <stdbool.h>
|
|
* #include <stddef.h>
|
|
* #include <stdint.h>
|
|
* #include <setjmp.h>
|
|
* @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 <cmocka.h>
|
|
* // ... your test code goes here ...
|
|
* @endcode
|
|
*/
|
|
|
|
#ifndef CMOCKA_NO_STANDARD_INCLUDES
|
|
#include <stdarg.h>
|
|
#include <stdbool.h>
|
|
#include <stddef.h>
|
|
#include <stdint.h>
|
|
#include <setjmp.h>
|
|
#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.
|
|
*
|
|
* <ul>
|
|
* <li><strong>will_return(function, value)</strong> - 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.</li>
|
|
*
|
|
* <li><strong>mock()</strong> - 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.</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
|
|
* 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
|
|
* <a
|
|
* href="https://git.cryptomilk.org/projects/cmocka.git/tree/example/mock">here</a>.
|
|
*
|
|
* @{
|
|
*/
|
|
|
|
/**
|
|
* @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
|
|
* <a href="https://git.cryptomilk.org/projects/cmocka.git/tree/example/mock">here</a>
|
|
*
|
|
* @{
|
|
*/
|
|
|
|
|
|
#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.
|
|
*
|
|
* <ul>
|
|
* <li><strong>expect_function_call(function)</strong> - The
|
|
* expect_function_call() macro pushes an expectation onto the stack of
|
|
* expected calls.</li>
|
|
*
|
|
* <li><strong>function_called()</strong> - pops a value from the stack of
|
|
* expected calls. function_called() is invoked within the mock object
|
|
* that uses it.
|
|
* </ul>
|
|
*
|
|
* 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,
|
|
* <strong>chef_sing()</strong>:
|
|
*
|
|
* @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 <strong>function_called()</strong>:
|
|
*
|
|
* @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
|
|
* <a href="https://clang.llvm.org/docs/AddressSanitizer.html">AddressSanitizer</a>.
|
|
*
|
|
* 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.
|
|
*
|
|
* <b>Automatic Allocation Redirection (Deprecated):</b>
|
|
*
|
|
* 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
|
|
* <a href="https://clang.llvm.org/docs/AddressSanitizer.html">AddressSanitizer</a>.
|
|
*
|
|
* To enable allocation testing, define both macros before including cmocka.h:
|
|
*
|
|
* @code
|
|
* #include <stdlib.h>
|
|
*
|
|
* #define UNIT_TESTING 1
|
|
* #define ALLOCATION_TESTING 1
|
|
* #include <cmocka.h>
|
|
*
|
|
* // 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_ */
|