Packages/l/libcmocka-devel-0.4.1-3.fc21.i686.rpm

 /*

  * Copyright 2008 Google Inc.

  *

  * Licensed under the Apache License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

  * You may obtain a copy of the License at

  *

  * http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 #ifndef CMOCKA_H_

 #define CMOCKA_H_


 #ifdef _WIN32

 # ifdef _MSC_VER


 # ifndef inline

 #define inline __inline

 # endif /* inline */


 #  if _MSC_VER < 1500

 #   ifdef __cplusplus

 extern "C" {

 #   endif   /* __cplusplus */

 int __stdcall IsDebuggerPresent();

 #   ifdef __cplusplus

 } /* extern "C" */

 #   endif   /* __cplusplus */

 #  endif  /* _MSC_VER < 1500 */

 # endif /* _MSC_VER */

 #endif  /* _WIN32 */


 /*

  * These headers or their equivalents should be included prior to including

  * this header file.

  *

  * #include <stdarg.h>

  * #include <stddef.h>

  * #include <setjmp.h>

  *

  * This allows test applications to use custom definitions of C standard

  * library functions and types.

  */


 /* For those who are used to __func__ from gcc. */

 #ifndef __func__

 #define __func__ __FUNCTION__

 #endif


 /* GCC have printf type attribute check.  */

 #ifdef __GNUC__

 #define CMOCKA_PRINTF_ATTRIBUTE(a,b) \

     __attribute__ ((__format__ (__printf__, a, b)))

 #else

 #define CMOCKA_PRINTF_ATTRIBUTE(a,b)

 #endif /* __GNUC__ */


 /*

  * Largest integral type.  This type should be large enough to hold any

  * pointer or integer supported by the compiler.

  */

 #ifndef LargestIntegralType

 #define LargestIntegralType unsigned long long

 #endif /* LargestIntegralType */


 /* Printf format used to display LargestIntegralType. */

 #ifndef LargestIntegralTypePrintfFormat

 #ifdef _WIN32

 #define LargestIntegralTypePrintfFormat "0x%I64x"

 #else

 #define LargestIntegralTypePrintfFormat "%#llx"

 #endif /* _WIN32 */

 #endif /* LargestIntegralTypePrintfFormat */


 /* Perform an unsigned cast to LargestIntegralType. */

 #define cast_to_largest_integral_type(value) \

     ((LargestIntegralType)((size_t)(value)))


 /* Smallest integral type capable of holding a pointer. */

 #if !defined(_UINTPTR_T) && !defined(_UINTPTR_T_DEFINED)

 # if defined(_WIN32)

     /* WIN32 is an ILP32 platform */

     typedef unsigned int uintptr_t;

 # elif defined(_WIN64)

     typedef unsigned long int uintptr_t

 # else /* _WIN32 */


 /* ILP32 and LP64 platforms */

 #  ifdef __WORDSIZE /* glibc */

 #   if __WORDSIZE == 64

       typedef unsigned long int uintptr_t;

 #   else

       typedef unsigned int uintptr_t;

 #   endif /* __WORDSIZE == 64 */

 #  else /* __WORDSIZE */

 #   if defined(_LP64) || defined(_I32LPx)

       typedef unsigned long int uintptr_t;

 #   else

       typedef unsigned int uintptr_t;

 #   endif

 #  endif /* __WORDSIZE */

 # endif /* _WIN32 */


 # define _UINTPTR_T

 # define _UINTPTR_T_DEFINED

 #endif /* !defined(_UINTPTR_T) || !defined(_UINTPTR_T_DEFINED) */


 /* Perform an unsigned cast to uintptr_t. */

 #define cast_to_pointer_integral_type(value) \

     ((uintptr_t)(value))


 /* Perform a cast of a pointer to uintmax_t */

 #define cast_ptr_to_largest_integral_type(value) \

 cast_to_largest_integral_type(cast_to_pointer_integral_type(value))


 #ifdef DOXYGEN


 void *mock(void);

 #else

 #define mock() _mock(__func__, __FILE__, __LINE__)

 #endif


 #ifdef DOXYGEN


 void *mock_type(#type);

 #else

 #define mock_type(type) ((type) mock())

 #endif


 #ifdef DOXYGEN


 void *mock_ptr_type(#type);

 #else

 #define mock_ptr_type(type) ((type) (uintptr_t) mock())

 #endif


 #ifdef DOXYGEN


 void will_return(#function, void *value);

 #else

 #define will_return(function, value) \

     _will_return(#function, __FILE__, __LINE__, \

                  cast_to_largest_integral_type(value), 1)

 #endif


 #ifdef DOXYGEN


 void will_return_count(#function, void *value, int count);

 #else

 #define will_return_count(function, value, count) \

     _will_return(#function, __FILE__, __LINE__, \

                  cast_to_largest_integral_type(value), count)

 #endif


 #ifdef DOXYGEN


 void will_return_always(#function, void *value);

 #else

 #define will_return_always(function, value) \

     will_return_count(function, (value), -1)

 #endif


 /*

  * Add a custom parameter checking function.  If the event parameter is NULL

  * the event structure is allocated internally by this function.  If event

  * parameter is provided it must be allocated on the heap and doesn't need to

  * be deallocated by the caller.

  */

 #ifdef DOXYGEN


 void expect_check(#function, #parameter, #check_function, const void *check_data);

 #else

 #define expect_check(function, parameter, check_function, check_data) \

     _expect_check(#function, #parameter, __FILE__, __LINE__, check_function, \

                   cast_to_largest_integral_type(check_data), NULL, 1)

 #endif


 #ifdef DOXYGEN


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

 #else

 #define expect_in_set(function, parameter, value_array) \

     expect_in_set_count(function, parameter, value_array, 1)

 #endif


 #ifdef DOXYGEN


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

 #else

 #define expect_in_set_count(function, parameter, value_array, count) \

     _expect_in_set(#function, #parameter, __FILE__, __LINE__, value_array, \

                    sizeof(value_array) / sizeof((value_array)[0]), count)

 #endif


 #ifdef DOXYGEN


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

 #else

 #define expect_not_in_set(function, parameter, value_array) \

     expect_not_in_set_count(function, parameter, value_array, 1)

 #endif


 #ifdef DOXYGEN


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

 #else

 #define expect_not_in_set_count(function, parameter, value_array, count) \

     _expect_not_in_set( \

         #function, #parameter, __FILE__, __LINE__, value_array, \

         sizeof(value_array) / sizeof((value_array)[0]), count)

 #endif


 #ifdef DOXYGEN


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

 #else

 #define expect_in_range(function, parameter, minimum, maximum) \

     expect_in_range_count(function, parameter, minimum, maximum, 1)

 #endif


 #ifdef DOXYGEN


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

 #else

 #define expect_in_range_count(function, parameter, minimum, maximum, count) \

     _expect_in_range(#function, #parameter, __FILE__, __LINE__, minimum, \

                      maximum, count)

 #endif


 #ifdef DOXYGEN


 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


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

 #else

 #define expect_not_in_range_count(function, parameter, minimum, maximum, \

                                   count) \

     _expect_not_in_range(#function, #parameter, __FILE__, __LINE__, \

                          minimum, maximum, count)

 #endif


 #ifdef DOXYGEN


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

 #else

 #define expect_value(function, parameter, value) \

     expect_value_count(function, parameter, value, 1)

 #endif


 #ifdef DOXYGEN


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

 #else

 #define expect_value_count(function, parameter, value, count) \

     _expect_value(#function, #parameter, __FILE__, __LINE__, \

                   cast_to_largest_integral_type(value), count)

 #endif


 #ifdef DOXYGEN


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

 #else

 #define expect_not_value(function, parameter, value) \

     expect_not_value_count(function, parameter, value, 1)

 #endif


 #ifdef DOXYGEN


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

 #else

 #define expect_not_value_count(function, parameter, value, count) \

     _expect_not_value(#function, #parameter, __FILE__, __LINE__, \

                       cast_to_largest_integral_type(value), count)

 #endif


 #ifdef DOXYGEN


 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


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

 #else

 #define expect_string_count(function, parameter, string, count) \

     _expect_string(#function, #parameter, __FILE__, __LINE__, \

                    (const char*)(string), count)

 #endif


 #ifdef DOXYGEN


 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


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

 #else

 #define expect_not_string_count(function, parameter, string, count) \

     _expect_not_string(#function, #parameter, __FILE__, __LINE__, \

                        (const char*)(string), count)

 #endif


 #ifdef DOXYGEN


 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


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

 #else

 #define expect_memory_count(function, parameter, memory, size, count) \

     _expect_memory(#function, #parameter, __FILE__, __LINE__, \

                    (const void*)(memory), size, count)

 #endif


 #ifdef DOXYGEN


 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


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

 #else

 #define expect_not_memory_count(function, parameter, memory, size, count) \

     _expect_not_memory(#function, #parameter, __FILE__, __LINE__, \

                        (const void*)(memory), size, count)

 #endif


 #ifdef DOXYGEN


 void expect_any(#function, #parameter);

 #else

 #define expect_any(function, parameter) \

     expect_any_count(function, parameter, 1)

 #endif


 #ifdef DOXYGEN


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

 #else

 #define expect_any_count(function, parameter, count) \

     _expect_any(#function, #parameter, __FILE__, __LINE__, count)

 #endif


 #ifdef DOXYGEN


 void check_expected(#parameter);

 #else

 #define check_expected(parameter) \

     _check_expected(__func__, #parameter, __FILE__, __LINE__, \

                     cast_to_largest_integral_type(parameter))

 #endif


 #ifdef DOXYGEN


 void assert_true(scalar expression);

 #else

 #define assert_true(c) _assert_true(cast_to_largest_integral_type(c), #c, \

                                     __FILE__, __LINE__)

 #endif


 #ifdef DOXYGEN


 void assert_false(scalar expression);

 #else

 #define assert_false(c) _assert_true(!(cast_to_largest_integral_type(c)), #c, \

                                      __FILE__, __LINE__)

 #endif


 #ifdef DOXYGEN


 void assert_return_code(int rc, int error);

 #else

 #define assert_return_code(rc, error) \

     _assert_return_code(cast_to_largest_integral_type(rc), \

                         sizeof(rc), \

                         cast_to_largest_integral_type(error), \

                         #rc, __FILE__, __LINE__)

 #endif


 #ifdef DOXYGEN


 void assert_non_null(void *pointer);

 #else

 #define assert_non_null(c) _assert_true(cast_ptr_to_largest_integral_type(c), #c, \

                                         __FILE__, __LINE__)

 #endif


 #ifdef DOXYGEN


 void assert_null(void *pointer);

 #else

 #define assert_null(c) _assert_true(!(cast_ptr_to_largest_integral_type(c)), #c, \

 __FILE__, __LINE__)

 #endif


 #ifdef DOXYGEN


 void assert_int_equal(int a, int b);

 #else

 #define assert_int_equal(a, b) \

     _assert_int_equal(cast_to_largest_integral_type(a), \

                       cast_to_largest_integral_type(b), \

                       __FILE__, __LINE__)

 #endif


 #ifdef DOXYGEN


 void assert_int_not_equal(int a, int b);

 #else

 #define assert_int_not_equal(a, b) \

     _assert_int_not_equal(cast_to_largest_integral_type(a), \

                           cast_to_largest_integral_type(b), \

                           __FILE__, __LINE__)

 #endif


 #ifdef DOXYGEN


 void assert_string_equal(const char *a, const char *b);

 #else

 #define assert_string_equal(a, b) \

     _assert_string_equal((const char*)(a), (const char*)(b), __FILE__, \

                          __LINE__)

 #endif


 #ifdef DOXYGEN


 void assert_string_not_equal(const char *a, const char *b);

 #else

 #define assert_string_not_equal(a, b) \

     _assert_string_not_equal((const char*)(a), (const char*)(b), __FILE__, \

                              __LINE__)

 #endif


 #ifdef DOXYGEN


 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


 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


 void assert_in_range(uintmax_t value, uintmax_t minimum, uintmax_t maximum);

 #else

 #define assert_in_range(value, minimum, maximum) \

     _assert_in_range( \

         cast_to_largest_integral_type(value), \

         cast_to_largest_integral_type(minimum), \

         cast_to_largest_integral_type(maximum), __FILE__, __LINE__)

 #endif


 #ifdef DOXYGEN


 void assert_not_in_range(uintmax_t value, uintmax_t minimum, uintmax_t maximum);

 #else

 #define assert_not_in_range(value, minimum, maximum) \

     _assert_not_in_range( \

         cast_to_largest_integral_type(value), \

         cast_to_largest_integral_type(minimum), \

         cast_to_largest_integral_type(maximum), __FILE__, __LINE__)

 #endif


 #ifdef DOXYGEN


 void assert_in_set(uintmax_t value, uintmax_t values[], size_t count);

 #else

 #define assert_in_set(value, values, number_of_values) \

     _assert_in_set(value, values, number_of_values, __FILE__, __LINE__)

 #endif


 #ifdef DOXYGEN


 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


 void fail(void);

 #else

 #define fail() _fail(__FILE__, __LINE__)

 #endif


 #ifdef DOXYGEN


 void fail_msg(const char *msg, ...);

 #else

 #define fail_msg(msg, ...) do { \

     print_error("ERROR: " msg "\n", ##__VA_ARGS__); \

     fail(); \

 } while (0)

 #endif


 #ifdef DOXYGEN


 int run_test(#function);

 #else

 #define run_test(f) _run_test(#f, f, NULL, UNIT_TEST_FUNCTION_TYPE_TEST, NULL)

 #endif


 static inline void _unit_test_dummy(void **state) {

     (void)state;

 }


 #define unit_test(f) { #f, f, UNIT_TEST_FUNCTION_TYPE_TEST }


 #define _unit_test_setup(test, setup) \

     { #test "_" #setup, setup, UNIT_TEST_FUNCTION_TYPE_SETUP }


 #define unit_test_setup(test, setup) \

     _unit_test_setup(test, setup), \

     unit_test(test), \

     _unit_test_teardown(test, _unit_test_dummy)


 #define _unit_test_teardown(test, teardown) \

     { #test "_" #teardown, teardown, UNIT_TEST_FUNCTION_TYPE_TEARDOWN }


 #define unit_test_teardown(test, teardown) \

     _unit_test_setup(test, _unit_test_dummy), \

     unit_test(test), \

     _unit_test_teardown(test, teardown)


 #define group_test_setup(setup) \

     { "group_" #setup, setup, UNIT_TEST_FUNCTION_TYPE_GROUP_SETUP }


 #define group_test_teardown(teardown) \

     { "group_" #teardown, teardown, UNIT_TEST_FUNCTION_TYPE_GROUP_TEARDOWN }


 #define unit_test_setup_teardown(test, setup, teardown) \

     _unit_test_setup(test, setup), \

     unit_test(test), \

     _unit_test_teardown(test, teardown)


 #ifdef DOXYGEN


 int run_tests(const UnitTest tests[]);

 #else

 #define run_tests(tests) _run_tests(tests, sizeof(tests) / sizeof(tests)[0])

 #endif


 #define run_group_tests(tests) _run_group_tests(tests, sizeof(tests) / sizeof(tests)[0])


 #ifdef DOXYGEN


 void *test_malloc(size_t size);

 #else

 #define test_malloc(size) _test_malloc(size, __FILE__, __LINE__)

 #endif


 #ifdef DOXYGEN


 void *test_calloc(size_t nmemb, size_t size);

 #else

 #define test_calloc(num, size) _test_calloc(num, size, __FILE__, __LINE__)

 #endif


 #ifdef DOXYGEN


 void test_free(void *ptr);

 #else

 #define test_free(ptr) _test_free(ptr, __FILE__, __LINE__)

 #endif


 /* Redirect malloc, calloc and free to the unit test allocators. */

 #ifdef UNIT_TESTING

 #define malloc test_malloc

 #define calloc test_calloc

 #define free test_free

 #endif /* UNIT_TESTING */


 void mock_assert(const int result, const char* const expression,

                  const char * const file, const int line);


 #ifdef DOXYGEN


 void expect_assert_failure(function fn_call);

 #else

 #define expect_assert_failure(function_call) \

   { \

     const int result = setjmp(global_expect_assert_env); \

     global_expecting_assert = 1; \

     if (result) { \

       print_message("Expected assertion %s occurred\n", \

                     global_last_failed_assert); \

       global_expecting_assert = 0; \

     } else { \

       function_call ; \

       global_expecting_assert = 0; \

       print_error("Expected assert in %s\n", #function_call); \

       _fail(__FILE__, __LINE__); \

     } \

   }

 #endif


 /* Function prototype for setup, test and teardown functions. */

 typedef void (*UnitTestFunction)(void **state);


 /* Function that determines whether a function parameter value is correct. */

 typedef int (*CheckParameterValue)(const LargestIntegralType value,

                                    const LargestIntegralType check_value_data);


 /* Type of the unit test function. */

 typedef enum UnitTestFunctionType {

     UNIT_TEST_FUNCTION_TYPE_TEST = 0,

     UNIT_TEST_FUNCTION_TYPE_SETUP,

     UNIT_TEST_FUNCTION_TYPE_TEARDOWN,

     UNIT_TEST_FUNCTION_TYPE_GROUP_SETUP,

     UNIT_TEST_FUNCTION_TYPE_GROUP_TEARDOWN,

 } UnitTestFunctionType;


 /*

  * Stores a unit test function with its name and type.

  * NOTE: Every setup function must be paired with a teardown function.  It's

  * possible to specify NULL function pointers.

  */

 typedef struct UnitTest {

     const char* name;

     UnitTestFunction function;

     UnitTestFunctionType function_type;

 } UnitTest;


 typedef struct GroupTest {

     UnitTestFunction setup;

     UnitTestFunction teardown;

     const UnitTest *tests;

     const size_t number_of_tests;

 } GroupTest;


 /* Location within some source code. */

 typedef struct SourceLocation {

     const char* file;

     int line;

 } SourceLocation;


 /* Event that's called to check a parameter value. */

 typedef struct CheckParameterEvent {

     SourceLocation location;

     const char *parameter_name;

     CheckParameterValue check_value;

     LargestIntegralType check_value_data;

 } CheckParameterEvent;


 /* Used by expect_assert_failure() and mock_assert(). */

 extern int global_expecting_assert;

 extern jmp_buf global_expect_assert_env;

 extern const char * global_last_failed_assert;


 /* Retrieves a value for the given function, as set by "will_return". */

 LargestIntegralType _mock(const char * const function, const char* const file,

                           const int line);


 void _expect_check(

     const char* const function, const char* const parameter,

     const char* const file, const int line,

     const CheckParameterValue check_function,

     const LargestIntegralType check_data, CheckParameterEvent * const event,

     const int count);


 void _expect_in_set(

     const char* const function, const char* const parameter,

     const char* const file, const int line, const LargestIntegralType values[],

     const size_t number_of_values, const int count);

 void _expect_not_in_set(

     const char* const function, const char* const parameter,

     const char* const file, const int line, const LargestIntegralType values[],

     const size_t number_of_values, const int count);


 void _expect_in_range(

     const char* const function, const char* const parameter,

     const char* const file, const int line,

     const LargestIntegralType minimum,

     const LargestIntegralType maximum, const int count);

 void _expect_not_in_range(

     const char* const function, const char* const parameter,

     const char* const file, const int line,

     const LargestIntegralType minimum,

     const LargestIntegralType maximum, const int count);


 void _expect_value(

     const char* const function, const char* const parameter,

     const char* const file, const int line, const LargestIntegralType value,

     const int count);

 void _expect_not_value(

     const char* const function, const char* const parameter,

     const char* const file, const int line, const LargestIntegralType value,

     const int count);


 void _expect_string(

     const char* const function, const char* const parameter,

     const char* const file, const int line, const char* string,

     const int count);

 void _expect_not_string(

     const char* const function, const char* const parameter,

     const char* const file, const int line, const char* string,

     const int count);


 void _expect_memory(

     const char* const function, const char* const parameter,

     const char* const file, const int line, const void* const memory,

     const size_t size, const int count);

 void _expect_not_memory(

     const char* const function, const char* const parameter,

     const char* const file, const int line, const void* const memory,

     const size_t size, const int count);


 void _expect_any(

     const char* const function, const char* const parameter,

     const char* const file, const int line, const int count);


 void _check_expected(

     const char * const function_name, const char * const parameter_name,

     const char* file, const int line, const LargestIntegralType value);


 void _will_return(const char * const function_name, const char * const file,

                   const int line, const LargestIntegralType value,

                   const int count);

 void _assert_true(const LargestIntegralType result,

                   const char* const expression,

                   const char * const file, const int line);

 void _assert_return_code(const LargestIntegralType result,

                          size_t rlen,

                          const LargestIntegralType error,

                          const char * const expression,

                          const char * const file,

                          const int line);

 void _assert_int_equal(

     const LargestIntegralType a, const LargestIntegralType b,

     const char * const file, const int line);

 void _assert_int_not_equal(

     const LargestIntegralType a, const LargestIntegralType b,

     const char * const file, const int line);

 void _assert_string_equal(const char * const a, const char * const b,

                           const char * const file, const int line);

 void _assert_string_not_equal(const char * const a, const char * const b,

                               const char *file, const int line);

 void _assert_memory_equal(const void * const a, const void * const b,

                           const size_t size, const char* const file,

                           const int line);

 void _assert_memory_not_equal(const void * const a, const void * const b,

                               const size_t size, const char* const file,

                               const int line);

 void _assert_in_range(

     const LargestIntegralType value, const LargestIntegralType minimum,

     const LargestIntegralType maximum, const char* const file, const int line);

 void _assert_not_in_range(

     const LargestIntegralType value, const LargestIntegralType minimum,

     const LargestIntegralType maximum, const char* const file, const int line);

 void _assert_in_set(

     const LargestIntegralType value, const LargestIntegralType values[],

     const size_t number_of_values, const char* const file, const int line);

 void _assert_not_in_set(

     const LargestIntegralType value, const LargestIntegralType values[],

     const size_t number_of_values, const char* const file, const int line);


 void* _test_malloc(const size_t size, const char* file, const int line);

 void* _test_calloc(const size_t number_of_elements, const size_t size,

                    const char* file, const int line);

 void _test_free(void* const ptr, const char* file, const int line);


 void _fail(const char * const file, const int line);

 int _run_test(

     const char * const function_name, const UnitTestFunction Function,

     void ** const volatile state, const UnitTestFunctionType function_type,

     const void* const heap_check_point);

 int _run_tests(const UnitTest * const tests, const size_t number_of_tests);

 int _run_group_tests(const UnitTest * const tests,

                      const size_t number_of_tests);


 /* 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);


 #endif /* CMOCKA_H_ */

assert_null
void assert_null(void *pointer)
Assert that the given pointer is NULL.

expect_any_count
void expect_any_count(#function,#parameter, size_t count)
Add an event to repeatedly check if a parameter (of any value) has been passed.

fail
void fail(void)
Forces the test to fail immediately and quit.

expect_not_in_range_count
void expect_not_in_range_count(#function,#parameter, uintmax_t minimum, uintmax_t maximum, size_t count)
Add an event to repeatedly check a parameter is outside a numerical range.

expect_not_in_range
void expect_not_in_range(#function,#parameter, uintmax_t minimum, uintmax_t maximum)
Add an event to check a parameter is outside a numerical range.

assert_memory_not_equal
void assert_memory_not_equal(const void *a, const void *b, size_t size)
Assert that the two given areas of memory are not equal.

run_tests
int run_tests(const UnitTest tests[])
Run tests specified by an array of UnitTest structures.

mock_ptr_type
void * mock_ptr_type(#type)
Retrieve a typed return value of the current function.

expect_check
void expect_check(#function,#parameter,#check_function, const void *check_data)
Add a custom parameter checking function.

mock
void * mock(void)
Retrieve a return value of the current function.

assert_in_set
void assert_in_set(uintmax_t value, uintmax_t values[], size_t count)
Assert that the specified value is within a set.

fail_msg
void fail_msg(const char *msg,...)
Forces the test to fail immediately and quit, printing the reason.

expect_string_count
void expect_string_count(#function,#parameter, const char *string, size_t count)
Add an event to check if the parameter value is equal to the provided string.

mock_assert
void mock_assert(const int result, const char *const expression, const char *const file, const int line)
Function to replace assert(3) in tested code.
Definition: cmocka.c:1282

expect_any
void expect_any(#function,#parameter)
Add an event to check if a parameter (of any value) has been passed.

assert_not_in_range
void assert_not_in_range(uintmax_t value, uintmax_t minimum, uintmax_t maximum)
Assert that the specified value is smaller than the minimum and bigger than the maximum.

assert_in_range
void assert_in_range(uintmax_t value, uintmax_t minimum, uintmax_t maximum)
Assert that the specified value is bigger than the minimum and smaller than the maximum.

expect_string
void expect_string(#function,#parameter, const char *string)
Add an event to check if the parameter value is equal to the provided string.

will_return_always
void will_return_always(#function, void *value)
Store a value that will be always returned by mock().

assert_not_in_set
void assert_not_in_set(uintmax_t value, uintmax_t values[], size_t count)
Assert that the specified value is not within a set.

expect_not_memory
void expect_not_memory(#function,#parameter, void *memory, size_t size)
Add an event to check if the parameter doesn't match an area of memory.

expect_value
void expect_value(#function,#parameter, uintmax_t value)
Add an event to check if a parameter is the given value.

expect_not_value
void expect_not_value(#function,#parameter, uintmax_t value)
Add an event to check if a parameter isn't the given value.

assert_string_equal
void assert_string_equal(const char *a, const char *b)
Assert that the two given strings are equal.

test_malloc
void * test_malloc(size_t size)
Test function overriding malloc.

assert_return_code
void assert_return_code(int rc, int error)
Assert if the return_code is smaller than 0.

assert_non_null
void assert_non_null(void *pointer)
Assert that the given pointer is non-NULL.

expect_not_string
void expect_not_string(#function,#parameter, const char *string)
Add an event to check if the parameter value isn't equal to the provided string.

assert_true
void assert_true(scalar expression)
Assert that the given expression is true.

expect_not_string_count
void expect_not_string_count(#function,#parameter, const char *string, size_t count)
Add an event to check if the parameter value isn't equal to the provided string.

assert_string_not_equal
void assert_string_not_equal(const char *a, const char *b)
Assert that the two given strings are not equal.

assert_false
void assert_false(scalar expression)
Assert that the given expression is false.

expect_not_in_set_count
void expect_not_in_set_count(#function,#parameter, uintmax_t value_array[], size_t count)
Add an event to check if the parameter value is not part of the provided array.

assert_int_not_equal
void assert_int_not_equal(int a, int b)
Assert that the two given integers are not equal.

expect_in_range
void expect_in_range(#function,#parameter, uintmax_t minimum, uintmax_t maximum)
Add an event to check a parameter is inside a numerical range.

run_test
int run_test(#function)
Generic method to run a single test.

will_return_count
void will_return_count(#function, void *value, int count)
Store a value to be returned by mock() later.

expect_not_in_set
void expect_not_in_set(#function,#parameter, uintmax_t value_array[])
Add an event to check if the parameter value is not part of the provided array.

expect_not_value_count
void expect_not_value_count(#function,#parameter, uintmax_t value, size_t count)
Add an event to repeatedly check if a parameter isn't the given value.

test_calloc
void * test_calloc(size_t nmemb, size_t size)
Test function overriding calloc.

expect_memory
void expect_memory(#function,#parameter, void *memory, size_t size)
Add an event to check if the parameter does match an area of memory.

expect_in_set_count
void expect_in_set_count(#function,#parameter, uintmax_t value_array[], size_t count)
Add an event to check if the parameter value is part of the provided array.

will_return
void will_return(#function, void *value)
Store a value to be returned by mock() later.

assert_int_equal
void assert_int_equal(int a, int b)
Assert that the two given integers are equal.

assert_memory_equal
void assert_memory_equal(const void *a, const void *b, size_t size)
Assert that the two given areas of memory are equal, otherwise fail.

check_expected
void check_expected(#parameter)
Determine whether a function parameter is correct.

expect_in_range_count
void expect_in_range_count(#function,#parameter, uintmax_t minimum, uintmax_t maximum, size_t count)
Add an event to repeatedly check a parameter is inside a numerical range.

mock_type
void * mock_type(#type)
Retrieve a typed return value of the current function.

expect_value_count
void expect_value_count(#function,#parameter, uintmax_t value, size_t count)
Add an event to repeatedly check if a parameter is the given value.

test_free
void test_free(void *ptr)
Test function overriding free(3).

expect_memory_count
void expect_memory_count(#function,#parameter, void *memory, size_t size, size_t count)
Add an event to repeatedly check if the parameter does match an area of memory.

expect_assert_failure
void expect_assert_failure(function fn_call)
Ensure that mock_assert() is called.

expect_not_memory_count
void expect_not_memory_count(#function,#parameter, void *memory, size_t size, size_t count)
Add an event to repeatedly check if the parameter doesn't match an area of memory.

expect_in_set
void expect_in_set(#function,#parameter, uintmax_t value_array[])
Add an event to check if the parameter value is part of the provided array.