mirror of https://github.com/DaveGamble/cJSON
Merge branch 'develop'
This commit is contained in:
commit
97d7347a6e
|
@ -13,3 +13,4 @@ cJSON_test_utils
|
||||||
libcjson.so.*
|
libcjson.so.*
|
||||||
libcjson_utils.so.*
|
libcjson_utils.so.*
|
||||||
*.orig
|
*.orig
|
||||||
|
.vscode
|
||||||
|
|
|
@ -23,6 +23,6 @@ addons:
|
||||||
script:
|
script:
|
||||||
- mkdir build
|
- mkdir build
|
||||||
- cd build
|
- cd build
|
||||||
- cmake .. -DENABLE_CJSON_UTILS=On -DENABLE_VALGRIND="${VALGRIND}" -DENABLE_SANITIZERS="${SANITIZERS}"
|
- cmake .. -DENABLE_CJSON_UTILS=On -DENABLE_VALGRIND="${VALGRIND}" -DENABLE_SAFE_STACK="${VALGRIND}" -DENABLE_SANITIZERS="${SANITIZERS}"
|
||||||
- make
|
- make
|
||||||
- make test CTEST_OUTPUT_ON_FAILURE=On
|
- make test CTEST_OUTPUT_ON_FAILURE=On
|
||||||
|
|
104
CMakeLists.txt
104
CMakeLists.txt
|
@ -16,33 +16,46 @@ set(PROJECT_VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT
|
||||||
set(custom_compiler_flags)
|
set(custom_compiler_flags)
|
||||||
|
|
||||||
include(CheckCCompilerFlag)
|
include(CheckCCompilerFlag)
|
||||||
option(ENABLE_CUSTOM_COMPILER_FLAGS "Enables custom compiler flags for Clang and GCC" ON)
|
option(ENABLE_CUSTOM_COMPILER_FLAGS "Enables custom compiler flags" ON)
|
||||||
if (ENABLE_CUSTOM_COMPILER_FLAGS)
|
if (ENABLE_CUSTOM_COMPILER_FLAGS)
|
||||||
list(APPEND custom_compiler_flags
|
if (("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang") OR ("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU"))
|
||||||
-std=c89
|
list(APPEND custom_compiler_flags
|
||||||
-pedantic
|
-std=c89
|
||||||
-Wall
|
-pedantic
|
||||||
-Wextra
|
-Wall
|
||||||
-Werror
|
-Wextra
|
||||||
-Wstrict-prototypes
|
-Werror
|
||||||
-Wwrite-strings
|
-Wstrict-prototypes
|
||||||
-Wshadow
|
-Wwrite-strings
|
||||||
-Winit-self
|
-Wshadow
|
||||||
-Wcast-align
|
-Winit-self
|
||||||
-Wformat=2
|
-Wcast-align
|
||||||
-Wmissing-prototypes
|
-Wformat=2
|
||||||
-Wstrict-overflow=2
|
-Wmissing-prototypes
|
||||||
-Wcast-qual
|
-Wstrict-overflow=2
|
||||||
-Wundef
|
-Wcast-qual
|
||||||
-Wswitch-default
|
-Wundef
|
||||||
-Wconversion
|
-Wswitch-default
|
||||||
-Wc++-compat
|
-Wconversion
|
||||||
-fstack-protector-strong
|
-Wc++-compat
|
||||||
-Wcomma
|
-fstack-protector-strong
|
||||||
-Wdouble-promotion
|
-Wcomma
|
||||||
-Wparentheses
|
-Wdouble-promotion
|
||||||
-Wformat-overflow
|
-Wparentheses
|
||||||
|
-Wformat-overflow
|
||||||
|
-Wunused-macros
|
||||||
|
-Wmissing-variable-declarations
|
||||||
|
-Wused-but-marked-unused
|
||||||
|
-Wswitch-enum
|
||||||
)
|
)
|
||||||
|
elseif("${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC")
|
||||||
|
list(APPEND custom_compiler_flags
|
||||||
|
/GS
|
||||||
|
/Za
|
||||||
|
/sdl
|
||||||
|
/W4
|
||||||
|
)
|
||||||
|
endif()
|
||||||
endif()
|
endif()
|
||||||
|
|
||||||
option(ENABLE_SANITIZERS "Enables AddressSanitizer and UndefinedBehaviorSanitizer." OFF)
|
option(ENABLE_SANITIZERS "Enables AddressSanitizer and UndefinedBehaviorSanitizer." OFF)
|
||||||
|
@ -60,6 +73,16 @@ if (ENABLE_SANITIZERS)
|
||||||
)
|
)
|
||||||
endif()
|
endif()
|
||||||
|
|
||||||
|
option(ENABLE_SAFE_STACK "Enables the SafeStack instrumentation pass by the Code Pointer Integrity Project" OFF)
|
||||||
|
if (ENABLE_SAFE_STACK)
|
||||||
|
if (ENABLE_SANITIZERS)
|
||||||
|
message(FATAL_ERROR "ENABLE_SAFE_STACK cannot be used in combination with ENABLE_SANITIZERS")
|
||||||
|
endif()
|
||||||
|
list(APPEND custom_compiler_flags
|
||||||
|
-fsanitize=safe-stack
|
||||||
|
)
|
||||||
|
endif()
|
||||||
|
|
||||||
option(ENABLE_PUBLIC_SYMBOLS "Export library symbols." On)
|
option(ENABLE_PUBLIC_SYMBOLS "Export library symbols." On)
|
||||||
if (ENABLE_PUBLIC_SYMBOLS)
|
if (ENABLE_PUBLIC_SYMBOLS)
|
||||||
list(APPEND custom_compiler_flags -fvisibility=hidden)
|
list(APPEND custom_compiler_flags -fvisibility=hidden)
|
||||||
|
@ -99,7 +122,17 @@ set(CJSON_LIB cjson)
|
||||||
file(GLOB HEADERS cJSON.h)
|
file(GLOB HEADERS cJSON.h)
|
||||||
set(SOURCES cJSON.c)
|
set(SOURCES cJSON.c)
|
||||||
|
|
||||||
add_library("${CJSON_LIB}" "${HEADERS}" "${SOURCES}")
|
option(BUILD_SHARED_AND_STATIC_LIBS "Build both shared and static libraries" Off)
|
||||||
|
|
||||||
|
if (NOT BUILD_SHARED_AND_STATIC_LIBS)
|
||||||
|
add_library("${CJSON_LIB}" "${HEADERS}" "${SOURCES}")
|
||||||
|
else()
|
||||||
|
# See https://cmake.org/Wiki/CMake_FAQ#How_do_I_make_my_shared_and_static_libraries_have_the_same_root_name.2C_but_different_suffixes.3F
|
||||||
|
add_library("${CJSON_LIB}" SHARED "${HEADERS}" "${SOURCES}")
|
||||||
|
add_library("${CJSON_LIB}-static" STATIC "${HEADERS}" "${SOURCES}")
|
||||||
|
set_target_properties("${CJSON_LIB}-static" PROPERTIES OUTPUT_NAME "${CJSON_LIB}")
|
||||||
|
set_target_properties("${CJSON_LIB}-static" PROPERTIES PREFIX "lib")
|
||||||
|
endif()
|
||||||
if (NOT WIN32)
|
if (NOT WIN32)
|
||||||
target_link_libraries("${CJSON_LIB}" m)
|
target_link_libraries("${CJSON_LIB}" m)
|
||||||
endif()
|
endif()
|
||||||
|
@ -110,6 +143,9 @@ configure_file("${CMAKE_CURRENT_SOURCE_DIR}/library_config/libcjson.pc.in"
|
||||||
install(FILES cJSON.h DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/cjson")
|
install(FILES cJSON.h DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/cjson")
|
||||||
install (FILES "${CMAKE_CURRENT_BINARY_DIR}/libcjson.pc" DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
|
install (FILES "${CMAKE_CURRENT_BINARY_DIR}/libcjson.pc" DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
|
||||||
install(TARGETS "${CJSON_LIB}" DESTINATION "${CMAKE_INSTALL_LIBDIR}" EXPORT "${CJSON_LIB}")
|
install(TARGETS "${CJSON_LIB}" DESTINATION "${CMAKE_INSTALL_LIBDIR}" EXPORT "${CJSON_LIB}")
|
||||||
|
if (BUILD_SHARED_AND_STATIC_LIBS)
|
||||||
|
install(TARGETS "${CJSON_LIB}-static" DESTINATION "${CMAKE_INSTALL_LIBDIR}")
|
||||||
|
endif()
|
||||||
if(ENABLE_TARGET_EXPORT)
|
if(ENABLE_TARGET_EXPORT)
|
||||||
# export library information for CMake projects
|
# export library information for CMake projects
|
||||||
install(EXPORT "${CJSON_LIB}" DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/cJSON")
|
install(EXPORT "${CJSON_LIB}" DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/cJSON")
|
||||||
|
@ -128,13 +164,25 @@ if(ENABLE_CJSON_UTILS)
|
||||||
file(GLOB HEADERS_UTILS cJSON_Utils.h)
|
file(GLOB HEADERS_UTILS cJSON_Utils.h)
|
||||||
set(SOURCES_UTILS cJSON_Utils.c)
|
set(SOURCES_UTILS cJSON_Utils.c)
|
||||||
|
|
||||||
add_library("${CJSON_UTILS_LIB}" "${HEADERS_UTILS}" "${SOURCES_UTILS}")
|
if (NOT BUILD_SHARED_AND_STATIC_LIBS)
|
||||||
target_link_libraries("${CJSON_UTILS_LIB}" "${CJSON_LIB}")
|
add_library("${CJSON_UTILS_LIB}" "${HEADERS_UTILS}" "${SOURCES_UTILS}")
|
||||||
|
target_link_libraries("${CJSON_UTILS_LIB}" "${CJSON_LIB}")
|
||||||
|
else()
|
||||||
|
add_library("${CJSON_UTILS_LIB}" SHARED "${HEADERS_UTILS}" "${SOURCES_UTILS}")
|
||||||
|
target_link_libraries("${CJSON_UTILS_LIB}" "${CJSON_LIB}")
|
||||||
|
add_library("${CJSON_UTILS_LIB}-static" STATIC "${HEADERS_UTILS}" "${SOURCES_UTILS}")
|
||||||
|
target_link_libraries("${CJSON_UTILS_LIB}-static" "${CJSON_LIB}-static")
|
||||||
|
set_target_properties("${CJSON_UTILS_LIB}-static" PROPERTIES OUTPUT_NAME "${CJSON_UTILS_LIB}")
|
||||||
|
set_target_properties("${CJSON_UTILS_LIB}-static" PROPERTIES PREFIX "lib")
|
||||||
|
endif()
|
||||||
|
|
||||||
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/library_config/libcjson_utils.pc.in"
|
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/library_config/libcjson_utils.pc.in"
|
||||||
"${CMAKE_CURRENT_BINARY_DIR}/libcjson_utils.pc" @ONLY)
|
"${CMAKE_CURRENT_BINARY_DIR}/libcjson_utils.pc" @ONLY)
|
||||||
|
|
||||||
install(TARGETS "${CJSON_UTILS_LIB}" DESTINATION "${CMAKE_INSTALL_LIBDIR}" EXPORT "${CJSON_UTILS_LIB}")
|
install(TARGETS "${CJSON_UTILS_LIB}" DESTINATION "${CMAKE_INSTALL_LIBDIR}" EXPORT "${CJSON_UTILS_LIB}")
|
||||||
|
if (BUILD_SHARED_AND_STATIC_LIBS)
|
||||||
|
install(TARGETS "${CJSON_UTILS_LIB}-static" DESTINATION "${CMAKE_INSTALL_LIBDIR}")
|
||||||
|
endif()
|
||||||
install(FILES cJSON_Utils.h DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/cjson")
|
install(FILES cJSON_Utils.h DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/cjson")
|
||||||
install (FILES "${CMAKE_CURRENT_BINARY_DIR}/libcjson_utils.pc" DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
|
install (FILES "${CMAKE_CURRENT_BINARY_DIR}/libcjson_utils.pc" DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
|
||||||
if(ENABLE_TARGET_EXPORT)
|
if(ENABLE_TARGET_EXPORT)
|
||||||
|
|
|
@ -85,10 +85,12 @@ You can change the build process with a list of different options that you can p
|
||||||
* `-DENABLE_CJSON_TEST=On`: Enable building the tests. (on by default)
|
* `-DENABLE_CJSON_TEST=On`: Enable building the tests. (on by default)
|
||||||
* `-DENABLE_CJSON_UTILS=On`: Enable building cJSON_Utils. (off by default)
|
* `-DENABLE_CJSON_UTILS=On`: Enable building cJSON_Utils. (off by default)
|
||||||
* `-DENABLE_TARGET_EXPORT=On`: Enable the export of CMake targets. Turn off if it makes problems. (on by default)
|
* `-DENABLE_TARGET_EXPORT=On`: Enable the export of CMake targets. Turn off if it makes problems. (on by default)
|
||||||
* `-DENABLE_CUSTOM_COMPILER_FLAGS=On`: Enable custom compiler flags (currently for Clang and GCC). Turn off if it makes problems. (on by default)
|
* `-DENABLE_CUSTOM_COMPILER_FLAGS=On`: Enable custom compiler flags (currently for Clang, GCC and MSVC). Turn off if it makes problems. (on by default)
|
||||||
* `-DENABLE_VALGRIND=On`: Run tests with [valgrind](http://valgrind.org). (off by default)
|
* `-DENABLE_VALGRIND=On`: Run tests with [valgrind](http://valgrind.org). (off by default)
|
||||||
* `-DENABLE_SANITIZERS=On`: Compile cJSON with [AddressSanitizer](https://github.com/google/sanitizers/wiki/AddressSanitizer) and [UndefinedBehaviorSanitizer](https://clang.llvm.org/docs/UndefinedBehaviorSanitizer.html) enabled (if possible). (off by default)
|
* `-DENABLE_SANITIZERS=On`: Compile cJSON with [AddressSanitizer](https://github.com/google/sanitizers/wiki/AddressSanitizer) and [UndefinedBehaviorSanitizer](https://clang.llvm.org/docs/UndefinedBehaviorSanitizer.html) enabled (if possible). (off by default)
|
||||||
|
* `-DENABLE_SAFE_STACK`: Enable the [SafeStack](https://clang.llvm.org/docs/SafeStack.html) instrumentation pass. Currently only works with the Clang compiler. (off by default)
|
||||||
* `-DBUILD_SHARED_LIBS=On`: Build the shared libraries. (on by default)
|
* `-DBUILD_SHARED_LIBS=On`: Build the shared libraries. (on by default)
|
||||||
|
* `-DBUILD_SHARED_AND_STATIC_LIBS=On`: Build both shared and static libraries. (off by default)
|
||||||
* `-DCMAKE_INSTALL_PREFIX=/usr`: Set a prefix for the installation.
|
* `-DCMAKE_INSTALL_PREFIX=/usr`: Set a prefix for the installation.
|
||||||
* `-DENABLE_LOCALES=On`: Enable the usage of localeconv method. ( on by default )
|
* `-DENABLE_LOCALES=On`: Enable the usage of localeconv method. ( on by default )
|
||||||
|
|
||||||
|
|
|
@ -0,0 +1,86 @@
|
||||||
|
os: Visual Studio 2015
|
||||||
|
|
||||||
|
# ENABLE_CUSTOM_COMPILER_FLAGS - on by default
|
||||||
|
# ENABLE_SANITIZERS - off by default
|
||||||
|
# ENABLE_PUBLIC_SYMBOLS - on by default
|
||||||
|
# BUILD_SHARED_LIBS - on by default
|
||||||
|
# ENABLE_TARGET_EXPORT - on by default
|
||||||
|
# ENABLE_CJSON_UTILS - off by default
|
||||||
|
# ENABLE_CJSON_TEST -on by default
|
||||||
|
# ENABLE_VALGRIND - off by default
|
||||||
|
# ENABLE_FUZZING - off by default
|
||||||
|
|
||||||
|
environment:
|
||||||
|
matrix:
|
||||||
|
- GENERATOR: "Visual Studio 14 2015"
|
||||||
|
BUILD_SHARED_LIBS: ON
|
||||||
|
ENABLE_CJSON_TEST: OFF
|
||||||
|
ENABLE_CJSON_UTILS: ON
|
||||||
|
|
||||||
|
- GENERATOR: "Visual Studio 14 2015"
|
||||||
|
BUILD_SHARED_LIBS: OFF
|
||||||
|
ENABLE_CJSON_TEST: OFF
|
||||||
|
ENABLE_CJSON_UTILS: ON
|
||||||
|
|
||||||
|
- GENERATOR: "Visual Studio 12 2013"
|
||||||
|
BUILD_SHARED_LIBS: ON
|
||||||
|
ENABLE_CJSON_TEST: OFF
|
||||||
|
ENABLE_CJSON_UTILS: ON
|
||||||
|
|
||||||
|
- GENERATOR: "Visual Studio 12 2013"
|
||||||
|
BUILD_SHARED_LIBS: OFF
|
||||||
|
ENABLE_CJSON_TEST: OFF
|
||||||
|
ENABLE_CJSON_UTILS: ON
|
||||||
|
|
||||||
|
- GENERATOR: "Visual Studio 11 2012"
|
||||||
|
BUILD_SHARED_LIBS: ON
|
||||||
|
ENABLE_CJSON_TEST: OFF
|
||||||
|
ENABLE_CJSON_UTILS: ON
|
||||||
|
|
||||||
|
- GENERATOR: "Visual Studio 11 2012"
|
||||||
|
BUILD_SHARED_LIBS: OFF
|
||||||
|
ENABLE_CJSON_TEST: OFF
|
||||||
|
ENABLE_CJSON_UTILS: ON
|
||||||
|
|
||||||
|
- GENERATOR: "Visual Studio 10 2010"
|
||||||
|
BUILD_SHARED_LIBS: ON
|
||||||
|
ENABLE_CJSON_TEST: OFF
|
||||||
|
ENABLE_CJSON_UTILS: ON
|
||||||
|
|
||||||
|
- GENERATOR: "Visual Studio 10 2010"
|
||||||
|
BUILD_SHARED_LIBS: OFF
|
||||||
|
ENABLE_CJSON_TEST: OFF
|
||||||
|
ENABLE_CJSON_UTILS: ON
|
||||||
|
|
||||||
|
- GENERATOR: "Visual Studio 9 2008"
|
||||||
|
BUILD_SHARED_LIBS: ON
|
||||||
|
ENABLE_CJSON_TEST: OFF
|
||||||
|
ENABLE_CJSON_UTILS: ON
|
||||||
|
|
||||||
|
- GENERATOR: "Visual Studio 9 2008"
|
||||||
|
BUILD_SHARED_LIBS: OFF
|
||||||
|
ENABLE_CJSON_TEST: OFF
|
||||||
|
ENABLE_CJSON_UTILS: ON
|
||||||
|
|
||||||
|
|
||||||
|
platform:
|
||||||
|
- x86
|
||||||
|
- x64
|
||||||
|
matrix:
|
||||||
|
exclude:
|
||||||
|
- platform: x64
|
||||||
|
GENERATOR: "Visual Studio 9 2008"
|
||||||
|
|
||||||
|
configuration:
|
||||||
|
- Release
|
||||||
|
|
||||||
|
|
||||||
|
build_script:
|
||||||
|
- ps: if($env:PLATFORM -eq "x64") { $env:CMAKE_GEN_SUFFIX=" Win64" }
|
||||||
|
- cmake "-G%GENERATOR%%CMAKE_GEN_SUFFIX%" -DBUILD_SHARED_LIBS=%BUILD_SHARED_LIBS% -DENABLE_CJSON_TEST=%ENABLE_CJSON_TEST% -H. -Bbuild
|
||||||
|
- cmake --build build --config "%CONFIGURATION%"
|
||||||
|
|
||||||
|
|
||||||
|
on_failure:
|
||||||
|
- ps: if(Test-Path builds/CMakeFiles/CMakeOutput.log) { cat builds/CMakeFiles/CMakeOutput.log }
|
||||||
|
- ps: if(Test-Path builds/CMakeFiles/CMakeError.log) { cat builds/CMakeFiles/CMakeError.log }
|
62
cJSON.c
62
cJSON.c
|
@ -23,9 +23,19 @@
|
||||||
/* cJSON */
|
/* cJSON */
|
||||||
/* JSON parser in C. */
|
/* JSON parser in C. */
|
||||||
|
|
||||||
|
/* disable warnings about old C89 functions in MSVC */
|
||||||
|
#if !defined(_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
|
||||||
|
#define _CRT_SECURE_NO_DEPRECATE
|
||||||
|
#endif
|
||||||
|
|
||||||
#ifdef __GNUC__
|
#ifdef __GNUC__
|
||||||
#pragma GCC visibility push(default)
|
#pragma GCC visibility push(default)
|
||||||
#endif
|
#endif
|
||||||
|
#if defined(_MSC_VER)
|
||||||
|
#pragma warning (push)
|
||||||
|
/* disable warning about single line comments in system headers */
|
||||||
|
#pragma warning (disable : 4001)
|
||||||
|
#endif
|
||||||
|
|
||||||
#include <string.h>
|
#include <string.h>
|
||||||
#include <stdio.h>
|
#include <stdio.h>
|
||||||
|
@ -36,6 +46,9 @@
|
||||||
#include <ctype.h>
|
#include <ctype.h>
|
||||||
#include <locale.h>
|
#include <locale.h>
|
||||||
|
|
||||||
|
#if defined(_MSC_VER)
|
||||||
|
#pragma warning (pop)
|
||||||
|
#endif
|
||||||
#ifdef __GNUC__
|
#ifdef __GNUC__
|
||||||
#pragma GCC visibility pop
|
#pragma GCC visibility pop
|
||||||
#endif
|
#endif
|
||||||
|
@ -101,7 +114,27 @@ typedef struct internal_hooks
|
||||||
void *(*reallocate)(void *pointer, size_t size);
|
void *(*reallocate)(void *pointer, size_t size);
|
||||||
} internal_hooks;
|
} internal_hooks;
|
||||||
|
|
||||||
static internal_hooks global_hooks = { malloc, free, realloc };
|
#if defined(_MSC_VER)
|
||||||
|
/* work around MSVC error C2322: '...' address of dillimport '...' is not static */
|
||||||
|
static void *internal_malloc(size_t size)
|
||||||
|
{
|
||||||
|
return malloc(size);
|
||||||
|
}
|
||||||
|
static void internal_free(void *pointer)
|
||||||
|
{
|
||||||
|
free(pointer);
|
||||||
|
}
|
||||||
|
static void *internal_realloc(void *pointer, size_t size)
|
||||||
|
{
|
||||||
|
return realloc(pointer, size);
|
||||||
|
}
|
||||||
|
#else
|
||||||
|
#define internal_malloc malloc
|
||||||
|
#define internal_free free
|
||||||
|
#define internal_realloc realloc
|
||||||
|
#endif
|
||||||
|
|
||||||
|
static internal_hooks global_hooks = { internal_malloc, internal_free, internal_realloc };
|
||||||
|
|
||||||
static unsigned char* cJSON_strdup(const unsigned char* string, const internal_hooks * const hooks)
|
static unsigned char* cJSON_strdup(const unsigned char* string, const internal_hooks * const hooks)
|
||||||
{
|
{
|
||||||
|
@ -114,7 +147,8 @@ static unsigned char* cJSON_strdup(const unsigned char* string, const internal_h
|
||||||
}
|
}
|
||||||
|
|
||||||
length = strlen((const char*)string) + sizeof("");
|
length = strlen((const char*)string) + sizeof("");
|
||||||
if (!(copy = (unsigned char*)hooks->allocate(length)))
|
copy = (unsigned char*)hooks->allocate(length);
|
||||||
|
if (copy == NULL)
|
||||||
{
|
{
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
@ -212,7 +246,6 @@ typedef struct
|
||||||
|
|
||||||
/* check if the given size is left to read in a given parse buffer (starting with 1) */
|
/* check if the given size is left to read in a given parse buffer (starting with 1) */
|
||||||
#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length))
|
#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length))
|
||||||
#define cannot_read(buffer, size) (!can_read(buffer, size))
|
|
||||||
/* check if the buffer can be accessed at the given index (starting with 0) */
|
/* check if the buffer can be accessed at the given index (starting with 0) */
|
||||||
#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))
|
#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))
|
||||||
#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index))
|
#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index))
|
||||||
|
@ -937,6 +970,22 @@ static parse_buffer *buffer_skip_whitespace(parse_buffer * const buffer)
|
||||||
return buffer;
|
return buffer;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/* skip the UTF-8 BOM (byte order mark) if it is at the beginning of a buffer */
|
||||||
|
static parse_buffer *skip_utf8_bom(parse_buffer * const buffer)
|
||||||
|
{
|
||||||
|
if ((buffer == NULL) || (buffer->content == NULL) || (buffer->offset != 0))
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (can_access_at_index(buffer, 4) && (strncmp((const char*)buffer_at_offset(buffer), "\xEF\xBB\xBF", 3) == 0))
|
||||||
|
{
|
||||||
|
buffer->offset += 3;
|
||||||
|
}
|
||||||
|
|
||||||
|
return buffer;
|
||||||
|
}
|
||||||
|
|
||||||
/* Parse an object - create a new root, and populate. */
|
/* Parse an object - create a new root, and populate. */
|
||||||
CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated)
|
CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated)
|
||||||
{
|
{
|
||||||
|
@ -963,7 +1012,7 @@ CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return
|
||||||
goto fail;
|
goto fail;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!parse_value(item, buffer_skip_whitespace(&buffer)))
|
if (!parse_value(item, buffer_skip_whitespace(skip_utf8_bom(&buffer))))
|
||||||
{
|
{
|
||||||
/* parse failure. ep is set. */
|
/* parse failure. ep is set. */
|
||||||
goto fail;
|
goto fail;
|
||||||
|
@ -1199,7 +1248,6 @@ static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buf
|
||||||
return parse_object(item, input_buffer);
|
return parse_object(item, input_buffer);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1826,7 +1874,7 @@ CJSON_PUBLIC(void) cJSON_AddItemToObject(cJSON *object, const char *string, cJSO
|
||||||
item->type &= ~cJSON_StringIsConst;
|
item->type &= ~cJSON_StringIsConst;
|
||||||
}
|
}
|
||||||
|
|
||||||
#if defined (__clang__) || ((__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5))))
|
#if defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5))))
|
||||||
#pragma GCC diagnostic push
|
#pragma GCC diagnostic push
|
||||||
#endif
|
#endif
|
||||||
#ifdef __GNUC__
|
#ifdef __GNUC__
|
||||||
|
@ -1848,7 +1896,7 @@ CJSON_PUBLIC(void) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJ
|
||||||
item->type |= cJSON_StringIsConst;
|
item->type |= cJSON_StringIsConst;
|
||||||
cJSON_AddItemToArray(object, item);
|
cJSON_AddItemToArray(object, item);
|
||||||
}
|
}
|
||||||
#if defined (__clang__) || ((__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5))))
|
#if defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5))))
|
||||||
#pragma GCC diagnostic pop
|
#pragma GCC diagnostic pop
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
|
|
|
@ -20,13 +20,32 @@
|
||||||
THE SOFTWARE.
|
THE SOFTWARE.
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
/* disable warnings about old C89 functions in MSVC */
|
||||||
|
#if !defined(_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
|
||||||
|
#define _CRT_SECURE_NO_DEPRECATE
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef __GNUCC__
|
||||||
#pragma GCC visibility push(default)
|
#pragma GCC visibility push(default)
|
||||||
|
#endif
|
||||||
|
#if defined(_MSC_VER)
|
||||||
|
#pragma warning (push)
|
||||||
|
/* disable warning about single line comments in system headers */
|
||||||
|
#pragma warning (disable : 4001)
|
||||||
|
#endif
|
||||||
|
|
||||||
#include <ctype.h>
|
#include <ctype.h>
|
||||||
#include <string.h>
|
#include <string.h>
|
||||||
#include <stdlib.h>
|
#include <stdlib.h>
|
||||||
#include <stdio.h>
|
#include <stdio.h>
|
||||||
#include <limits.h>
|
#include <limits.h>
|
||||||
|
|
||||||
|
#if defined(_MSC_VER)
|
||||||
|
#pragma warning (pop)
|
||||||
|
#endif
|
||||||
|
#ifdef __GNUCC__
|
||||||
#pragma GCC visibility pop
|
#pragma GCC visibility pop
|
||||||
|
#endif
|
||||||
|
|
||||||
#include "cJSON_Utils.h"
|
#include "cJSON_Utils.h"
|
||||||
|
|
||||||
|
|
|
@ -25,6 +25,14 @@ if(ENABLE_CJSON_TEST)
|
||||||
target_compile_options(unity PRIVATE "-fno-sanitize=float-divide-by-zero")
|
target_compile_options(unity PRIVATE "-fno-sanitize=float-divide-by-zero")
|
||||||
endif()
|
endif()
|
||||||
endif()
|
endif()
|
||||||
|
# Disable -Wswitch-enum for Unity
|
||||||
|
if (FLAG_SUPPORTED_Wswitchenum)
|
||||||
|
if ("${CMAKE_VERSION}" VERSION_LESS "2.8.12")
|
||||||
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-switch-enum")
|
||||||
|
else()
|
||||||
|
target_compile_options(unity PRIVATE "-Wno-switch-enum")
|
||||||
|
endif()
|
||||||
|
endif()
|
||||||
|
|
||||||
#copy test files
|
#copy test files
|
||||||
file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/inputs")
|
file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/inputs")
|
||||||
|
|
|
@ -119,7 +119,7 @@ static cJSON_bool test_apply_patch(const cJSON * const test)
|
||||||
return successful;
|
return successful;
|
||||||
}
|
}
|
||||||
|
|
||||||
static cJSON_bool test_generate_test(cJSON *test __attribute__((unused)))
|
static cJSON_bool test_generate_test(cJSON *test)
|
||||||
{
|
{
|
||||||
cJSON *doc = NULL;
|
cJSON *doc = NULL;
|
||||||
cJSON *patch = NULL;
|
cJSON *patch = NULL;
|
||||||
|
|
|
@ -426,6 +426,30 @@ static void ensure_should_fail_on_failed_realloc(void)
|
||||||
TEST_ASSERT_NULL_MESSAGE(ensure(&buffer, 200), "Ensure didn't fail with failing realloc.");
|
TEST_ASSERT_NULL_MESSAGE(ensure(&buffer, 200), "Ensure didn't fail with failing realloc.");
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static void skip_utf8_bom_should_skip_bom(void)
|
||||||
|
{
|
||||||
|
const unsigned char string[] = "\xEF\xBB\xBF{}";
|
||||||
|
parse_buffer buffer = { 0, 0, 0, 0, { 0, 0, 0 } };
|
||||||
|
buffer.content = string;
|
||||||
|
buffer.length = sizeof(string);
|
||||||
|
buffer.hooks = global_hooks;
|
||||||
|
|
||||||
|
TEST_ASSERT_TRUE(skip_utf8_bom(&buffer) == &buffer);
|
||||||
|
TEST_ASSERT_EQUAL_UINT(3U, (unsigned int)buffer.offset);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void skip_utf8_bom_should_not_skip_bom_if_not_at_beginning(void)
|
||||||
|
{
|
||||||
|
const unsigned char string[] = " \xEF\xBB\xBF{}";
|
||||||
|
parse_buffer buffer = { 0, 0, 0, 0, { 0, 0, 0 } };
|
||||||
|
buffer.content = string;
|
||||||
|
buffer.length = sizeof(string);
|
||||||
|
buffer.hooks = global_hooks;
|
||||||
|
buffer.offset = 1;
|
||||||
|
|
||||||
|
TEST_ASSERT_NULL(skip_utf8_bom(&buffer));
|
||||||
|
}
|
||||||
|
|
||||||
int main(void)
|
int main(void)
|
||||||
{
|
{
|
||||||
UNITY_BEGIN();
|
UNITY_BEGIN();
|
||||||
|
@ -442,5 +466,8 @@ int main(void)
|
||||||
RUN_TEST(cjson_replace_item_in_object_should_preserve_name);
|
RUN_TEST(cjson_replace_item_in_object_should_preserve_name);
|
||||||
RUN_TEST(cjson_functions_shouldnt_crash_with_null_pointers);
|
RUN_TEST(cjson_functions_shouldnt_crash_with_null_pointers);
|
||||||
RUN_TEST(ensure_should_fail_on_failed_realloc);
|
RUN_TEST(ensure_should_fail_on_failed_realloc);
|
||||||
|
RUN_TEST(skip_utf8_bom_should_skip_bom);
|
||||||
|
RUN_TEST(skip_utf8_bom_should_not_skip_bom_if_not_at_beginning);
|
||||||
|
|
||||||
return UNITY_END();
|
return UNITY_END();
|
||||||
}
|
}
|
||||||
|
|
|
@ -81,6 +81,22 @@ static void parse_with_opts_should_return_parse_end(void)
|
||||||
cJSON_Delete(item);
|
cJSON_Delete(item);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static void parse_with_opts_should_parse_utf8_bom(void)
|
||||||
|
{
|
||||||
|
cJSON *with_bom = NULL;
|
||||||
|
cJSON *without_bom = NULL;
|
||||||
|
|
||||||
|
with_bom = cJSON_ParseWithOpts("\xEF\xBB\xBF{}", NULL, true);
|
||||||
|
TEST_ASSERT_NOT_NULL(with_bom);
|
||||||
|
without_bom = cJSON_ParseWithOpts("{}", NULL, true);
|
||||||
|
TEST_ASSERT_NOT_NULL(with_bom);
|
||||||
|
|
||||||
|
TEST_ASSERT_TRUE(cJSON_Compare(with_bom, without_bom, true));
|
||||||
|
|
||||||
|
cJSON_Delete(with_bom);
|
||||||
|
cJSON_Delete(without_bom);
|
||||||
|
}
|
||||||
|
|
||||||
int main(void)
|
int main(void)
|
||||||
{
|
{
|
||||||
UNITY_BEGIN();
|
UNITY_BEGIN();
|
||||||
|
@ -90,6 +106,7 @@ int main(void)
|
||||||
RUN_TEST(parse_with_opts_should_handle_incomplete_json);
|
RUN_TEST(parse_with_opts_should_handle_incomplete_json);
|
||||||
RUN_TEST(parse_with_opts_should_require_null_if_requested);
|
RUN_TEST(parse_with_opts_should_require_null_if_requested);
|
||||||
RUN_TEST(parse_with_opts_should_return_parse_end);
|
RUN_TEST(parse_with_opts_should_return_parse_end);
|
||||||
|
RUN_TEST(parse_with_opts_should_parse_utf8_bom);
|
||||||
|
|
||||||
return UNITY_END();
|
return UNITY_END();
|
||||||
}
|
}
|
||||||
|
|
|
@ -49,16 +49,16 @@ static void print_number_should_print_zero(void)
|
||||||
|
|
||||||
static void print_number_should_print_negative_integers(void)
|
static void print_number_should_print_negative_integers(void)
|
||||||
{
|
{
|
||||||
assert_print_number("-1", -1);
|
assert_print_number("-1", -1.0);
|
||||||
assert_print_number("-32768", -32768);
|
assert_print_number("-32768", -32768.0);
|
||||||
assert_print_number("-2147483648", -2147483648.0);
|
assert_print_number("-2147483648", -2147483648.0);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void print_number_should_print_positive_integers(void)
|
static void print_number_should_print_positive_integers(void)
|
||||||
{
|
{
|
||||||
assert_print_number("1", 1);
|
assert_print_number("1", 1.0);
|
||||||
assert_print_number("32767", 32767);
|
assert_print_number("32767", 32767.0);
|
||||||
assert_print_number("2147483647", 2147483647);
|
assert_print_number("2147483647", 2147483647.0);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void print_number_should_print_positive_reals(void)
|
static void print_number_should_print_positive_reals(void)
|
||||||
|
@ -68,6 +68,7 @@ static void print_number_should_print_positive_reals(void)
|
||||||
assert_print_number("1000000000000", 10e11);
|
assert_print_number("1000000000000", 10e11);
|
||||||
assert_print_number("1.23e+129", 123e+127);
|
assert_print_number("1.23e+129", 123e+127);
|
||||||
assert_print_number("1.23e-126", 123e-128);
|
assert_print_number("1.23e-126", 123e-128);
|
||||||
|
assert_print_number("3.1415926535897931", 3.1415926535897931);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void print_number_should_print_negative_reals(void)
|
static void print_number_should_print_negative_reals(void)
|
||||||
|
|
|
@ -118,6 +118,17 @@ Another way of calling TEST_ASSERT_EQUAL_INT
|
||||||
Asserts that the actual value is within plus or minus delta of the expected value. This also comes in
|
Asserts that the actual value is within plus or minus delta of the expected value. This also comes in
|
||||||
size specific variants.
|
size specific variants.
|
||||||
|
|
||||||
|
|
||||||
|
TEST_ASSERT_GREATER_THAN(threshold, actual)
|
||||||
|
|
||||||
|
Asserts that the actual value is greater than the threshold. This also comes in size specific variants.
|
||||||
|
|
||||||
|
|
||||||
|
TEST_ASSERT_LESS_THAN(threshold, actual)
|
||||||
|
|
||||||
|
Asserts that the actual value is less than the threshold. This also comes in size specific variants.
|
||||||
|
|
||||||
|
|
||||||
Arrays
|
Arrays
|
||||||
------
|
------
|
||||||
|
|
||||||
|
|
|
@ -172,7 +172,7 @@ class UnityModuleGenerator
|
||||||
when 'camel' then part1
|
when 'camel' then part1
|
||||||
when 'snake' then part1.downcase
|
when 'snake' then part1.downcase
|
||||||
when 'caps' then part1.upcase
|
when 'caps' then part1.upcase
|
||||||
else part1.downcase
|
else part1
|
||||||
end
|
end
|
||||||
else
|
else
|
||||||
case (@options[:naming])
|
case (@options[:naming])
|
||||||
|
@ -180,7 +180,7 @@ class UnityModuleGenerator
|
||||||
when 'camel' then part1 + part2
|
when 'camel' then part1 + part2
|
||||||
when 'snake' then part1.downcase + '_' + part2.downcase
|
when 'snake' then part1.downcase + '_' + part2.downcase
|
||||||
when 'caps' then part1.upcase + '_' + part2.upcase
|
when 'caps' then part1.upcase + '_' + part2.upcase
|
||||||
else part1.downcase + '_' + part2.downcase
|
else part1 + '_' + part2
|
||||||
end
|
end
|
||||||
end
|
end
|
||||||
end
|
end
|
||||||
|
@ -290,7 +290,7 @@ if $0 == __FILE__
|
||||||
' -n"camel" sets the file naming convention.',
|
' -n"camel" sets the file naming convention.',
|
||||||
' bumpy - BumpyCaseFilenames.',
|
' bumpy - BumpyCaseFilenames.',
|
||||||
' camel - camelCaseFilenames.',
|
' camel - camelCaseFilenames.',
|
||||||
' snake - snake_case_filenames. (DEFAULT)',
|
' snake - snake_case_filenames.',
|
||||||
' caps - CAPS_CASE_FILENAMES.',
|
' caps - CAPS_CASE_FILENAMES.',
|
||||||
' -u update subversion too (requires subversion command line)',
|
' -u update subversion too (requires subversion command line)',
|
||||||
' -y"my.yml" selects a different yaml config file for module generation',
|
' -y"my.yml" selects a different yaml config file for module generation',
|
||||||
|
|
|
@ -119,7 +119,7 @@ class UnityTestRunnerGenerator
|
||||||
source_index = 0
|
source_index = 0
|
||||||
tests_and_line_numbers.size.times do |i|
|
tests_and_line_numbers.size.times do |i|
|
||||||
source_lines[source_index..-1].each_with_index do |line, index|
|
source_lines[source_index..-1].each_with_index do |line, index|
|
||||||
next unless line =~ /#{tests_and_line_numbers[i][:test]}/
|
next unless line =~ /\s+#{tests_and_line_numbers[i][:test]}(?:\s|\()/
|
||||||
source_index += index
|
source_index += index
|
||||||
tests_and_line_numbers[i][:line_number] = source_index + 1
|
tests_and_line_numbers[i][:line_number] = source_index + 1
|
||||||
break
|
break
|
||||||
|
|
|
@ -290,6 +290,60 @@ Asserts the specified bit of the `actual` parameter is high.
|
||||||
|
|
||||||
Asserts the specified bit of the `actual` parameter is low.
|
Asserts the specified bit of the `actual` parameter is low.
|
||||||
|
|
||||||
|
### Integer Less Than / Greater Than
|
||||||
|
|
||||||
|
These assertions verify that the `actual` parameter is less than or greater
|
||||||
|
than `threshold` (exclusive). For example, if the threshold value is 0 for the
|
||||||
|
greater than assertion will fail if it is 0 or less.
|
||||||
|
|
||||||
|
##### `TEST_ASSERT_GREATER_THAN (threshold, actual)`
|
||||||
|
|
||||||
|
##### `TEST_ASSERT_GREATER_THAN_INT (threshold, actual)`
|
||||||
|
|
||||||
|
##### `TEST_ASSERT_GREATER_THAN_INT8 (threshold, actual)`
|
||||||
|
|
||||||
|
##### `TEST_ASSERT_GREATER_THAN_INT16 (threshold, actual)`
|
||||||
|
|
||||||
|
##### `TEST_ASSERT_GREATER_THAN_INT32 (threshold, actual)`
|
||||||
|
|
||||||
|
##### `TEST_ASSERT_GREATER_THAN_UINT (threshold, actual)`
|
||||||
|
|
||||||
|
##### `TEST_ASSERT_GREATER_THAN_UINT8 (threshold, actual)`
|
||||||
|
|
||||||
|
##### `TEST_ASSERT_GREATER_THAN_UINT16 (threshold, actual)`
|
||||||
|
|
||||||
|
##### `TEST_ASSERT_GREATER_THAN_UINT32 (threshold, actual)`
|
||||||
|
|
||||||
|
##### `TEST_ASSERT_GREATER_THAN_HEX8 (threshold, actual)`
|
||||||
|
|
||||||
|
##### `TEST_ASSERT_GREATER_THAN_HEX16 (threshold, actual)`
|
||||||
|
|
||||||
|
##### `TEST_ASSERT_GREATER_THAN_HEX32 (threshold, actual)`
|
||||||
|
|
||||||
|
##### `TEST_ASSERT_LESS_THAN (threshold, actual)`
|
||||||
|
|
||||||
|
##### `TEST_ASSERT_LESS_THAN_INT (threshold, actual)`
|
||||||
|
|
||||||
|
##### `TEST_ASSERT_LESS_THAN_INT8 (threshold, actual)`
|
||||||
|
|
||||||
|
##### `TEST_ASSERT_LESS_THAN_INT16 (threshold, actual)`
|
||||||
|
|
||||||
|
##### `TEST_ASSERT_LESS_THAN_INT32 (threshold, actual)`
|
||||||
|
|
||||||
|
##### `TEST_ASSERT_LESS_THAN_UINT (threshold, actual)`
|
||||||
|
|
||||||
|
##### `TEST_ASSERT_LESS_THAN_UINT8 (threshold, actual)`
|
||||||
|
|
||||||
|
##### `TEST_ASSERT_LESS_THAN_UINT16 (threshold, actual)`
|
||||||
|
|
||||||
|
##### `TEST_ASSERT_LESS_THAN_UINT32 (threshold, actual)`
|
||||||
|
|
||||||
|
##### `TEST_ASSERT_LESS_THAN_HEX8 (threshold, actual)`
|
||||||
|
|
||||||
|
##### `TEST_ASSERT_LESS_THAN_HEX16 (threshold, actual)`
|
||||||
|
|
||||||
|
##### `TEST_ASSERT_LESS_THAN_HEX32 (threshold, actual)`
|
||||||
|
|
||||||
|
|
||||||
### Integer Ranges (of all sizes)
|
### Integer Ranges (of all sizes)
|
||||||
|
|
||||||
|
|
|
@ -201,10 +201,12 @@
|
||||||
* `stdout` option. You decide to route your test result output to a custom
|
* `stdout` option. You decide to route your test result output to a custom
|
||||||
* serial `RS232_putc()` function you wrote like thus:
|
* serial `RS232_putc()` function you wrote like thus:
|
||||||
*/
|
*/
|
||||||
/* #define UNITY_OUTPUT_CHAR(a) RS232_putc(a) */
|
/* #define UNITY_OUTPUT_CHAR(a) RS232_putc(a) */
|
||||||
/* #define UNITY_OUTPUT_FLUSH() RS232_flush() */
|
/* #define UNITY_OUTPUT_CHAR_HEADER_DECLARATION RS232_putc(int) */
|
||||||
/* #define UNITY_OUTPUT_START() RS232_config(115200,1,8,0) */
|
/* #define UNITY_OUTPUT_FLUSH() RS232_flush() */
|
||||||
/* #define UNITY_OUTPUT_COMPLETE() RS232_close() */
|
/* #define UNITY_OUTPUT_FLUSH_HEADER_DECLARATION RS232_flush(void) */
|
||||||
|
/* #define UNITY_OUTPUT_START() RS232_config(115200,1,8,0) */
|
||||||
|
/* #define UNITY_OUTPUT_COMPLETE() RS232_close() */
|
||||||
|
|
||||||
/* For some targets, Unity can make the otherwise required `setUp()` and
|
/* For some targets, Unity can make the otherwise required `setUp()` and
|
||||||
* `tearDown()` functions optional. This is a nice convenience for test writers
|
* `tearDown()` functions optional. This is a nice convenience for test writers
|
||||||
|
|
|
@ -53,7 +53,7 @@ module RakefileHelpers
|
||||||
defines = if $cfg['compiler']['defines']['items'].nil?
|
defines = if $cfg['compiler']['defines']['items'].nil?
|
||||||
''
|
''
|
||||||
else
|
else
|
||||||
squash($cfg['compiler']['defines']['prefix'], $cfg['compiler']['defines']['items'] + ['UNITY_OUTPUT_CHAR=UnityOutputCharSpy_OutputChar'])
|
squash($cfg['compiler']['defines']['prefix'], $cfg['compiler']['defines']['items'] + ['UNITY_OUTPUT_CHAR=UnityOutputCharSpy_OutputChar'] + ['UNITY_OUTPUT_CHAR_HEADER_DECLARATION=UnityOutputCharSpy_OutputChar\(int\)'])
|
||||||
end
|
end
|
||||||
options = squash('', $cfg['compiler']['options'])
|
options = squash('', $cfg['compiler']['options'])
|
||||||
includes = squash($cfg['compiler']['includes']['prefix'], $cfg['compiler']['includes']['items'])
|
includes = squash($cfg['compiler']['includes']['prefix'], $cfg['compiler']['includes']['items'])
|
||||||
|
|
|
@ -6,6 +6,7 @@ endif
|
||||||
CFLAGS += -std=c99 -pedantic -Wall -Wextra -Werror
|
CFLAGS += -std=c99 -pedantic -Wall -Wextra -Werror
|
||||||
CFLAGS += $(DEBUG)
|
CFLAGS += $(DEBUG)
|
||||||
DEFINES = -D UNITY_OUTPUT_CHAR=UnityOutputCharSpy_OutputChar
|
DEFINES = -D UNITY_OUTPUT_CHAR=UnityOutputCharSpy_OutputChar
|
||||||
|
DEFINES += -D UNITY_OUTPUT_CHAR_HEADER_DECLARATION=UnityOutputCharSpy_OutputChar\(int\)
|
||||||
SRC = ../src/unity_fixture.c \
|
SRC = ../src/unity_fixture.c \
|
||||||
../../../src/unity.c \
|
../../../src/unity.c \
|
||||||
unity_fixture_Test.c \
|
unity_fixture_Test.c \
|
||||||
|
|
|
@ -1,2 +1,2 @@
|
||||||
120
|
121
|
||||||
|
|
||||||
|
|
|
@ -1,2 +1,2 @@
|
||||||
2.4.1
|
2.4.2
|
||||||
|
|
||||||
|
|
|
@ -27,6 +27,8 @@ static const char UnityStrNull[] = "NULL";
|
||||||
static const char UnityStrSpacer[] = ". ";
|
static const char UnityStrSpacer[] = ". ";
|
||||||
static const char UnityStrExpected[] = " Expected ";
|
static const char UnityStrExpected[] = " Expected ";
|
||||||
static const char UnityStrWas[] = " Was ";
|
static const char UnityStrWas[] = " Was ";
|
||||||
|
static const char UnityStrGt[] = " to be greater than ";
|
||||||
|
static const char UnityStrLt[] = " to be less than ";
|
||||||
static const char UnityStrElement[] = " Element ";
|
static const char UnityStrElement[] = " Element ";
|
||||||
static const char UnityStrByte[] = " Byte ";
|
static const char UnityStrByte[] = " Byte ";
|
||||||
static const char UnityStrMemory[] = " Memory Mismatch.";
|
static const char UnityStrMemory[] = " Memory Mismatch.";
|
||||||
|
@ -235,95 +237,97 @@ void UnityPrintMask(const UNITY_UINT mask, const UNITY_UINT number)
|
||||||
|
|
||||||
/*-----------------------------------------------*/
|
/*-----------------------------------------------*/
|
||||||
#ifndef UNITY_EXCLUDE_FLOAT_PRINT
|
#ifndef UNITY_EXCLUDE_FLOAT_PRINT
|
||||||
static void UnityPrintDecimalAndNumberWithLeadingZeros(UNITY_INT32 fraction_part, UNITY_INT32 divisor)
|
/* This function prints a floating-point value in a format similar to
|
||||||
{
|
* printf("%.6g"). It can work with either single- or double-precision,
|
||||||
UNITY_OUTPUT_CHAR('.');
|
* but for simplicity, it prints only 6 significant digits in either case.
|
||||||
while (divisor > 0)
|
* Printing more than 6 digits accurately is hard (at least in the single-
|
||||||
{
|
* precision case) and isn't attempted here. */
|
||||||
UNITY_OUTPUT_CHAR('0' + fraction_part / divisor);
|
|
||||||
fraction_part %= divisor;
|
|
||||||
divisor /= 10;
|
|
||||||
if (fraction_part == 0) break; /* Truncate trailing 0's */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#ifndef UNITY_ROUND_TIES_AWAY_FROM_ZERO
|
|
||||||
/* If rounds up && remainder 0.5 && result odd && below cutoff for double precision issues */
|
|
||||||
#define ROUND_TIES_TO_EVEN(orig, num_int, num) \
|
|
||||||
if (num_int > (num) && (num) - (num_int-1) <= 0.5 && (num_int & 1) == 1 && orig < 1e22) \
|
|
||||||
num_int -= 1 /* => a tie to round down to even */
|
|
||||||
#else
|
|
||||||
#define ROUND_TIES_TO_EVEN(orig, num_int, num) /* Remove macro */
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* Printing floating point numbers is hard. Some goals of this implementation: works for embedded
|
|
||||||
* systems, floats or doubles, and has a reasonable format. The key paper in this area,
|
|
||||||
* 'How to Print Floating-Point Numbers Accurately' by Steele & White, shows an approximation by
|
|
||||||
* scaling called Dragon 2. This code uses a similar idea. The other core algorithm uses casts and
|
|
||||||
* floating subtraction to give exact remainders after the decimal, to be scaled into an integer.
|
|
||||||
* Extra trailing 0's are excluded. The output defaults to rounding to nearest, ties to even. You
|
|
||||||
* can enable rounding ties away from zero. Note: UNITY_DOUBLE param can typedef to float or double
|
|
||||||
|
|
||||||
* The old version required compiling in snprintf. For reference, with a similar format as now:
|
|
||||||
* char buf[19];
|
|
||||||
* if (number > 4294967296.0 || -number > 4294967296.0) snprintf(buf, sizeof buf, "%.8e", number);
|
|
||||||
* else snprintf(buf, sizeof buf, "%.6f", number);
|
|
||||||
* UnityPrint(buf);
|
|
||||||
*/
|
|
||||||
void UnityPrintFloat(const UNITY_DOUBLE input_number)
|
void UnityPrintFloat(const UNITY_DOUBLE input_number)
|
||||||
{
|
{
|
||||||
UNITY_DOUBLE number;
|
UNITY_DOUBLE number = input_number;
|
||||||
|
|
||||||
if (input_number < 0)
|
/* print minus sign (including for negative zero) */
|
||||||
|
if (number < 0.0f || (number == 0.0f && 1.0f / number < 0.0f))
|
||||||
{
|
{
|
||||||
UNITY_OUTPUT_CHAR('-');
|
UNITY_OUTPUT_CHAR('-');
|
||||||
number = -input_number;
|
number = -number;
|
||||||
} else
|
|
||||||
{
|
|
||||||
number = input_number;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
if (isnan(number)) UnityPrint(UnityStrNaN);
|
/* handle zero, NaN, and +/- infinity */
|
||||||
else if (isinf(number)) UnityPrintLen(UnityStrInf, 3);
|
if (number == 0.0f) UnityPrint("0");
|
||||||
else if (number <= 0.0000005 && number > 0) UnityPrint("0.000000..."); /* Small number */
|
else if (isnan(number)) UnityPrint("nan");
|
||||||
else if (number < 4294967295.9999995) /* Rounded result fits in 32 bits, "%.6f" format */
|
else if (isinf(number)) UnityPrint("inf");
|
||||||
|
else
|
||||||
{
|
{
|
||||||
const UNITY_INT32 divisor = 1000000/10;
|
int exponent = 0;
|
||||||
UNITY_UINT32 integer_part = (UNITY_UINT32)number;
|
int decimals, digits;
|
||||||
UNITY_INT32 fraction_part = (UNITY_INT32)((number - (UNITY_DOUBLE)integer_part)*1000000.0 + 0.5);
|
UNITY_INT32 n;
|
||||||
/* Double precision calculation gives best performance for six rounded decimal places */
|
char buf[16];
|
||||||
ROUND_TIES_TO_EVEN(number, fraction_part, (number - (UNITY_DOUBLE)integer_part)*1000000.0);
|
|
||||||
|
|
||||||
if (fraction_part == 1000000) /* Carry across the decimal point */
|
/* scale up or down by powers of 10 */
|
||||||
|
while (number < 100000.0f / 1e6f) { number *= 1e6f; exponent -= 6; }
|
||||||
|
while (number < 100000.0f) { number *= 10.0f; exponent--; }
|
||||||
|
while (number > 1000000.0f * 1e6f) { number /= 1e6f; exponent += 6; }
|
||||||
|
while (number > 1000000.0f) { number /= 10.0f; exponent++; }
|
||||||
|
|
||||||
|
/* round to nearest integer */
|
||||||
|
n = ((UNITY_INT32)(number + number) + 1) / 2;
|
||||||
|
if (n > 999999)
|
||||||
{
|
{
|
||||||
fraction_part = 0;
|
n = 100000;
|
||||||
integer_part += 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
UnityPrintNumberUnsigned(integer_part);
|
|
||||||
UnityPrintDecimalAndNumberWithLeadingZeros(fraction_part, divisor);
|
|
||||||
}
|
|
||||||
else /* Number is larger, use exponential format of 9 digits, "%.8e" */
|
|
||||||
{
|
|
||||||
const UNITY_INT32 divisor = 1000000000/10;
|
|
||||||
UNITY_INT32 integer_part;
|
|
||||||
UNITY_DOUBLE_TYPE divide = 10.0;
|
|
||||||
int exponent = 9;
|
|
||||||
|
|
||||||
while (number / divide >= 1000000000.0 - 0.5)
|
|
||||||
{
|
|
||||||
divide *= 10;
|
|
||||||
exponent++;
|
exponent++;
|
||||||
}
|
}
|
||||||
integer_part = (UNITY_INT32)(number / divide + 0.5);
|
|
||||||
/* Double precision calculation required for float, to produce 9 rounded digits */
|
|
||||||
ROUND_TIES_TO_EVEN(number, integer_part, number / divide);
|
|
||||||
|
|
||||||
UNITY_OUTPUT_CHAR('0' + integer_part / divisor);
|
/* determine where to place decimal point */
|
||||||
UnityPrintDecimalAndNumberWithLeadingZeros(integer_part % divisor, divisor / 10);
|
decimals = (exponent <= 0 && exponent >= -9) ? -exponent : 5;
|
||||||
UNITY_OUTPUT_CHAR('e');
|
exponent += decimals;
|
||||||
UNITY_OUTPUT_CHAR('+');
|
|
||||||
if (exponent < 10) UNITY_OUTPUT_CHAR('0');
|
/* truncate trailing zeroes after decimal point */
|
||||||
UnityPrintNumber(exponent);
|
while (decimals > 0 && n % 10 == 0)
|
||||||
|
{
|
||||||
|
n /= 10;
|
||||||
|
decimals--;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* build up buffer in reverse order */
|
||||||
|
digits = 0;
|
||||||
|
while (n != 0 || digits < decimals + 1)
|
||||||
|
{
|
||||||
|
buf[digits++] = (char)('0' + n % 10);
|
||||||
|
n /= 10;
|
||||||
|
}
|
||||||
|
while (digits > 0)
|
||||||
|
{
|
||||||
|
if(digits == decimals) UNITY_OUTPUT_CHAR('.');
|
||||||
|
UNITY_OUTPUT_CHAR(buf[--digits]);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* print exponent if needed */
|
||||||
|
if (exponent != 0)
|
||||||
|
{
|
||||||
|
UNITY_OUTPUT_CHAR('e');
|
||||||
|
|
||||||
|
if(exponent < 0)
|
||||||
|
{
|
||||||
|
UNITY_OUTPUT_CHAR('-');
|
||||||
|
exponent = -exponent;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
UNITY_OUTPUT_CHAR('+');
|
||||||
|
}
|
||||||
|
|
||||||
|
digits = 0;
|
||||||
|
while (exponent != 0 || digits < 2)
|
||||||
|
{
|
||||||
|
buf[digits++] = (char)('0' + exponent % 10);
|
||||||
|
exponent /= 10;
|
||||||
|
}
|
||||||
|
while (digits > 0)
|
||||||
|
{
|
||||||
|
UNITY_OUTPUT_CHAR(buf[--digits]);
|
||||||
|
}
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
#endif /* ! UNITY_EXCLUDE_FLOAT_PRINT */
|
#endif /* ! UNITY_EXCLUDE_FLOAT_PRINT */
|
||||||
|
@ -526,6 +530,50 @@ void UnityAssertEqualNumber(const UNITY_INT expected,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/*-----------------------------------------------*/
|
||||||
|
void UnityAssertGreaterNumber(const UNITY_INT threshold,
|
||||||
|
const UNITY_INT actual,
|
||||||
|
const char *msg,
|
||||||
|
const UNITY_LINE_TYPE lineNumber,
|
||||||
|
const UNITY_DISPLAY_STYLE_T style)
|
||||||
|
{
|
||||||
|
RETURN_IF_FAIL_OR_IGNORE;
|
||||||
|
|
||||||
|
if (!(actual > threshold))
|
||||||
|
{
|
||||||
|
UnityTestResultsFailBegin(lineNumber);
|
||||||
|
UnityPrint(UnityStrExpected);
|
||||||
|
UnityPrintNumberByStyle(actual, style);
|
||||||
|
UnityPrint(UnityStrGt);
|
||||||
|
UnityPrintNumberByStyle(threshold, style);
|
||||||
|
UnityAddMsgIfSpecified(msg);
|
||||||
|
UNITY_FAIL_AND_BAIL;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/*-----------------------------------------------*/
|
||||||
|
void UnityAssertSmallerNumber(const UNITY_INT threshold,
|
||||||
|
const UNITY_INT actual,
|
||||||
|
const char *msg,
|
||||||
|
const UNITY_LINE_TYPE lineNumber,
|
||||||
|
const UNITY_DISPLAY_STYLE_T style)
|
||||||
|
{
|
||||||
|
RETURN_IF_FAIL_OR_IGNORE;
|
||||||
|
|
||||||
|
if (!(actual < threshold))
|
||||||
|
{
|
||||||
|
UnityTestResultsFailBegin(lineNumber);
|
||||||
|
UnityPrint(UnityStrExpected);
|
||||||
|
UnityPrintNumberByStyle(actual, style);
|
||||||
|
UnityPrint(UnityStrLt);
|
||||||
|
UnityPrintNumberByStyle(threshold, style);
|
||||||
|
UnityAddMsgIfSpecified(msg);
|
||||||
|
UNITY_FAIL_AND_BAIL;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
#define UnityPrintPointlessAndBail() \
|
#define UnityPrintPointlessAndBail() \
|
||||||
{ \
|
{ \
|
||||||
UnityTestResultsFailBegin(lineNumber); \
|
UnityTestResultsFailBegin(lineNumber); \
|
||||||
|
@ -1025,7 +1073,7 @@ void UnityAssertEqualStringArray(UNITY_INTERNAL_PTR expected,
|
||||||
{
|
{
|
||||||
UNITY_UINT32 i = 0;
|
UNITY_UINT32 i = 0;
|
||||||
UNITY_UINT32 j = 0;
|
UNITY_UINT32 j = 0;
|
||||||
const char* exp = NULL;
|
const char* expd = NULL;
|
||||||
const char* act = NULL;
|
const char* act = NULL;
|
||||||
|
|
||||||
RETURN_IF_FAIL_OR_IGNORE;
|
RETURN_IF_FAIL_OR_IGNORE;
|
||||||
|
@ -1048,7 +1096,7 @@ void UnityAssertEqualStringArray(UNITY_INTERNAL_PTR expected,
|
||||||
|
|
||||||
if (flags != UNITY_ARRAY_TO_ARRAY)
|
if (flags != UNITY_ARRAY_TO_ARRAY)
|
||||||
{
|
{
|
||||||
exp = (const char*)expected;
|
expd = (const char*)expected;
|
||||||
}
|
}
|
||||||
|
|
||||||
do
|
do
|
||||||
|
@ -1056,15 +1104,15 @@ void UnityAssertEqualStringArray(UNITY_INTERNAL_PTR expected,
|
||||||
act = actual[j];
|
act = actual[j];
|
||||||
if (flags == UNITY_ARRAY_TO_ARRAY)
|
if (flags == UNITY_ARRAY_TO_ARRAY)
|
||||||
{
|
{
|
||||||
exp = ((const char* const*)expected)[j];
|
expd = ((const char* const*)expected)[j];
|
||||||
}
|
}
|
||||||
|
|
||||||
/* if both pointers not null compare the strings */
|
/* if both pointers not null compare the strings */
|
||||||
if (exp && act)
|
if (expd && act)
|
||||||
{
|
{
|
||||||
for (i = 0; exp[i] || act[i]; i++)
|
for (i = 0; expd[i] || act[i]; i++)
|
||||||
{
|
{
|
||||||
if (exp[i] != act[i])
|
if (expd[i] != act[i])
|
||||||
{
|
{
|
||||||
Unity.CurrentTestFailed = 1;
|
Unity.CurrentTestFailed = 1;
|
||||||
break;
|
break;
|
||||||
|
@ -1073,7 +1121,7 @@ void UnityAssertEqualStringArray(UNITY_INTERNAL_PTR expected,
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{ /* handle case of one pointers being null (if both null, test should pass) */
|
{ /* handle case of one pointers being null (if both null, test should pass) */
|
||||||
if (exp != act)
|
if (expd != act)
|
||||||
{
|
{
|
||||||
Unity.CurrentTestFailed = 1;
|
Unity.CurrentTestFailed = 1;
|
||||||
}
|
}
|
||||||
|
@ -1087,7 +1135,7 @@ void UnityAssertEqualStringArray(UNITY_INTERNAL_PTR expected,
|
||||||
UnityPrint(UnityStrElement);
|
UnityPrint(UnityStrElement);
|
||||||
UnityPrintNumberUnsigned(j);
|
UnityPrintNumberUnsigned(j);
|
||||||
}
|
}
|
||||||
UnityPrintExpectedAndActualStrings(exp, act);
|
UnityPrintExpectedAndActualStrings(expd, act);
|
||||||
UnityAddMsgIfSpecified(msg);
|
UnityAddMsgIfSpecified(msg);
|
||||||
UNITY_FAIL_AND_BAIL;
|
UNITY_FAIL_AND_BAIL;
|
||||||
}
|
}
|
||||||
|
|
|
@ -114,6 +114,35 @@ void tearDown(void);
|
||||||
#define TEST_ASSERT_BIT_HIGH(bit, actual) UNITY_TEST_ASSERT_BITS(((UNITY_UINT32)1 << (bit)), (UNITY_UINT32)(-1), (actual), __LINE__, NULL)
|
#define TEST_ASSERT_BIT_HIGH(bit, actual) UNITY_TEST_ASSERT_BITS(((UNITY_UINT32)1 << (bit)), (UNITY_UINT32)(-1), (actual), __LINE__, NULL)
|
||||||
#define TEST_ASSERT_BIT_LOW(bit, actual) UNITY_TEST_ASSERT_BITS(((UNITY_UINT32)1 << (bit)), (UNITY_UINT32)(0), (actual), __LINE__, NULL)
|
#define TEST_ASSERT_BIT_LOW(bit, actual) UNITY_TEST_ASSERT_BITS(((UNITY_UINT32)1 << (bit)), (UNITY_UINT32)(0), (actual), __LINE__, NULL)
|
||||||
|
|
||||||
|
/* Integer Greater Than/ Less Than (of all sizes) */
|
||||||
|
#define TEST_ASSERT_GREATER_THAN(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_INT((threshold), (actual), __LINE__, NULL)
|
||||||
|
#define TEST_ASSERT_GREATER_THAN_INT(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_INT((threshold), (actual), __LINE__, NULL)
|
||||||
|
#define TEST_ASSERT_GREATER_THAN_INT8(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_INT8((threshold), (actual), __LINE__, NULL)
|
||||||
|
#define TEST_ASSERT_GREATER_THAN_INT16(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_INT16((threshold), (actual), __LINE__, NULL)
|
||||||
|
#define TEST_ASSERT_GREATER_THAN_INT32(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_INT32((threshold), (actual), __LINE__, NULL)
|
||||||
|
#define TEST_ASSERT_GREATER_THAN_UINT(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_UINT((threshold), (actual), __LINE__, NULL)
|
||||||
|
#define TEST_ASSERT_GREATER_THAN_UINT8(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_UINT8((threshold), (actual), __LINE__, NULL)
|
||||||
|
#define TEST_ASSERT_GREATER_THAN_UINT16(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_UINT16((threshold), (actual), __LINE__, NULL)
|
||||||
|
#define TEST_ASSERT_GREATER_THAN_UINT32(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_UINT32((threshold), (actual), __LINE__, NULL)
|
||||||
|
#define TEST_ASSERT_GREATER_THAN_HEX8(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_HEX8((threshold), (actual), __LINE__, NULL)
|
||||||
|
#define TEST_ASSERT_GREATER_THAN_HEX16(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_HEX16((threshold), (actual), __LINE__, NULL)
|
||||||
|
#define TEST_ASSERT_GREATER_THAN_HEX32(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_HEX32((threshold), (actual), __LINE__, NULL)
|
||||||
|
|
||||||
|
|
||||||
|
#define TEST_ASSERT_LESS_THAN(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_INT((threshold), (actual), __LINE__, NULL)
|
||||||
|
#define TEST_ASSERT_LESS_THAN_INT(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_INT((threshold), (actual), __LINE__, NULL)
|
||||||
|
#define TEST_ASSERT_LESS_THAN_INT8(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_INT8((threshold), (actual), __LINE__, NULL)
|
||||||
|
#define TEST_ASSERT_LESS_THAN_INT16(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_INT16((threshold), (actual), __LINE__, NULL)
|
||||||
|
#define TEST_ASSERT_LESS_THAN_INT32(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_INT32((threshold), (actual), __LINE__, NULL)
|
||||||
|
#define TEST_ASSERT_LESS_THAN_UINT(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_UINT((threshold), (actual), __LINE__, NULL)
|
||||||
|
#define TEST_ASSERT_LESS_THAN_UINT8(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_UINT8((threshold), (actual), __LINE__, NULL)
|
||||||
|
#define TEST_ASSERT_LESS_THAN_UINT16(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_UINT16((threshold), (actual), __LINE__, NULL)
|
||||||
|
#define TEST_ASSERT_LESS_THAN_UINT32(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_UINT32((threshold), (actual), __LINE__, NULL)
|
||||||
|
#define TEST_ASSERT_LESS_THAN_HEX8(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_HEX8((threshold), (actual), __LINE__, NULL)
|
||||||
|
#define TEST_ASSERT_LESS_THAN_HEX16(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_HEX16((threshold), (actual), __LINE__, NULL)
|
||||||
|
#define TEST_ASSERT_LESS_THAN_HEX32(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_HEX32((threshold), (actual), __LINE__, NULL)
|
||||||
|
|
||||||
|
|
||||||
/* Integer Ranges (of all sizes) */
|
/* Integer Ranges (of all sizes) */
|
||||||
#define TEST_ASSERT_INT_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT_WITHIN((delta), (expected), (actual), __LINE__, NULL)
|
#define TEST_ASSERT_INT_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT_WITHIN((delta), (expected), (actual), __LINE__, NULL)
|
||||||
#define TEST_ASSERT_INT8_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT8_WITHIN((delta), (expected), (actual), __LINE__, NULL)
|
#define TEST_ASSERT_INT8_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT8_WITHIN((delta), (expected), (actual), __LINE__, NULL)
|
||||||
|
@ -157,6 +186,8 @@ void tearDown(void);
|
||||||
#define TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_STRING_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
|
#define TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_STRING_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
|
||||||
#define TEST_ASSERT_EQUAL_MEMORY_ARRAY(expected, actual, len, num_elements) UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((expected), (actual), (len), (num_elements), __LINE__, NULL)
|
#define TEST_ASSERT_EQUAL_MEMORY_ARRAY(expected, actual, len, num_elements) UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((expected), (actual), (len), (num_elements), __LINE__, NULL)
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/* Arrays Compared To Single Value */
|
/* Arrays Compared To Single Value */
|
||||||
#define TEST_ASSERT_EACH_EQUAL_INT(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_INT((expected), (actual), (num_elements), __LINE__, NULL)
|
#define TEST_ASSERT_EACH_EQUAL_INT(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_INT((expected), (actual), (num_elements), __LINE__, NULL)
|
||||||
#define TEST_ASSERT_EACH_EQUAL_INT8(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_INT8((expected), (actual), (num_elements), __LINE__, NULL)
|
#define TEST_ASSERT_EACH_EQUAL_INT8(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_INT8((expected), (actual), (num_elements), __LINE__, NULL)
|
||||||
|
@ -241,6 +272,35 @@ void tearDown(void);
|
||||||
#define TEST_ASSERT_BIT_HIGH_MESSAGE(bit, actual, message) UNITY_TEST_ASSERT_BITS(((UNITY_UINT32)1 << (bit)), (UNITY_UINT32)(-1), (actual), __LINE__, (message))
|
#define TEST_ASSERT_BIT_HIGH_MESSAGE(bit, actual, message) UNITY_TEST_ASSERT_BITS(((UNITY_UINT32)1 << (bit)), (UNITY_UINT32)(-1), (actual), __LINE__, (message))
|
||||||
#define TEST_ASSERT_BIT_LOW_MESSAGE(bit, actual, message) UNITY_TEST_ASSERT_BITS(((UNITY_UINT32)1 << (bit)), (UNITY_UINT32)(0), (actual), __LINE__, (message))
|
#define TEST_ASSERT_BIT_LOW_MESSAGE(bit, actual, message) UNITY_TEST_ASSERT_BITS(((UNITY_UINT32)1 << (bit)), (UNITY_UINT32)(0), (actual), __LINE__, (message))
|
||||||
|
|
||||||
|
/* Integer Greater Than/ Less Than (of all sizes) */
|
||||||
|
#define TEST_ASSERT_GREATER_THAN_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_INT((threshold), (actual), __LINE__, (message))
|
||||||
|
#define TEST_ASSERT_GREATER_THAN_INT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_INT((threshold), (actual), __LINE__, (message))
|
||||||
|
#define TEST_ASSERT_GREATER_THAN_INT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_INT8((threshold), (actual), __LINE__, (message))
|
||||||
|
#define TEST_ASSERT_GREATER_THAN_INT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_INT16((threshold), (actual), __LINE__, (message))
|
||||||
|
#define TEST_ASSERT_GREATER_THAN_INT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_INT32((threshold), (actual), __LINE__, (message))
|
||||||
|
#define TEST_ASSERT_GREATER_THAN_UINT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_UINT((threshold), (actual), __LINE__, (message))
|
||||||
|
#define TEST_ASSERT_GREATER_THAN_UINT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_UINT8((threshold), (actual), __LINE__, (message))
|
||||||
|
#define TEST_ASSERT_GREATER_THAN_UINT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_UINT16((threshold), (actual), __LINE__, (message))
|
||||||
|
#define TEST_ASSERT_GREATER_THAN_UINT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_UINT32((threshold), (actual), __LINE__, (message))
|
||||||
|
#define TEST_ASSERT_GREATER_THAN_HEX8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_HEX8((threshold), (actual), __LINE__, (message))
|
||||||
|
#define TEST_ASSERT_GREATER_THAN_HEX16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_HEX16((threshold), (actual), __LINE__, (message))
|
||||||
|
#define TEST_ASSERT_GREATER_THAN_HEX32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_HEX32((threshold), (actual), __LINE__, (message))
|
||||||
|
|
||||||
|
|
||||||
|
#define TEST_ASSERT_LESS_THAN_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_INT((threshold), (actual), __LINE__, (message))
|
||||||
|
#define TEST_ASSERT_LESS_THAN_INT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_INT((threshold), (actual), __LINE__, (message))
|
||||||
|
#define TEST_ASSERT_LESS_THAN_INT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_INT8((threshold), (actual), __LINE__, (message))
|
||||||
|
#define TEST_ASSERT_LESS_THAN_INT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_INT16((threshold), (actual), __LINE__, (message))
|
||||||
|
#define TEST_ASSERT_LESS_THAN_INT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_INT32((threshold), (actual), __LINE__, (message))
|
||||||
|
#define TEST_ASSERT_LESS_THAN_UINT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_UINT((threshold), (actual), __LINE__, (message))
|
||||||
|
#define TEST_ASSERT_LESS_THAN_UINT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_UINT8((threshold), (actual), __LINE__, (message))
|
||||||
|
#define TEST_ASSERT_LESS_THAN_UINT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_UINT16((threshold), (actual), __LINE__, (message))
|
||||||
|
#define TEST_ASSERT_LESS_THAN_UINT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_UINT32((threshold), (actual), __LINE__, (message))
|
||||||
|
#define TEST_ASSERT_LESS_THAN_HEX8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_HEX8((threshold), (actual), __LINE__, (message))
|
||||||
|
#define TEST_ASSERT_LESS_THAN_HEX16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_HEX16((threshold), (actual), __LINE__, (message))
|
||||||
|
#define TEST_ASSERT_LESS_THAN_HEX32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_HEX32((threshold), (actual), __LINE__, (message))
|
||||||
|
|
||||||
|
|
||||||
/* Integer Ranges (of all sizes) */
|
/* Integer Ranges (of all sizes) */
|
||||||
#define TEST_ASSERT_INT_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT_WITHIN((delta), (expected), (actual), __LINE__, (message))
|
#define TEST_ASSERT_INT_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT_WITHIN((delta), (expected), (actual), __LINE__, (message))
|
||||||
#define TEST_ASSERT_INT8_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT8_WITHIN((delta), (expected), (actual), __LINE__, (message))
|
#define TEST_ASSERT_INT8_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT8_WITHIN((delta), (expected), (actual), __LINE__, (message))
|
||||||
|
|
|
@ -244,8 +244,8 @@ typedef UNITY_FLOAT_TYPE UNITY_FLOAT;
|
||||||
#define UNITY_OUTPUT_CHAR(a) (void)putchar(a)
|
#define UNITY_OUTPUT_CHAR(a) (void)putchar(a)
|
||||||
#else
|
#else
|
||||||
/* If defined as something else, make sure we declare it here so it's ready for use */
|
/* If defined as something else, make sure we declare it here so it's ready for use */
|
||||||
#ifndef UNITY_OMIT_OUTPUT_CHAR_HEADER_DECLARATION
|
#ifdef UNITY_OUTPUT_CHAR_HEADER_DECLARATION
|
||||||
extern void UNITY_OUTPUT_CHAR(int);
|
extern void UNITY_OUTPUT_CHAR_HEADER_DECLARATION;
|
||||||
#endif
|
#endif
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
|
@ -253,22 +253,22 @@ extern void UNITY_OUTPUT_CHAR(int);
|
||||||
#ifdef UNITY_USE_FLUSH_STDOUT
|
#ifdef UNITY_USE_FLUSH_STDOUT
|
||||||
/* We want to use the stdout flush utility */
|
/* We want to use the stdout flush utility */
|
||||||
#include <stdio.h>
|
#include <stdio.h>
|
||||||
#define UNITY_OUTPUT_FLUSH (void)fflush(stdout)
|
#define UNITY_OUTPUT_FLUSH() (void)fflush(stdout)
|
||||||
#else
|
#else
|
||||||
/* We've specified nothing, therefore flush should just be ignored */
|
/* We've specified nothing, therefore flush should just be ignored */
|
||||||
#define UNITY_OUTPUT_FLUSH
|
#define UNITY_OUTPUT_FLUSH()
|
||||||
#endif
|
#endif
|
||||||
#else
|
#else
|
||||||
/* We've defined flush as something else, so make sure we declare it here so it's ready for use */
|
/* We've defined flush as something else, so make sure we declare it here so it's ready for use */
|
||||||
#ifndef UNITY_OMIT_OUTPUT_FLUSH_HEADER_DECLARATION
|
#ifdef UNITY_OUTPUT_FLUSH_HEADER_DECLARATION
|
||||||
extern void UNITY_OUTPUT_FLUSH(void);
|
extern void UNITY_OMIT_OUTPUT_FLUSH_HEADER_DECLARATION;
|
||||||
#endif
|
#endif
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#ifndef UNITY_OUTPUT_FLUSH
|
#ifndef UNITY_OUTPUT_FLUSH
|
||||||
#define UNITY_FLUSH_CALL()
|
#define UNITY_FLUSH_CALL()
|
||||||
#else
|
#else
|
||||||
#define UNITY_FLUSH_CALL() UNITY_OUTPUT_FLUSH
|
#define UNITY_FLUSH_CALL() UNITY_OUTPUT_FLUSH()
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#ifndef UNITY_PRINT_EOL
|
#ifndef UNITY_PRINT_EOL
|
||||||
|
@ -453,6 +453,18 @@ void UnityAssertEqualNumber(const UNITY_INT expected,
|
||||||
const UNITY_LINE_TYPE lineNumber,
|
const UNITY_LINE_TYPE lineNumber,
|
||||||
const UNITY_DISPLAY_STYLE_T style);
|
const UNITY_DISPLAY_STYLE_T style);
|
||||||
|
|
||||||
|
void UnityAssertGreaterNumber(const UNITY_INT threshold,
|
||||||
|
const UNITY_INT actual,
|
||||||
|
const char* msg,
|
||||||
|
const UNITY_LINE_TYPE lineNumber,
|
||||||
|
const UNITY_DISPLAY_STYLE_T style);
|
||||||
|
|
||||||
|
void UnityAssertSmallerNumber(const UNITY_INT threshold,
|
||||||
|
const UNITY_INT actual,
|
||||||
|
const char* msg,
|
||||||
|
const UNITY_LINE_TYPE lineNumber,
|
||||||
|
const UNITY_DISPLAY_STYLE_T style);
|
||||||
|
|
||||||
void UnityAssertEqualIntArray(UNITY_INTERNAL_PTR expected,
|
void UnityAssertEqualIntArray(UNITY_INTERNAL_PTR expected,
|
||||||
UNITY_INTERNAL_PTR actual,
|
UNITY_INTERNAL_PTR actual,
|
||||||
const UNITY_UINT32 num_elements,
|
const UNITY_UINT32 num_elements,
|
||||||
|
@ -650,6 +662,34 @@ int UnityTestMatches(void);
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_HEX32(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT32)(expected), (UNITY_INT)(UNITY_INT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32)
|
#define UNITY_TEST_ASSERT_EQUAL_HEX32(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT32)(expected), (UNITY_INT)(UNITY_INT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32)
|
||||||
#define UNITY_TEST_ASSERT_BITS(mask, expected, actual, line, message) UnityAssertBits((UNITY_INT)(mask), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line))
|
#define UNITY_TEST_ASSERT_BITS(mask, expected, actual, line, message) UnityAssertBits((UNITY_INT)(mask), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line))
|
||||||
|
|
||||||
|
|
||||||
|
#define UNITY_TEST_ASSERT_GREATER_THAN_INT(threshold, actual, line, message) UnityAssertGreaterNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT)
|
||||||
|
#define UNITY_TEST_ASSERT_GREATER_THAN_INT8(threshold, actual, line, message) UnityAssertGreaterNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8)
|
||||||
|
#define UNITY_TEST_ASSERT_GREATER_THAN_INT16(threshold, actual, line, message) UnityAssertGreaterNumber((UNITY_INT)(UNITY_INT16)(threshold), (UNITY_INT)(UNITY_INT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16)
|
||||||
|
#define UNITY_TEST_ASSERT_GREATER_THAN_INT32(threshold, actual, line, message) UnityAssertGreaterNumber((UNITY_INT)(UNITY_INT32)(threshold), (UNITY_INT)(UNITY_INT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32)
|
||||||
|
#define UNITY_TEST_ASSERT_GREATER_THAN_UINT(threshold, actual, line, message) UnityAssertGreaterNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT)
|
||||||
|
#define UNITY_TEST_ASSERT_GREATER_THAN_UINT8(threshold, actual, line, message) UnityAssertGreaterNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8)
|
||||||
|
#define UNITY_TEST_ASSERT_GREATER_THAN_UINT16(threshold, actual, line, message) UnityAssertGreaterNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16)
|
||||||
|
#define UNITY_TEST_ASSERT_GREATER_THAN_UINT32(threshold, actual, line, message) UnityAssertGreaterNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32)
|
||||||
|
#define UNITY_TEST_ASSERT_GREATER_THAN_HEX8(threshold, actual, line, message) UnityAssertGreaterNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8)
|
||||||
|
#define UNITY_TEST_ASSERT_GREATER_THAN_HEX16(threshold, actual, line, message) UnityAssertGreaterNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16)
|
||||||
|
#define UNITY_TEST_ASSERT_GREATER_THAN_HEX32(threshold, actual, line, message) UnityAssertGreaterNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32)
|
||||||
|
|
||||||
|
|
||||||
|
#define UNITY_TEST_ASSERT_SMALLER_THAN_INT(threshold, actual, line, message) UnityAssertSmallerNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT)
|
||||||
|
#define UNITY_TEST_ASSERT_SMALLER_THAN_INT8(threshold, actual, line, message) UnityAssertSmallerNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8)
|
||||||
|
#define UNITY_TEST_ASSERT_SMALLER_THAN_INT16(threshold, actual, line, message) UnityAssertSmallerNumber((UNITY_INT)(UNITY_INT16)(threshold), (UNITY_INT)(UNITY_INT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16)
|
||||||
|
#define UNITY_TEST_ASSERT_SMALLER_THAN_INT32(threshold, actual, line, message) UnityAssertSmallerNumber((UNITY_INT)(UNITY_INT32)(threshold), (UNITY_INT)(UNITY_INT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32)
|
||||||
|
#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT(threshold, actual, line, message) UnityAssertSmallerNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT)
|
||||||
|
#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT8(threshold, actual, line, message) UnityAssertSmallerNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8)
|
||||||
|
#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT16(threshold, actual, line, message) UnityAssertSmallerNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16)
|
||||||
|
#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT32(threshold, actual, line, message) UnityAssertSmallerNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32)
|
||||||
|
#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX8(threshold, actual, line, message) UnityAssertSmallerNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8)
|
||||||
|
#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX16(threshold, actual, line, message) UnityAssertSmallerNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16)
|
||||||
|
#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX32(threshold, actual, line, message) UnityAssertSmallerNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32)
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
#define UNITY_TEST_ASSERT_INT_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((delta), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT)
|
#define UNITY_TEST_ASSERT_INT_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((delta), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT)
|
||||||
#define UNITY_TEST_ASSERT_INT8_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT8 )(delta), (UNITY_INT)(UNITY_INT8 )(expected), (UNITY_INT)(UNITY_INT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8)
|
#define UNITY_TEST_ASSERT_INT8_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT8 )(delta), (UNITY_INT)(UNITY_INT8 )(expected), (UNITY_INT)(UNITY_INT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8)
|
||||||
#define UNITY_TEST_ASSERT_INT16_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT16)(delta), (UNITY_INT)(UNITY_INT16)(expected), (UNITY_INT)(UNITY_INT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16)
|
#define UNITY_TEST_ASSERT_INT16_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT16)(delta), (UNITY_INT)(UNITY_INT16)(expected), (UNITY_INT)(UNITY_INT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16)
|
||||||
|
|
|
@ -14,6 +14,7 @@ CFLAGS += -Wbad-function-cast -Wcast-qual -Wold-style-definition -Wshadow -Wstri
|
||||||
#DEBUG = -O0 -g
|
#DEBUG = -O0 -g
|
||||||
CFLAGS += $(DEBUG)
|
CFLAGS += $(DEBUG)
|
||||||
DEFINES = -D UNITY_OUTPUT_CHAR=putcharSpy
|
DEFINES = -D UNITY_OUTPUT_CHAR=putcharSpy
|
||||||
|
DEFINES += -D UNITY_OUTPUT_CHAR_HEADER_DECLARATION=putcharSpy\(int\)
|
||||||
DEFINES += -D UNITY_SUPPORT_64 -D UNITY_INCLUDE_DOUBLE
|
DEFINES += -D UNITY_SUPPORT_64 -D UNITY_INCLUDE_DOUBLE
|
||||||
SRC = ../src/unity.c tests/testunity.c build/testunityRunner.c
|
SRC = ../src/unity.c tests/testunity.c build/testunityRunner.c
|
||||||
INC_DIR = -I ../src
|
INC_DIR = -I ../src
|
||||||
|
|
|
@ -91,7 +91,7 @@ module RakefileHelpers
|
||||||
defines = if $cfg['compiler']['defines']['items'].nil?
|
defines = if $cfg['compiler']['defines']['items'].nil?
|
||||||
''
|
''
|
||||||
else
|
else
|
||||||
squash($cfg['compiler']['defines']['prefix'], $cfg['compiler']['defines']['items'] + ['UNITY_OUTPUT_CHAR=putcharSpy'] + inject_defines)
|
squash($cfg['compiler']['defines']['prefix'], $cfg['compiler']['defines']['items'] + ['UNITY_OUTPUT_CHAR=putcharSpy'] + ['UNITY_OUTPUT_CHAR_HEADER_DECLARATION=putcharSpy\(int\)'] + inject_defines)
|
||||||
end
|
end
|
||||||
options = squash('', $cfg['compiler']['options'])
|
options = squash('', $cfg['compiler']['options'])
|
||||||
includes = squash($cfg['compiler']['includes']['prefix'], $cfg['compiler']['includes']['items'])
|
includes = squash($cfg['compiler']['includes']['prefix'], $cfg['compiler']['includes']['items'])
|
||||||
|
|
|
@ -764,8 +764,9 @@ void testNotEqualBitsLow(void)
|
||||||
EXPECT_ABORT_BEGIN
|
EXPECT_ABORT_BEGIN
|
||||||
TEST_ASSERT_BITS_LOW(v0, v1);
|
TEST_ASSERT_BITS_LOW(v0, v1);
|
||||||
VERIFY_FAILS_END
|
VERIFY_FAILS_END
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
void testEqualShorts(void)
|
void testEqualShorts(void)
|
||||||
{
|
{
|
||||||
short v0, v1;
|
short v0, v1;
|
||||||
|
@ -1305,6 +1306,415 @@ void testINT8sNotWithinDeltaAndCustomMessage(void)
|
||||||
VERIFY_FAILS_END
|
VERIFY_FAILS_END
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
//-----------------
|
||||||
|
void testGreaterThan(void)
|
||||||
|
{
|
||||||
|
UNITY_INT v0, v1;
|
||||||
|
UNITY_INT *p0, *p1;
|
||||||
|
|
||||||
|
v0 = 0;
|
||||||
|
v1 = 1;
|
||||||
|
p0 = &v0;
|
||||||
|
p1 = &v1;
|
||||||
|
|
||||||
|
TEST_ASSERT_GREATER_THAN(v0, v1);
|
||||||
|
TEST_ASSERT_GREATER_THAN(*p0, v1);
|
||||||
|
TEST_ASSERT_GREATER_THAN(v0, *p1);
|
||||||
|
TEST_ASSERT_GREATER_THAN(*p0, *p1);
|
||||||
|
}
|
||||||
|
|
||||||
|
void testGreaterThanINT(void)
|
||||||
|
{
|
||||||
|
UNITY_INT v0, v1;
|
||||||
|
UNITY_INT *p0, *p1;
|
||||||
|
|
||||||
|
v0 = 302;
|
||||||
|
v1 = 3334;
|
||||||
|
p0 = &v0;
|
||||||
|
p1 = &v1;
|
||||||
|
|
||||||
|
TEST_ASSERT_GREATER_THAN_INT(v0, v1);
|
||||||
|
TEST_ASSERT_GREATER_THAN_INT(*p0, v1);
|
||||||
|
TEST_ASSERT_GREATER_THAN_INT(v0, *p1);
|
||||||
|
TEST_ASSERT_GREATER_THAN_INT(*p0, *p1);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void testGreaterThanINT8(void)
|
||||||
|
{
|
||||||
|
UNITY_INT8 v0, v1;
|
||||||
|
UNITY_INT8 *p0, *p1;
|
||||||
|
|
||||||
|
v0 = -128;
|
||||||
|
v1 = 127;
|
||||||
|
p0 = &v0;
|
||||||
|
p1 = &v1;
|
||||||
|
|
||||||
|
TEST_ASSERT_GREATER_THAN_INT8(v0, v1);
|
||||||
|
TEST_ASSERT_GREATER_THAN_INT8(*p0, v1);
|
||||||
|
TEST_ASSERT_GREATER_THAN_INT8(v0, *p1);
|
||||||
|
TEST_ASSERT_GREATER_THAN_INT8(*p0, *p1);
|
||||||
|
}
|
||||||
|
|
||||||
|
void testGreaterThanINT16(void)
|
||||||
|
{
|
||||||
|
UNITY_INT16 v0, v1;
|
||||||
|
UNITY_INT16 *p0, *p1;
|
||||||
|
|
||||||
|
v0 = -32768;
|
||||||
|
v1 = 32767;
|
||||||
|
p0 = &v0;
|
||||||
|
p1 = &v1;
|
||||||
|
|
||||||
|
TEST_ASSERT_GREATER_THAN_INT16(v0, v1);
|
||||||
|
TEST_ASSERT_GREATER_THAN_INT16(*p0, v1);
|
||||||
|
TEST_ASSERT_GREATER_THAN_INT16(v0, *p1);
|
||||||
|
TEST_ASSERT_GREATER_THAN_INT16(*p0, *p1);
|
||||||
|
}
|
||||||
|
|
||||||
|
void testGreaterThanINT32(void)
|
||||||
|
{
|
||||||
|
UNITY_INT32 v0, v1;
|
||||||
|
UNITY_INT32 *p0, *p1;
|
||||||
|
|
||||||
|
v0 = -214783648;
|
||||||
|
v1 = 214783647;
|
||||||
|
p0 = &v0;
|
||||||
|
p1 = &v1;
|
||||||
|
|
||||||
|
TEST_ASSERT_GREATER_THAN_INT32(v0, v1);
|
||||||
|
TEST_ASSERT_GREATER_THAN_INT32(*p0, v1);
|
||||||
|
TEST_ASSERT_GREATER_THAN_INT32(v0, *p1);
|
||||||
|
TEST_ASSERT_GREATER_THAN_INT32(*p0, *p1);
|
||||||
|
}
|
||||||
|
|
||||||
|
void testGreaterThanUINT(void)
|
||||||
|
{
|
||||||
|
UNITY_UINT v0, v1;
|
||||||
|
UNITY_UINT *p0, *p1;
|
||||||
|
|
||||||
|
v0 = 0;
|
||||||
|
v1 = 1;
|
||||||
|
p0 = &v0;
|
||||||
|
p1 = &v1;
|
||||||
|
|
||||||
|
TEST_ASSERT_GREATER_THAN_UINT(v0, v1);
|
||||||
|
TEST_ASSERT_GREATER_THAN_UINT(*p0, v1);
|
||||||
|
TEST_ASSERT_GREATER_THAN_UINT(v0, *p1);
|
||||||
|
TEST_ASSERT_GREATER_THAN_UINT(*p0, *p1);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void testGreaterThanUINT8(void)
|
||||||
|
{
|
||||||
|
UNITY_UINT8 v0, v1;
|
||||||
|
UNITY_UINT8 *p0, *p1;
|
||||||
|
|
||||||
|
v0 = 0;
|
||||||
|
v1 = 255;
|
||||||
|
p0 = &v0;
|
||||||
|
p1 = &v1;
|
||||||
|
|
||||||
|
TEST_ASSERT_GREATER_THAN_UINT8(v0, v1);
|
||||||
|
TEST_ASSERT_GREATER_THAN_UINT8(*p0, v1);
|
||||||
|
TEST_ASSERT_GREATER_THAN_UINT8(v0, *p1);
|
||||||
|
TEST_ASSERT_GREATER_THAN_UINT8(*p0, *p1);
|
||||||
|
}
|
||||||
|
|
||||||
|
void testGreaterThanUINT16(void)
|
||||||
|
{
|
||||||
|
UNITY_UINT16 v0, v1;
|
||||||
|
UNITY_UINT16 *p0, *p1;
|
||||||
|
|
||||||
|
v0 = 0;
|
||||||
|
v1 = 65535;
|
||||||
|
p0 = &v0;
|
||||||
|
p1 = &v1;
|
||||||
|
|
||||||
|
TEST_ASSERT_GREATER_THAN_UINT16(v0, v1);
|
||||||
|
TEST_ASSERT_GREATER_THAN_UINT16(*p0, v1);
|
||||||
|
TEST_ASSERT_GREATER_THAN_UINT16(v0, *p1);
|
||||||
|
TEST_ASSERT_GREATER_THAN_UINT16(*p0, *p1);
|
||||||
|
}
|
||||||
|
|
||||||
|
void testGreaterThanUINT32(void)
|
||||||
|
{
|
||||||
|
UNITY_UINT32 v0, v1;
|
||||||
|
UNITY_UINT32 *p0, *p1;
|
||||||
|
|
||||||
|
v0 = 0;
|
||||||
|
v1 = 4294967295;
|
||||||
|
p0 = &v0;
|
||||||
|
p1 = &v1;
|
||||||
|
|
||||||
|
TEST_ASSERT_GREATER_THAN_UINT32(v0, v1);
|
||||||
|
TEST_ASSERT_GREATER_THAN_UINT32(*p0, v1);
|
||||||
|
TEST_ASSERT_GREATER_THAN_UINT32(v0, *p1);
|
||||||
|
TEST_ASSERT_GREATER_THAN_UINT32(*p0, *p1);
|
||||||
|
}
|
||||||
|
|
||||||
|
void testGreaterThanHEX8(void)
|
||||||
|
{
|
||||||
|
UNITY_UINT8 v0, v1;
|
||||||
|
UNITY_UINT8 *p0, *p1;
|
||||||
|
|
||||||
|
v0 = 0x00;
|
||||||
|
v1 = 0xFF;
|
||||||
|
p0 = &v0;
|
||||||
|
p1 = &v1;
|
||||||
|
|
||||||
|
TEST_ASSERT_GREATER_THAN_HEX8(v0, v1);
|
||||||
|
TEST_ASSERT_GREATER_THAN_HEX8(*p0, v1);
|
||||||
|
TEST_ASSERT_GREATER_THAN_HEX8(v0, *p1);
|
||||||
|
TEST_ASSERT_GREATER_THAN_HEX8(*p0, *p1);
|
||||||
|
}
|
||||||
|
|
||||||
|
void testGreaterThanHEX16(void)
|
||||||
|
{
|
||||||
|
UNITY_UINT16 v0, v1;
|
||||||
|
UNITY_UINT16 *p0, *p1;
|
||||||
|
|
||||||
|
v0 = 0x0000;
|
||||||
|
v1 = 0xFFFF;
|
||||||
|
p0 = &v0;
|
||||||
|
p1 = &v1;
|
||||||
|
|
||||||
|
TEST_ASSERT_GREATER_THAN_HEX16(v0, v1);
|
||||||
|
TEST_ASSERT_GREATER_THAN_HEX16(*p0, v1);
|
||||||
|
TEST_ASSERT_GREATER_THAN_HEX16(v0, *p1);
|
||||||
|
TEST_ASSERT_GREATER_THAN_HEX16(*p0, *p1);
|
||||||
|
}
|
||||||
|
|
||||||
|
void testGreaterThanHEX32(void)
|
||||||
|
{
|
||||||
|
UNITY_UINT32 v0, v1;
|
||||||
|
UNITY_UINT32 *p0, *p1;
|
||||||
|
|
||||||
|
v0 = 0x00000000;
|
||||||
|
v1 = 0xFFFFFFFF;
|
||||||
|
p0 = &v0;
|
||||||
|
p1 = &v1;
|
||||||
|
|
||||||
|
TEST_ASSERT_GREATER_THAN_HEX32(v0, v1);
|
||||||
|
TEST_ASSERT_GREATER_THAN_HEX32(*p0, v1);
|
||||||
|
TEST_ASSERT_GREATER_THAN_HEX32(v0, *p1);
|
||||||
|
TEST_ASSERT_GREATER_THAN_HEX32(*p0, *p1);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void testNotGreaterThan(void)
|
||||||
|
{
|
||||||
|
EXPECT_ABORT_BEGIN
|
||||||
|
TEST_ASSERT_GREATER_THAN(0, -1);
|
||||||
|
VERIFY_FAILS_END
|
||||||
|
}
|
||||||
|
|
||||||
|
void testLessThan(void)
|
||||||
|
{
|
||||||
|
UNITY_INT v0, v1;
|
||||||
|
UNITY_INT *p0, *p1;
|
||||||
|
|
||||||
|
v0 = 0;
|
||||||
|
v1 = -1;
|
||||||
|
p0 = &v0;
|
||||||
|
p1 = &v1;
|
||||||
|
|
||||||
|
TEST_ASSERT_LESS_THAN(v0, v1);
|
||||||
|
TEST_ASSERT_LESS_THAN(*p0, v1);
|
||||||
|
TEST_ASSERT_LESS_THAN(v0, *p1);
|
||||||
|
TEST_ASSERT_LESS_THAN(*p0, *p1);
|
||||||
|
}
|
||||||
|
|
||||||
|
void testLessThanINT(void)
|
||||||
|
{
|
||||||
|
UNITY_INT v0, v1;
|
||||||
|
UNITY_INT *p0, *p1;
|
||||||
|
|
||||||
|
v0 = 3334;
|
||||||
|
v1 = 302;
|
||||||
|
p0 = &v0;
|
||||||
|
p1 = &v1;
|
||||||
|
|
||||||
|
TEST_ASSERT_LESS_THAN_INT(v0, v1);
|
||||||
|
TEST_ASSERT_LESS_THAN_INT(*p0, v1);
|
||||||
|
TEST_ASSERT_LESS_THAN_INT(v0, *p1);
|
||||||
|
TEST_ASSERT_LESS_THAN_INT(*p0, *p1);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void testLessThanINT8(void)
|
||||||
|
{
|
||||||
|
UNITY_INT8 v0, v1;
|
||||||
|
UNITY_INT8 *p0, *p1;
|
||||||
|
|
||||||
|
v0 = 127;
|
||||||
|
v1 = -128;
|
||||||
|
p0 = &v0;
|
||||||
|
p1 = &v1;
|
||||||
|
|
||||||
|
TEST_ASSERT_LESS_THAN_INT8(v0, v1);
|
||||||
|
TEST_ASSERT_LESS_THAN_INT8(*p0, v1);
|
||||||
|
TEST_ASSERT_LESS_THAN_INT8(v0, *p1);
|
||||||
|
TEST_ASSERT_LESS_THAN_INT8(*p0, *p1);
|
||||||
|
}
|
||||||
|
|
||||||
|
void testLessThanINT16(void)
|
||||||
|
{
|
||||||
|
UNITY_INT16 v0, v1;
|
||||||
|
UNITY_INT16 *p0, *p1;
|
||||||
|
|
||||||
|
v0 = 32767;
|
||||||
|
v1 = -32768;
|
||||||
|
p0 = &v0;
|
||||||
|
p1 = &v1;
|
||||||
|
|
||||||
|
TEST_ASSERT_LESS_THAN_INT16(v0, v1);
|
||||||
|
TEST_ASSERT_LESS_THAN_INT16(*p0, v1);
|
||||||
|
TEST_ASSERT_LESS_THAN_INT16(v0, *p1);
|
||||||
|
TEST_ASSERT_LESS_THAN_INT16(*p0, *p1);
|
||||||
|
}
|
||||||
|
|
||||||
|
void testLessThanINT32(void)
|
||||||
|
{
|
||||||
|
UNITY_INT32 v0, v1;
|
||||||
|
UNITY_INT32 *p0, *p1;
|
||||||
|
|
||||||
|
v0 = 214783647;
|
||||||
|
v1 = -214783648;
|
||||||
|
p0 = &v0;
|
||||||
|
p1 = &v1;
|
||||||
|
|
||||||
|
TEST_ASSERT_LESS_THAN_INT32(v0, v1);
|
||||||
|
TEST_ASSERT_LESS_THAN_INT32(*p0, v1);
|
||||||
|
TEST_ASSERT_LESS_THAN_INT32(v0, *p1);
|
||||||
|
TEST_ASSERT_LESS_THAN_INT32(*p0, *p1);
|
||||||
|
}
|
||||||
|
|
||||||
|
void testLessThanUINT(void)
|
||||||
|
{
|
||||||
|
UNITY_UINT v0, v1;
|
||||||
|
UNITY_UINT *p0, *p1;
|
||||||
|
|
||||||
|
v0 = 1;
|
||||||
|
v1 = 0;
|
||||||
|
p0 = &v0;
|
||||||
|
p1 = &v1;
|
||||||
|
|
||||||
|
TEST_ASSERT_LESS_THAN_UINT(v0, v1);
|
||||||
|
TEST_ASSERT_LESS_THAN_UINT(*p0, v1);
|
||||||
|
TEST_ASSERT_LESS_THAN_UINT(v0, *p1);
|
||||||
|
TEST_ASSERT_LESS_THAN_UINT(*p0, *p1);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void testLessThanUINT8(void)
|
||||||
|
{
|
||||||
|
UNITY_UINT8 v0, v1;
|
||||||
|
UNITY_UINT8 *p0, *p1;
|
||||||
|
|
||||||
|
v0 = 255;
|
||||||
|
v1 = 0;
|
||||||
|
p0 = &v0;
|
||||||
|
p1 = &v1;
|
||||||
|
|
||||||
|
TEST_ASSERT_LESS_THAN_UINT8(v0, v1);
|
||||||
|
TEST_ASSERT_LESS_THAN_UINT8(*p0, v1);
|
||||||
|
TEST_ASSERT_LESS_THAN_UINT8(v0, *p1);
|
||||||
|
TEST_ASSERT_LESS_THAN_UINT8(*p0, *p1);
|
||||||
|
}
|
||||||
|
|
||||||
|
void testLessThanUINT16(void)
|
||||||
|
{
|
||||||
|
UNITY_UINT16 v0, v1;
|
||||||
|
UNITY_UINT16 *p0, *p1;
|
||||||
|
|
||||||
|
v0 = 65535;
|
||||||
|
v1 = 0;
|
||||||
|
p0 = &v0;
|
||||||
|
p1 = &v1;
|
||||||
|
|
||||||
|
TEST_ASSERT_LESS_THAN_UINT16(v0, v1);
|
||||||
|
TEST_ASSERT_LESS_THAN_UINT16(*p0, v1);
|
||||||
|
TEST_ASSERT_LESS_THAN_UINT16(v0, *p1);
|
||||||
|
TEST_ASSERT_LESS_THAN_UINT16(*p0, *p1);
|
||||||
|
}
|
||||||
|
|
||||||
|
void testLessThanUINT32(void)
|
||||||
|
{
|
||||||
|
UNITY_UINT32 v0, v1;
|
||||||
|
UNITY_UINT32 *p0, *p1;
|
||||||
|
|
||||||
|
v0 = 4294967295;
|
||||||
|
v1 = 0;
|
||||||
|
p0 = &v0;
|
||||||
|
p1 = &v1;
|
||||||
|
|
||||||
|
TEST_ASSERT_LESS_THAN_UINT32(v0, v1);
|
||||||
|
TEST_ASSERT_LESS_THAN_UINT32(*p0, v1);
|
||||||
|
TEST_ASSERT_LESS_THAN_UINT32(v0, *p1);
|
||||||
|
TEST_ASSERT_LESS_THAN_UINT32(*p0, *p1);
|
||||||
|
}
|
||||||
|
|
||||||
|
void testLessThanHEX8(void)
|
||||||
|
{
|
||||||
|
UNITY_UINT8 v0, v1;
|
||||||
|
UNITY_UINT8 *p0, *p1;
|
||||||
|
|
||||||
|
v0 = 0xFF;
|
||||||
|
v1 = 0x00;
|
||||||
|
p0 = &v0;
|
||||||
|
p1 = &v1;
|
||||||
|
|
||||||
|
TEST_ASSERT_LESS_THAN_HEX8(v0, v1);
|
||||||
|
TEST_ASSERT_LESS_THAN_HEX8(*p0, v1);
|
||||||
|
TEST_ASSERT_LESS_THAN_HEX8(v0, *p1);
|
||||||
|
TEST_ASSERT_LESS_THAN_HEX8(*p0, *p1);
|
||||||
|
}
|
||||||
|
|
||||||
|
void testLessThanHEX16(void)
|
||||||
|
{
|
||||||
|
UNITY_UINT16 v0, v1;
|
||||||
|
UNITY_UINT16 *p0, *p1;
|
||||||
|
|
||||||
|
v0 = 0xFFFF;
|
||||||
|
v1 = 0x0000;
|
||||||
|
p0 = &v0;
|
||||||
|
p1 = &v1;
|
||||||
|
|
||||||
|
TEST_ASSERT_LESS_THAN_HEX16(v0, v1);
|
||||||
|
TEST_ASSERT_LESS_THAN_HEX16(*p0, v1);
|
||||||
|
TEST_ASSERT_LESS_THAN_HEX16(v0, *p1);
|
||||||
|
TEST_ASSERT_LESS_THAN_HEX16(*p0, *p1);
|
||||||
|
}
|
||||||
|
|
||||||
|
void testLessThanHEX32(void)
|
||||||
|
{
|
||||||
|
UNITY_UINT32 v0, v1;
|
||||||
|
UNITY_UINT32 *p0, *p1;
|
||||||
|
|
||||||
|
v0 = 0xFFFFFFFF;
|
||||||
|
v1 = 0x00000000;
|
||||||
|
p0 = &v0;
|
||||||
|
p1 = &v1;
|
||||||
|
|
||||||
|
TEST_ASSERT_LESS_THAN_HEX32(v0, v1);
|
||||||
|
TEST_ASSERT_LESS_THAN_HEX32(*p0, v1);
|
||||||
|
TEST_ASSERT_LESS_THAN_HEX32(v0, *p1);
|
||||||
|
TEST_ASSERT_LESS_THAN_HEX32(*p0, *p1);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void testNotLessThan(void)
|
||||||
|
{
|
||||||
|
EXPECT_ABORT_BEGIN
|
||||||
|
TEST_ASSERT_LESS_THAN(0, 1);
|
||||||
|
VERIFY_FAILS_END
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
//-----------------
|
||||||
void testEqualStrings(void)
|
void testEqualStrings(void)
|
||||||
{
|
{
|
||||||
const char *testString = "foo";
|
const char *testString = "foo";
|
||||||
|
@ -4056,61 +4466,46 @@ void testFloatPrinting(void)
|
||||||
#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || !defined(USING_OUTPUT_SPY)
|
#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || !defined(USING_OUTPUT_SPY)
|
||||||
TEST_IGNORE();
|
TEST_IGNORE();
|
||||||
#else
|
#else
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("0.0", 0.0f);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("0", 0.0f);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("0.000000...", 0.000000499f);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("4.99e-07", 0.000000499f);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("0.000001", 0.00000050000005f);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("5e-07", 0.00000050000005f);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("0.100469", 0.100469499f);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("0.100469", 0.100469499f);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.0", 0.9999995f); /*Rounding to int place*/
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("1", 0.9999995f); /*Rounding to int place*/
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.0", 1.0f);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("1", 1.0f);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.25", 1.25f);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.25", 1.25f);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("7.999999", 7.999999f); /*Not rounding*/
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("7.99999", 7.99999f); /*Not rounding*/
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("16.000002", 16.000002f);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("16.0002", 16.0002f);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("16.000004", 16.000004f);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("16.0004", 16.0004f);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("16.000006", 16.000006f);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("16.0006", 16.0006f);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("4294967040.0", 4294967040.0f); /*Last full print integer*/
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("999999", 999999.0f); /*Last full print integer*/
|
||||||
|
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("0.0", -0.0f);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("-0", -0.0f);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.000000...",-0.000000499f);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.99e-07", -0.000000499f);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.000001", -0.00000050000005f);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("-5e-07", -0.00000050000005f);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.100469", -0.100469499f);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.100469", -0.100469499f);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-1.0", -0.9999995f); /*Rounding to int place*/
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("-1", -0.9999995f); /*Rounding to int place*/
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-1.0", -1.0f);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("-1", -1.0f);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-1.25", -1.25f);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("-1.25", -1.25f);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-7.999999", -7.999999f); /*Not rounding*/
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("-7.99999", -7.99999f); /*Not rounding*/
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.000002", -16.000002f);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.0002", -16.0002f);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.000004", -16.000004f);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.0004", -16.0004f);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.000006", -16.000006f);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.0006", -16.0006f);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-4294967040.0",-4294967040.0f); /*Last full print integer*/
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("-999999", -999999.0f); /*Last full print integer*/
|
||||||
|
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("4.2949673e+09", 4294967296.0f);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("4.29497e+09", 4294967296.0f);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("5.0e+09", 5000000000.0f);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("5e+09", 5000000000.0f);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("8.0e+09", 8.0e+09f);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("8e+09", 8.0e+09f);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("8.3099991e+09", 8309999104.0f);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("8.31e+09", 8309999104.0f);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.0e+10", 1.0e+10f);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("1e+10", 1.0e+10f);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.0e+10", 10000000000.0f);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("1e+10", 10000000000.0f);
|
||||||
/* Some compilers have trouble with inexact float constants, a float cast works generally */
|
/* Some compilers have trouble with inexact float constants, a float cast works generally */
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.00005499e+10", (float)1.000055e+10f);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.00005e+10", (float)1.000054e+10f);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.10000006e+38", (float)1.10000005e+38f);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.1e+38", (float)1.10000005e+38f);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.63529943e+10", 1.63529943e+10f);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.6353e+10", 1.63529943e+10f);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("3.40282347e+38", 3.40282346638e38f);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("3.40282e+38", 3.40282346638e38f);
|
||||||
|
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-1.0e+10", -1.0e+10f);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("-1e+10", -1.0e+10f);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-3.40282347e+38",-3.40282346638e38f);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("-3.40282e+38", -3.40282346638e38f);
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
void testFloatPrintingRoundTiesToEven(void)
|
|
||||||
{
|
|
||||||
#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || !defined(USING_OUTPUT_SPY)
|
|
||||||
TEST_IGNORE();
|
|
||||||
#else
|
|
||||||
#ifdef UNITY_ROUND_TIES_AWAY_FROM_ZERO
|
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("0.007813", 0.0078125f);
|
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("0.976563", 0.9765625f);
|
|
||||||
#else /* Default to Round ties to even */
|
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("0.007182", 0.0071825f);
|
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("0.976562", 0.9765625f);
|
|
||||||
#endif
|
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -4119,105 +4514,69 @@ void testFloatPrintingInfinityAndNaN(void)
|
||||||
#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || !defined(USING_OUTPUT_SPY)
|
#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || !defined(USING_OUTPUT_SPY)
|
||||||
TEST_IGNORE();
|
TEST_IGNORE();
|
||||||
#else
|
#else
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("Inf", 1.0f / f_zero);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("inf", 1.0f / f_zero);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-Inf", -1.0f / f_zero);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("-inf", -1.0f / f_zero);
|
||||||
|
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("NaN", 0.0f / f_zero);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("nan", 0.0f / f_zero);
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
#if defined(UNITY_TEST_ALL_FLOATS_PRINT_OK) && defined(USING_OUTPUT_SPY)
|
#if defined(UNITY_TEST_ALL_FLOATS_PRINT_OK) && defined(USING_OUTPUT_SPY)
|
||||||
static void AllFloatPrinting_LessThan32Bits(void)
|
static void printFloatValue(float f)
|
||||||
{
|
{
|
||||||
char expected[18];
|
char expected[18];
|
||||||
union { float f_value; int32_t int_value; } u;
|
char expected_lower[18];
|
||||||
/* Float representations are laid out in integer order, walk up the list */
|
char expected_higher[18];
|
||||||
for (u.f_value = 0.00000050000005f; u.f_value <= 4294967040.0f; u.int_value += 1)
|
|
||||||
|
startPutcharSpy();
|
||||||
|
|
||||||
|
UnityPrintFloat(f);
|
||||||
|
|
||||||
|
sprintf(expected, "%.6g", f);
|
||||||
|
|
||||||
|
/* We print all NaN's as "nan", not "-nan" */
|
||||||
|
if(strcmp(expected, "-nan") == 0) strcpy(expected, "nan");
|
||||||
|
|
||||||
|
/* Allow for rounding differences in last digit */
|
||||||
|
double lower = (double)f * 0.9999995;
|
||||||
|
double higher = (double)f * 1.0000005;
|
||||||
|
|
||||||
|
if (isfinite(lower)) sprintf(expected_lower, "%.6g", lower); else strcpy(expected_lower, expected);
|
||||||
|
if (isfinite(higher)) sprintf(expected_higher, "%.6g", higher); else strcpy(expected_higher, expected);
|
||||||
|
|
||||||
|
if (strcmp(expected, getBufferPutcharSpy()) != 0 &&
|
||||||
|
strcmp(expected_lower, getBufferPutcharSpy()) != 0 &&
|
||||||
|
strcmp(expected_higher, getBufferPutcharSpy()) != 0)
|
||||||
{
|
{
|
||||||
startPutcharSpy();
|
/* Fail with diagnostic printing */
|
||||||
|
TEST_ASSERT_EQUAL_PRINT_FLOATING(expected, f);
|
||||||
UnityPrintFloat(u.f_value); /*1.5x as fast as sprintf 5e-7f - 0.01f, 20s vs 30s*/
|
|
||||||
int len = sprintf(expected, "%.6f", u.f_value);
|
|
||||||
|
|
||||||
while (expected[len - 1] == '0' && expected[len - 2] != '.') { len--; }
|
|
||||||
expected[len] = '\0'; /* delete trailing 0's */
|
|
||||||
|
|
||||||
if (strcmp(expected, getBufferPutcharSpy()) != 0)
|
|
||||||
{
|
|
||||||
double six_digits = ((double)u.f_value - (uint32_t)u.f_value)*1000000.0;
|
|
||||||
/* Not a tie (remainder != 0.5) => Can't explain the different strings */
|
|
||||||
if (six_digits - (uint32_t)six_digits != 0.5)
|
|
||||||
{
|
|
||||||
/* Fail with diagnostic printing */
|
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING(expected, u.f_value);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Compared to perfect, floats are occasionally rounded wrong. It doesn't affect
|
|
||||||
* correctness, though. Two examples (of 13 total found during testing):
|
|
||||||
* Printed: 6.19256349e+20, Exact: 619256348499999981568.0f <= Eliminated by ROUND_TIES_TO_EVEN
|
|
||||||
* Printed: 2.19012272e+35, Exact: 219012271499999993621766990196637696.0f */
|
|
||||||
static void AllFloatPrinting_Larger(const float start, const float end)
|
|
||||||
{
|
|
||||||
unsigned int wrong = 0;
|
|
||||||
char expected[18];
|
|
||||||
union { float f_value; int32_t int_value; } u;
|
|
||||||
for (u.f_value = start; u.f_value <= end; u.int_value += 1)
|
|
||||||
{
|
|
||||||
startPutcharSpy();
|
|
||||||
|
|
||||||
UnityPrintFloat(u.f_value); /*Twice as fast as sprintf 2**32-1e12, 10s vs 21s*/
|
|
||||||
sprintf(expected, "%.8e", u.f_value);
|
|
||||||
|
|
||||||
int len = 11 - 1; /* 11th char is 'e' in exponential format */
|
|
||||||
while (expected[len - 1] == '0' && expected[len - 2] != '.') { len --; }
|
|
||||||
if (expected[14] != '\0') memmove(&expected[12], &expected[13], 3); /* Two char exponent */
|
|
||||||
memmove(&expected[len], &expected[11 - 1], sizeof "e+09"); /* 5 char length */
|
|
||||||
|
|
||||||
if (strcmp(expected, getBufferPutcharSpy()) != 0)
|
|
||||||
{
|
|
||||||
wrong++;
|
|
||||||
/* endPutcharSpy(); UnityPrint("Expected "); UnityPrint(expected);
|
|
||||||
UnityPrint(" Was "); UnityPrint(getBufferPutcharSpy()); UNITY_OUTPUT_CHAR('\n'); */
|
|
||||||
|
|
||||||
if (wrong > 10 || (wrong > 3 && end <= 1e25f))
|
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING(expected, u.f_value);
|
|
||||||
/* Empirical values from the current routine, don't be worse when making changes */
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
/* Exhaustive testing of all float values we differentiate when printing. Doubles
|
void testFloatPrintingRandomSamples(void)
|
||||||
* are not explored here -- too many. These tests confirm that the routine works
|
|
||||||
* for all floats > 5e-7, positives only. Off by default due to test time.
|
|
||||||
* Compares Unity's routine to your sprintf() C lib, tested to pass on 3 platforms.
|
|
||||||
* Part1 takes a long time, around 3 minutes compiled with -O2
|
|
||||||
* Runs through all floats from 0.000001 - 2**32, ~300 million values */
|
|
||||||
void testAllFloatPrintingPart1_LessThan32Bits(void)
|
|
||||||
{
|
{
|
||||||
#if defined(UNITY_TEST_ALL_FLOATS_PRINT_OK) && defined(USING_OUTPUT_SPY)
|
#if !defined(UNITY_TEST_ALL_FLOATS_PRINT_OK) || !defined(USING_OUTPUT_SPY)
|
||||||
AllFloatPrinting_LessThan32Bits();
|
TEST_IGNORE();
|
||||||
#else
|
#else
|
||||||
TEST_IGNORE(); /* Ignore one of three */
|
union { float f_value; uint32_t int_value; } u;
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Test takes a long time, around 3.5 minutes compiled with -O2, try ~500 million values */
|
/* These values are not covered by the MINSTD generator */
|
||||||
void testAllFloatPrintingPart2_Larger(void)
|
u.int_value = 0x00000000; printFloatValue(u.f_value);
|
||||||
{
|
u.int_value = 0x80000000; printFloatValue(u.f_value);
|
||||||
#if defined(UNITY_TEST_ALL_FLOATS_PRINT_OK) && defined(USING_OUTPUT_SPY)
|
u.int_value = 0x7fffffff; printFloatValue(u.f_value);
|
||||||
AllFloatPrinting_Larger(4294967296.0f, 1e25f);
|
u.int_value = 0xffffffff; printFloatValue(u.f_value);
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Test takes a long time, around 3.5 minutes compiled with -O2, try ~500 million values */
|
uint32_t a = 1;
|
||||||
void testAllFloatPrintingPart3_LargerStill(void)
|
for(int num_tested = 0; num_tested < 1000000; num_tested++)
|
||||||
{
|
{
|
||||||
#if defined(UNITY_TEST_ALL_FLOATS_PRINT_OK) && defined(USING_OUTPUT_SPY)
|
/* MINSTD pseudo-random number generator */
|
||||||
AllFloatPrinting_Larger(1e25f, 3.40282347e+38f);
|
a = (uint32_t)(((uint64_t)a * 48271u) % 2147483647u);
|
||||||
|
|
||||||
|
/* MINSTD does not set the highest bit; test both possibilities */
|
||||||
|
u.int_value = a; printFloatValue(u.f_value);
|
||||||
|
u.int_value = a | 0x80000000; printFloatValue(u.f_value);
|
||||||
|
}
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -4893,35 +5252,20 @@ void testDoublePrinting(void)
|
||||||
#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_EXCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY)
|
#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_EXCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY)
|
||||||
TEST_IGNORE();
|
TEST_IGNORE();
|
||||||
#else
|
#else
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("0.100469", 0.10046949999999999);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("0.100469", 0.10046949999999999);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("4294967295.999999", 4294967295.999999);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("4.29497e+09", 4294967295.999999);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("4.2949673e+09", 4294967295.9999995);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("4.29497e+09", 4294967295.9999995);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("4.2949673e+09", 4294967296.0);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("4.29497e+09", 4294967296.0);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.0e+10", 9999999995.0);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("1e+10", 9999999995.0);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("9.00719925e+15", 9007199254740990.0);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("9.0072e+15", 9007199254740990.0);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("7.0e+100", 7.0e+100);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("7e+100", 7.0e+100);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("3.0e+200", 3.0e+200);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("3e+200", 3.0e+200);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("9.23456789e+300", 9.23456789e+300);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("9.23457e+300", 9.23456789e+300);
|
||||||
|
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.100469", -0.10046949999999999);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.100469", -0.10046949999999999);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-4294967295.999999", -4294967295.999999);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.29497e+09", -4294967295.999999);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.2949673e+09", -4294967295.9999995);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.29497e+09", -4294967295.9999995);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-7.0e+100", -7.0e+100);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("-7e+100", -7.0e+100);
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
void testDoublePrintingRoundTiesToEven(void)
|
|
||||||
{
|
|
||||||
#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_EXCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY)
|
|
||||||
TEST_IGNORE();
|
|
||||||
#else
|
|
||||||
#ifdef UNITY_ROUND_TIES_AWAY_FROM_ZERO
|
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.00000001e+10", 10000000050.0);
|
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("9.00719925e+15", 9007199245000000.0);
|
|
||||||
#else /* Default to Round ties to even */
|
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.0e+10", 10000000050.0);
|
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("9.00719924e+15", 9007199245000000.0);
|
|
||||||
#endif
|
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -4930,10 +5274,10 @@ void testDoublePrintingInfinityAndNaN(void)
|
||||||
#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_EXCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY)
|
#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_EXCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY)
|
||||||
TEST_IGNORE();
|
TEST_IGNORE();
|
||||||
#else
|
#else
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("Inf", 1.0 / d_zero);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("inf", 1.0 / d_zero);
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-Inf", -1.0 / d_zero);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("-inf", -1.0 / d_zero);
|
||||||
|
|
||||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("NaN", 0.0 / d_zero);
|
TEST_ASSERT_EQUAL_PRINT_FLOATING("nan", 0.0 / d_zero);
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
Loading…
Reference in New Issue