paths:
- obj/
+fedora/memory-sanitizer:
+ image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$FEDORA_BUILD
+ script:
+ - mkdir -p obj && cd obj && cmake
+ -DCMAKE_BUILD_TYPE=MemorySanitizer
+ -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++
+ -DUNIT_TESTING=ON ..
+ && make -j$(nproc) && ctest --output-on-failure
+ tags:
+ - shared
+ except:
+ - tags
+ artifacts:
+ expire_in: 1 week
+ when: on_failure
+ paths:
+ - obj/
+
fedora/undefined-sanitizer:
image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$FEDORA_BUILD
script:
paths:
- obj/
+fedora/csbuild:
+ image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$FEDORA_BUILD
+ script:
+ - |
+ if [[ -z "$CI_COMMIT_BEFORE_SHA" ]]; then
+ export CI_COMMIT_BEFORE_SHA=$(git rev-parse "${CI_COMMIT_SHA}~20")
+ fi
+
+ # Check if the commit exists in this branch
+ # This is not the case for a force push
+ git branch --contains $CI_COMMIT_BEFORE_SHA 2>/dev/null || export CI_COMMIT_BEFORE_SHA=$(git rev-parse "${CI_COMMIT_SHA}~20")
+
+ export CI_COMMIT_RANGE="$CI_COMMIT_BEFORE_SHA..$CI_COMMIT_SHA"
+
+ - csbuild
+ --build-dir=obj-csbuild
+ --prep-cmd="cmake -DCMAKE_BUILD_TYPE=Debug -DPICKY_DEVELOPER=ON -DUNIT_TESTING=ON @SRCDIR@"
+ --build-cmd "make clean && make -j$(nproc)"
+ --git-commit-range $CI_COMMIT_RANGE
+ --color
+ --print-current --print-fixed
+ tags:
+ - shared
+ except:
+ - tags
+ artifacts:
+ expire_in: 1 week
+ when: on_failure
+ paths:
+ - obj-csbuild/
+
freebsd/x86_64:
image:
script:
- build=$(dpkg-architecture -qDEB_HOST_GNU_TYPE)
- host="${CI_JOB_NAME#*.cross.}"
- mkdir -p obj && cd obj && cmake
- -DCMAKE_C_COMPILER="$(which $host-gcc)"
- -DCMAKE_CXX_COMPILER="$(which $host-g++)"
+ -DCMAKE_TOOLCHAIN_FILE=../cmake/Toolchain-Debian-mips.cmake
-DCMAKE_BUILD_TYPE=RelWithDebInfo
- -DUNIT_TESTING=ON .. && make -j$(nproc)
- - ctest --output-on-failure -j$(nproc)
+ -DUNIT_TESTING=ON .. &&
+ make -j$(nproc) &&
+ ctest --output-on-failure -j$(nproc)
tags:
- shared
except:
when: on_failure
paths:
- obj/scan
+
+visualstudio/x86_64:
+ script:
+ - $env:VCPKG_DEFAULT_TRIPLET="x64-windows"
+ - mkdir obj
+ - cd obj
+ - cmake
+ -A x64
+ -DCMAKE_TOOLCHAIN_FILE="$env:VCPKG_TOOLCHAIN_FILE"
+ -DPICKY_DEVELOPER=ON
+ -DUNIT_TESTING=ON ..
+ - cmake --build .
+ - ctest --output-on-failure
+ tags:
+ - vs2017
+ - windows
+ except:
+ - tags
+ only:
+ - branches@cmocka/cmocka
+ - branches@ansasaki/cmocka
+ - branches@cryptomilk/cmocka
+ artifacts:
+ expire_in: 1 week
+ when: on_failure
+ paths:
+ - obj/
+
+visualstudio/x86:
+ script:
+ - $env:VCPKG_DEFAULT_TRIPLET="x86-windows"
+ - mkdir obj
+ - cd obj
+ - cmake
+ -DCMAKE_TOOLCHAIN_FILE="$env:VCPKG_TOOLCHAIN_FILE"
+ -DPICKY_DEVELOPER=ON
+ -DWITH_SFTP=ON -DWITH_SERVER=ON -DWITH_ZLIB=ON -DWITH_PCAP=ON
+ -DUNIT_TESTING=ON ..
+ - cmake --build .
+ - ctest --output-on-failure
+ tags:
+ - vs2017
+ - windows
+ except:
+ - tags
+ only:
+ - branches@cmocka/cmocka
+ - branches@ansasaki/cmocka
+ - branches@cryptomilk/cmocka
+ artifacts:
+ expire_in: 1 week
+ when: on_failure
+ paths:
+ - obj/
--- /dev/null
+From addb1927eb979310a01abc65f29a5408a970da11 Mon Sep 17 00:00:00 2001
+From: Richard Bayerle <richi.bayerle@gmail.com>
+Date: Sun, 24 Feb 2019 16:38:05 +0000
+Subject: [PATCH] XML output is JUnit XML, not xUnit XML.
+
+---
+ doc/mainpage.dox | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+diff --git a/doc/mainpage.dox b/doc/mainpage.dox
+index 4c26d96..c378bb1 100644
+--- a/doc/mainpage.dox
++++ b/doc/mainpage.dox
+@@ -33,7 +33,7 @@ The CMocka library provides:
+ - Very well tested
+ - Testing of memory leaks, buffer overflows and underflows.
+ - A set of assert macros.
+- - Several supported output formats (stdout, TAP, xUnit XML, Subunit)
++ - Several supported output formats (stdout, TAP, JUnit XML, Subunit)
+ - License: Apache License 2.0
+
+ @section main-test A cmocka test
+@@ -119,7 +119,7 @@ supported values are:
+ - <tt>STDOUT</tt> for the default standard output printer
+ - <tt>SUBUNIT</tt> for subunit output
+ - <tt>TAP</tt> for Test Anything Protocol (TAP) output
+- - <tt>XML</tt> for xUnit XML format
++ - <tt>XML</tt> for JUnit XML format
+ The case doesn't matter.
+
+ The XML output goes to stderr by default. If the environment variable
+--
+2.18.1
+
include(DefineCompilerFlags)
include(DefinePlatformDefaults)
-project(cmocka VERSION 1.1.3 LANGUAGES C)
+project(cmocka VERSION 1.1.5 LANGUAGES C)
# global needed variables
set(APPLICATION_NAME ${PROJECT_NAME})
# Increment AGE. Set REVISION to 0
# If the source code was changed, but there were no interface changes:
# Increment REVISION.
-set(LIBRARY_VERSION "0.5.1")
+set(LIBRARY_VERSION "0.7.0")
set(LIBRARY_SOVERSION "0")
# include cmake files
endif (MINGW)
# check subdirectories
-add_subdirectory(doc)
add_subdirectory(include)
add_subdirectory(src)
+add_subdirectory(doc)
include(AddCMockaTest)
if (UNIT_TESTING)
add_subdirectory(tests)
endif (UNIT_TESTING)
-add_subdirectory(example)
+if (WITH_EXAMPLES)
+ add_subdirectory(example)
+endif ()
# pkg-config file
configure_file(cmocka.pc.cmake ${CMAKE_CURRENT_BINARY_DIR}/cmocka.pc)
)
# cmake config files
-set(CMOCKA_LIBRARY_NAME ${CMAKE_SHARED_LIBRARY_PREFIX}${PROJECT_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX})
+if (WIN32)
+ set(CMOCKA_LIBRARY_NAME ${CMAKE_SHARED_LIBRARY_PREFIX}${PROJECT_NAME}${CMAKE_IMPORT_LIBRARY_SUFFIX})
+else()
+ set(CMOCKA_LIBRARY_NAME ${CMAKE_SHARED_LIBRARY_PREFIX}${PROJECT_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX})
+endif()
set(INCLUDE_INSTALL_DIR ${CMAKE_INSTALL_INCLUDEDIR} CACHE INTERNAL "")
set(LIB_INSTALL_DIR ${CMAKE_INSTALL_LIBDIR} CACHE INTERNAL "")
+Thu Mar 28 2019 Andreas Schneider <asn@cryptomilk.org>
+ * cmocka version 1.1.5
+ * Added cmocka_set_skip_filter()
+
+Thu Mar 28 2019 Andreas Schneider <asn@cryptomilk.org>
+ * cmocka version 1.1.4
+ * Added assert_float(_not)_equal()
+ * Added expect_any_always()
+ * Small bug fixes
+
Wed Sep 26 2018 Andreas Schneider <asn@cryptomilk.org>
* cmocka version 1.1.3
* Fixed subunit output on failures
add_c_compiler_flag("-Werror=strict-overflow" SUPPORTED_COMPILER_FLAGS)
add_c_compiler_flag("-Wstrict-overflow=2" SUPPORTED_COMPILER_FLAGS)
add_c_compiler_flag("-Wno-format-zero-length" SUPPORTED_COMPILER_FLAGS)
+ add_c_compiler_flag("-Wmissing-field-initializers" SUPPORTED_COMPILER_FLAGS)
check_c_compiler_flag("-Wformat" REQUIRED_FLAGS_WFORMAT)
if (REQUIRED_FLAGS_WFORMAT)
add_c_compiler_flag("-Werror=format-security" SUPPORTED_COMPILER_FLAGS)
# Allow zero for a variadic macro argument
- add_c_compiler_flag("-Wno-gnu-zero-variadic-macro-arguments" SUPPORTED_COMPILER_FLAGS)
+ string(TOLOWER "${CMAKE_C_COMPILER_ID}" _C_COMPILER_ID)
+ if ("${_C_COMPILER_ID}" STREQUAL "clang")
+ add_c_compiler_flag("-Wno-gnu-zero-variadic-macro-arguments" SUPPORTED_COMPILER_FLAGS)
+ endif()
add_c_compiler_flag("-fno-common" SUPPORTED_COMPILER_FLAGS)
endif (WIN32)
find_library(RT_LIBRARY rt)
-if (RT_LIBRARY AND NOT LINUX)
+if (RT_LIBRARY AND NOT LINUX AND NOT ANDROID)
set(CMOCKA_REQUIRED_LIBRARIES ${RT_LIBRARY} CACHE INTERNAL "cmocka required system libraries")
endif ()
option(WITH_STATIC_LIB "Build with a static library" OFF)
option(WITH_CMOCKERY_SUPPORT "Install a cmockery header" OFF)
+option(WITH_EXAMPLES "Build examples" ON)
option(UNIT_TESTING "Build with unit testing" OFF)
option(PICKY_DEVELOPER "Build with picky developer flags" OFF)
# Create the compile command database for clang by default
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+# Always build with -fPIC
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+# Avoid source tree pollution
+set(CMAKE_DISABLE_SOURCE_CHANGES ON)
+set(CMAKE_DISABLE_IN_SOURCE_BUILD ON)
set(CMAKE_EXEC_LINKER_FLAGS_ADDRESSSANITIZER "-fsanitize=address"
CACHE STRING "Flags used by the linker during ADDRESSSANITIZER builds.")
+ # Activate with: -DCMAKE_BUILD_TYPE=MemorySanitizer
+ set(CMAKE_C_FLAGS_MEMORYSANITIZER "-g -O2 -fsanitize=memory -fsanitize-memory-track-origins=2 -fno-omit-frame-pointer"
+ CACHE STRING "Flags used by the C compiler during MEMORYSANITIZER builds.")
+ set(CMAKE_CXX_FLAGS_MEMORYSANITIZER "-g -O2 -fsanitize=memory -fsanitize-memory-track-origins=2 -fno-omit-frame-pointer"
+ CACHE STRING "Flags used by the CXX compiler during MEMORYSANITIZER builds.")
+ set(CMAKE_SHARED_LINKER_FLAGS_MEMORYSANITIZER "-fsanitize=memory"
+ CACHE STRING "Flags used by the linker during the creation of shared libraries during MEMORYSANITIZER builds.")
+ set(CMAKE_MODULE_LINKER_FLAGS_MEMORYSANITIZER "-fsanitize=memory"
+ CACHE STRING "Flags used by the linker during the creation of shared libraries during MEMORYSANITIZER builds.")
+ set(CMAKE_EXEC_LINKER_FLAGS_MEMORYSANITIZER "-fsanitize=memory"
+ CACHE STRING "Flags used by the linker during MEMORYSANITIZER builds.")
+
# Activate with: -DCMAKE_BUILD_TYPE=UndefinedSanitizer
set(CMAKE_C_FLAGS_UNDEFINEDSANITIZER "-g -O1 -fsanitize=undefined -fsanitize=null -fsanitize=alignment -fno-sanitize-recover"
CACHE STRING "Flags used by the C compiler during UNDEFINEDSANITIZER builds.")
--- /dev/null
+include(CMakeForceCompiler)
+
+set(TOOLCHAIN_PREFIX mips-linux-gnu)
+
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_VERSION 1)
+set(CMAKE_SYSTEM_PROCESSOR mips)
+
+# This is the location of the mips toolchain
+set(CMAKE_C_COMPILER ${TOOLCHAIN_PREFIX}-gcc)
+set(CMAKE_CXX_COMPILER ${TOOLCHAIN_PREFIX}-g++)
+
+# This is the file system root of the target
+set(CMAKE_FIND_ROOT_PATH /usr/${TOOLCHAIN_PREFIX})
+
+# Search for programs in the build host directories
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+
+# For libraries and headers in the target directories
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
#define LargestIntegralType unsigned long long
+
void _assert_true(const LargestIntegralType result,
const char* const expression,
const char * const file, const int line)
{
- __coverity_panic__();
+ if (!result) {
+ __coverity_panic__();
+ }
}
void _assert_int_equal(
const LargestIntegralType a, const LargestIntegralType b,
const char * const file, const int line)
{
- __coverity_panic__();
+ if (a != b) {
+ __coverity_panic__();
+ }
}
void _assert_int_not_equal(
const LargestIntegralType a, const LargestIntegralType b,
const char * const file, const int line)
{
- __coverity_panic__();
+ if (a == b) {
+ __coverity_panic__();
+ }
}
void _assert_return_code(const LargestIntegralType result,
const char * const file,
const int line)
{
- __coverity_panic__();
+ if (result != 0) {
+ __coverity_panic__();
+ }
}
void _assert_string_equal(const char * const a, const char * const b,
const char * const file, const int line)
{
- __coverity_panic__();
+ char ch;
+ int cmp;
+
+ __coverity_weak_guard_sink__(a, b);
+ __coverity_weak_guard_sink__(b, a);
+
+ ch = *((char *)a);
+ ch = *((char *)b);
+
+ if (cmp != 0) {
+ __coverity_panic__();
+ }
}
void _assert_string_not_equal(const char * const a, const char * const b,
const char *file, const int line)
{
- __coverity_panic__();
+ char ch;
+ int cmp;
+
+ __coverity_weak_guard_sink__(a, b);
+ __coverity_weak_guard_sink__(b, a);
+
+ ch = *((char *)a);
+ ch = *((char *)b);
+
+ if (cmp == 0) {
+ __coverity_panic__();
+ }
}
void _assert_memory_equal(const void * const a, const void * const b,
const size_t size, const char* const file,
const int line)
{
- __coverity_panic__();
+ unsigned char ch;
+ int cmp;
+
+ __coverity_weak_guard_sink__(a, b);
+ __coverity_weak_guard_sink__(b, a);
+
+ ch = *((unsigned char *)a);
+ ch = *((unsigned char *)b);
+
+ if (cmp != 0) {
+ __coverity_panic__();
+ }
}
void _assert_memory_not_equal(const void * const a, const void * const b,
const size_t size, const char* const file,
const int line)
{
- __coverity_panic__();
+ unsigned char ch;
+ int cmp;
+
+ __coverity_weak_guard_sink__(a, b);
+ __coverity_weak_guard_sink__(b, a);
+
+ ch = *((unsigned char *)a);
+ ch = *((unsigned char *)b);
+
+ if (cmp == 0) {
+ __coverity_panic__();
+ }
}
void _assert_in_range(
const LargestIntegralType value, const LargestIntegralType minimum,
const LargestIntegralType maximum, const char* const file, const int line)
{
- __coverity_panic__();
+ if (value < minimum || value > maximum) {
+ __coverity_panic__();
+ }
}
void _assert_not_in_range(
const LargestIntegralType value, const LargestIntegralType minimum,
const LargestIntegralType maximum, const char* const file, const int line)
{
- __coverity_panic__();
+ if (value > minimum && value < maximum) {
+ __coverity_panic__();
+ }
}
void _assert_in_set(
const LargestIntegralType value, const LargestIntegralType values[],
const size_t number_of_values, const char* const file, const int line)
{
- __coverity_panic__();
+ size_t i;
+
+ for (i = 0; i < number_of_values; i++) {
+ if (value == values[i]) {
+ return;
+ }
+ }
+ __coverity_panic__();
}
void _assert_not_in_set(
const LargestIntegralType value, const LargestIntegralType values[],
const size_t number_of_values, const char* const file, const int line)
{
- __coverity_panic__();
-}
+ size_t i;
+ for (i = 0; i < number_of_values; i++) {
+ if (value == values[i]) {
+ __coverity_panic__();
+ }
+ }
+}
doxygen_add_docs(docs
${cmocka-library_SOURCE_DIR}
- ${cmocka-headers_SOURCE_DIR}
+ ${cmocka-header_SOURCE_DIR}
${CMAKE_CURRENT_SOURCE_DIR})
endif(DOXYGEN_FOUND)
- Very well tested
- Testing of memory leaks, buffer overflows and underflows.
- A set of assert macros.
- - Several supported output formats (stdout, TAP, xUnit XML, Subunit)
+ - Several supported output formats (stdout, TAP, JUnit XML, Subunit)
- License: Apache License 2.0
@section main-test A cmocka test
- <tt>STDOUT</tt> for the default standard output printer
- <tt>SUBUNIT</tt> for subunit output
- <tt>TAP</tt> for Test Anything Protocol (TAP) output
- - <tt>XML</tt> for xUnit XML format
+ - <tt>XML</tt> for JUnit XML format
The case doesn't matter.
The XML output goes to stderr by default. If the environment variable
#include <stdarg.h>
#include <stddef.h>
+#include <stdint.h>
#include <setjmp.h>
#include <cmocka.h>
uptime_str = calc_uptime();
assert_null(uptime_str);
+
+ free(uptime_str);
}
int main(void)
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
+#include <stdint.h>
#include <cmocka.h>
/* A test case that does nothing and succeeds. */
/**
* @defgroup cmocka The CMocka API
*
- * These headers or their equivalents should be included prior to including
+ * These headers or their equivalents MUST be included prior to including
* this header file.
* @code
* #include <stdarg.h>
* #include <stddef.h>
* #include <setjmp.h>
+ * #include <stdint.h>
* @endcode
*
* This allows test applications to use custom definitions of C standard
# endif /* _WIN32 */
#endif /* LargestIntegralTypePrintfFormat */
+#ifndef FloatPrintfFormat
+# define FloatPrintfFormat "%f"
+#endif /* FloatPrintfFormat */
+
/* Perform an unsigned cast to LargestIntegralType. */
#define cast_to_largest_integral_type(value) \
((LargestIntegralType)(value))
/* WIN32 is an ILP32 platform */
typedef unsigned int uintptr_t;
# elif defined(_WIN64)
- typedef unsigned long int uintptr_t
+ typedef unsigned long int uintptr_t;
# else /* _WIN32 */
/* ILP32 and LP64 platforms */
* }
* @endcode
*
- * For a complete example please at a look
- * <a href="http://git.cryptomilk.org/projects/cmocka.git/tree/example/chef_wrap/waiter_test_wrap.c">here</a>.
+ * For a complete example please take a look
+ * <a href="https://git.cryptomilk.org/projects/cmocka.git/tree/example/mock">here</a>.
*
* @{
*/
* }
* @endcode
*
- * For a complete example please at a look at
- * <a href="http://git.cryptomilk.org/projects/cmocka.git/tree/example/chef_wrap/waiter_test_wrap.c">here</a>
+ * For a complete example please take a look
+ * <a href="https://git.cryptomilk.org/projects/cmocka.git/tree/example/mock">here</a>
*
* @{
*/
#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.
*
#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 strings are equal.
*
* The function prints an error message to standard error and terminates the
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_int_equal(
const LargestIntegralType a, const LargestIntegralType b,
const char * const file, const int line);
/**
* @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. Thep
+ * This allows to filter tests and only run the ones matching the pattern. The
* pattern can include two wildards. The first is '*', a wildcard that matches
* zero or more characters, or ‘?’, a wildcard that matches exactly one
* character.
*/
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 wildards. The first is '*', a wildcard that matches
+ * zero or more characters, or ‘?’, a wildcard that matches exactly one
+ * character.
+ *
+ * @param[in] pattern The pattern to match, e.g. "test_wurst*"
+ */
+void cmocka_set_skip_filter(const char *pattern);
+
/** @} */
#endif /* CMOCKA_H_ */
${CMAKE_INSTALL_LIBDIR}
LIBRARY DESTINATION
${CMAKE_INSTALL_LIBDIR}
+ RUNTIME DESTINATION
+ ${CMAKE_INSTALL_BINDIR}
COMPONENT
${PROJECT_NAME})
#include <stdlib.h>
#include <string.h>
#include <time.h>
+#include <float.h>
/*
* This allows to add a platform specific header file. Some embedded platforms
static const char *global_test_filter_pattern;
+static const char *global_skip_filter_pattern;
+
#ifndef _WIN32
/* Signals caught by exception_handler(). */
static const int exception_signals[] = {
remove_always_return_values_from_list(&global_call_ordering_head);
if (check_for_leftover_values_list(&global_call_ordering_head,
- "%s function was expected to be called but was not not.\n")) {
+ "%s function was expected to be called but was not.\n")) {
error_occurred = 1;
}
if (error_occurred) {
child_node = child_node->next, ++leftover_count) {
const FuncOrderingValue *const o =
(const FuncOrderingValue*) child_node->value;
- cm_print_error(error_message, o->function);
+ cm_print_error(error_message, "%s", o->function);
cm_print_error(SOURCE_LOCATION_FORMAT
": note: remaining item was declared here\n",
o->location.file, o->location.line);
if (!list_empty(child_list)) {
if (number_of_symbol_names == 1) {
const ListNode *child_node;
- cm_print_error(error_message, value->symbol_name);
+ cm_print_error(error_message, "%s", value->symbol_name);
for (child_node = child_list->next; child_node != child_list;
child_node = child_node->next) {
list_add_value(&global_call_ordering_head, ordering, count);
}
+/* Returns 1 if the specified float values are equal, else returns 0. */
+static int float_compare(const float left,
+ const float right,
+ const float epsilon) {
+ float absLeft;
+ float absRight;
+ float largest;
+ float relDiff;
+
+ float diff = left - right;
+ diff = (diff >= 0.f) ? diff : -diff;
+
+ // Check if the numbers are really close -- needed
+ // when comparing numbers near zero.
+ if (diff <= epsilon) {
+ return 1;
+ }
+
+ absLeft = (left >= 0.f) ? left : -left;
+ absRight = (right >= 0.f) ? right : -right;
+
+ largest = (absRight > absLeft) ? absRight : absLeft;
+ relDiff = largest * FLT_EPSILON;
+
+ if (diff > relDiff) {
+ return 0;
+ }
+ return 1;
+}
+
+/* Returns 1 if the specified float values are equal. If the values are not equal
+ * an error is displayed and 0 is returned. */
+static int float_values_equal_display_error(const float left,
+ const float right,
+ const float epsilon) {
+ const int equal = float_compare(left, right, epsilon);
+ if (!equal) {
+ cm_print_error(FloatPrintfFormat " != "
+ FloatPrintfFormat "\n", left, right);
+ }
+ return equal;
+}
+
+/* Returns 1 if the specified float values are different. If the values are equal
+ * an error is displayed and 0 is returned. */
+static int float_values_not_equal_display_error(const float left,
+ const float right,
+ const float epsilon) {
+ const int not_equal = (float_compare(left, right, epsilon) == 0);
+ if (!not_equal) {
+ cm_print_error(FloatPrintfFormat " == "
+ FloatPrintfFormat "\n", left, right);
+ }
+ return not_equal;
+}
+
/* Returns 1 if the specified values are equal. If the values are not equal
* an error is displayed and 0 is returned. */
static int values_equal_display_error(const LargestIntegralType left,
}
}
+void _assert_float_equal(const float a,
+ const float b,
+ const float epsilon,
+ const char * const file,
+ const int line) {
+ if (!float_values_equal_display_error(a, b, epsilon)) {
+ _fail(file, line);
+ }
+}
+
+void _assert_float_not_equal(const float a,
+ const float b,
+ const float epsilon,
+ const char * const file,
+ const int line) {
+ if (!float_values_not_equal_display_error(a, b, epsilon)) {
+ _fail(file, line);
+ }
+}
+
void _assert_int_equal(
const LargestIntegralType a, const LargestIntegralType b,
const char * const file, const int line) {
return &global_allocated_blocks;
}
-static void *libc_malloc(size_t size)
+static void *libc_calloc(size_t nmemb, size_t size)
{
-#undef malloc
- return malloc(size);
-#define malloc test_malloc
+#undef calloc
+ return calloc(nmemb, size);
+#define calloc test_calloc
}
static void libc_free(void *ptr)
if (cm_error_message == NULL) {
/* CREATE MESSAGE */
- cm_error_message = libc_malloc(len + 1);
+ cm_error_message = libc_calloc(1, len + 1);
if (cm_error_message == NULL) {
/* TODO */
goto end;
}
return ptr;
}
+#define calloc test_calloc
/* Use the real free in this function. */
global_test_filter_pattern = pattern;
}
+void cmocka_set_skip_filter(const char *pattern)
+{
+ global_skip_filter_pattern = pattern;
+}
+
/****************************************************************************
* TIME CALCULATIONS
****************************************************************************/
/* Make sure LargestIntegralType is at least the size of a pointer. */
assert_true(sizeof(LargestIntegralType) >= sizeof(void*));
- cm_tests = (struct CMUnitTestState *)libc_malloc(sizeof(struct CMUnitTestState) * num_tests);
+ cm_tests = libc_calloc(1, sizeof(struct CMUnitTestState) * num_tests);
if (cm_tests == NULL) {
return -1;
}
|| tests[i].setup_func != NULL
|| tests[i].teardown_func != NULL)) {
if (global_test_filter_pattern != NULL) {
- int ok;
+ int match;
+
+ match = c_strmatch(tests[i].name, global_test_filter_pattern);
+ if (!match) {
+ continue;
+ }
+ }
+ if (global_skip_filter_pattern != NULL) {
+ int match;
- ok = c_strmatch(tests[i].name, global_test_filter_pattern);
- if (!ok) {
+ match = c_strmatch(tests[i].name, global_skip_filter_pattern);
+ if (match) {
continue;
}
}
LIBRARY cmocka
EXPORTS
+ _assert_float_equal
+ _assert_float_not_equal
_assert_in_range
_assert_in_set
_assert_int_equal
cm_print_error
cmocka_set_message_output
cmocka_set_test_filter
+ cmocka_set_skip_filter
global_expect_assert_env
global_expecting_assert
global_last_failed_assert
test_fixtures
test_group_fixtures
test_groups
+ test_float_macros
test_assert_macros
test_assert_macros_fail
test_basics
test_ordering_fail
test_returns
test_returns_fail
- test_wildcard)
+ test_wildcard
+ test_skip_filter
+ )
if (TEST_EXCEPTION_HANDLER)
list(APPEND CMOCKA_TESTS test_exception_handler)
--- /dev/null
+/*
+ * Copyright 2019 Arnaud Gelas <arnaud.gelas@sensefly.com>
+ *
+ * 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.
+ */
+
+/* Use the unit test allocators */
+#define UNIT_TESTING 1
+
+#include <stdarg.h>
+#include <stddef.h>
+#include <setjmp.h>
+#include <cmocka.h>
+
+/* A test case that does check if float is equal. */
+static void float_test_success(void **state)
+{
+ (void)state; /* unused */
+
+ assert_float_equal(0.5f, 1.f / 2.f, 0.000001f);
+ assert_float_not_equal(0.5, 0.499f, 0.000001f);
+}
+
+int main(void) {
+ const struct CMUnitTest tests[] = {
+ cmocka_unit_test(float_test_success),
+ };
+
+ return cmocka_run_group_tests(tests, NULL, NULL);
+}
--- /dev/null
+/*
+ * Copyright (c) 2019 by Red Hat, Inc.
+ *
+ * Author: Anderson Toshiyuki Sasaki <ansasaki@redhat.com>
+ *
+ * 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.
+ */
+
+#include <stdarg.h>
+#include <stddef.h>
+#include <setjmp.h>
+#include <cmocka.h>
+
+static void test_skip1(void **state)
+{
+ (void)state;
+
+ assert_true(1);
+}
+
+static void test_skip2(void **state)
+{
+ (void)state;
+
+ assert_false(1);
+}
+
+static void test_fail(void **state)
+{
+ (void)state;
+
+ assert_false(1);
+}
+
+int main(void) {
+ const struct CMUnitTest tests[] = {
+ cmocka_unit_test(test_skip1),
+ cmocka_unit_test(test_skip2),
+ cmocka_unit_test(test_fail),
+ };
+
+ cmocka_set_test_filter("test_skip*");
+
+ cmocka_set_skip_filter("test_skip2");
+
+ return cmocka_run_group_tests(tests, NULL, NULL);
+}
projects / platform / upstream / cmocka.git / commitdiff