From 9899cb43af9f371e0cf754994a359df8ef2beb58 Mon Sep 17 00:00:00 2001 From: Andrew Coffey Date: Thu, 5 Jun 2025 22:06:50 -0500 Subject: [PATCH 01/21] Beginnings of c unit testing with base module (with necessary changes to base, i.e. header) --- .github/workflows/build-debian-multiarch.yml | 2 +- .gitignore | 1 + .pre-commit-config.yaml | 3 + ctest/meson.build | 22 + ctest/test_base.c | 82 + dev.py | 11 + meson.build | 5 + meson_options.txt | 10 +- src_c/base.c | 147 +- src_c/base.h | 210 ++ subprojects/unity/CMakeLists.txt | 172 ++ subprojects/unity/LICENSE.txt | 21 + subprojects/unity/README.md | 234 ++ subprojects/unity/docs/CODE_OF_CONDUCT.md | 138 + subprojects/unity/docs/CONTRIBUTING.md | 238 ++ .../unity/docs/MesonGeneratorRunner.md | 18 + .../docs/ThrowTheSwitchCodingStandard.md | 187 ++ ...tSuitableforPrintingandPossiblyFraming.pdf | Bin 0 -> 144467 bytes .../unity/docs/UnityAssertionsReference.md | 860 ++++++ subprojects/unity/docs/UnityChangeLog.md | 110 + .../unity/docs/UnityConfigurationGuide.md | 654 +++++ .../unity/docs/UnityGettingStartedGuide.md | 242 ++ .../unity/docs/UnityHelperScriptsGuide.md | 533 ++++ subprojects/unity/docs/UnityKnownIssues.md | 13 + subprojects/unity/extras/bdd/readme.md | 40 + subprojects/unity/extras/bdd/src/unity_bdd.h | 44 + subprojects/unity/extras/bdd/test/meson.build | 9 + subprojects/unity/extras/bdd/test/test_bdd.c | 129 + .../unity/extras/eclipse/error_parsers.txt | 26 + subprojects/unity/extras/fixture/readme.md | 26 + .../unity/extras/fixture/src/meson.build | 10 + .../unity/extras/fixture/src/unity_fixture.c | 310 ++ .../unity/extras/fixture/src/unity_fixture.h | 94 + .../fixture/src/unity_fixture_internals.h | 50 + .../unity/extras/fixture/test/Makefile | 72 + .../unity/extras/fixture/test/main/AllTests.c | 20 + .../fixture/test/template_fixture_tests.c | 39 + .../extras/fixture/test/unity_fixture_Test.c | 245 ++ .../fixture/test/unity_fixture_TestRunner.c | 32 + subprojects/unity/extras/memory/readme.md | 42 + .../unity/extras/memory/src/meson.build | 9 + .../unity/extras/memory/src/unity_memory.c | 203 ++ .../unity/extras/memory/src/unity_memory.h | 61 + subprojects/unity/extras/memory/test/Makefile | 85 + .../extras/memory/test/unity_memory_Test.c | 326 +++ .../memory/test/unity_memory_TestRunner.c | 50 + .../extras/memory/test/unity_output_Spy.c | 57 + .../extras/memory/test/unity_output_Spy.h | 17 + subprojects/unity/library.json | 25 + subprojects/unity/meson.build | 80 + subprojects/unity/meson_options.txt | 3 + subprojects/unity/platformio-build.py | 24 + subprojects/unity/src/meson.build | 17 + subprojects/unity/src/unity.c | 2501 +++++++++++++++++ subprojects/unity/src/unity.h | 698 +++++ subprojects/unity/src/unity_internals.h | 1183 ++++++++ subprojects/unity/unityConfig.cmake | 1 + test/ctest_test.py | 41 + test/meson.build | 1 + 59 files changed, 10347 insertions(+), 136 deletions(-) create mode 100644 ctest/meson.build create mode 100644 ctest/test_base.c create mode 100644 src_c/base.h create mode 100644 subprojects/unity/CMakeLists.txt create mode 100644 subprojects/unity/LICENSE.txt create mode 100644 subprojects/unity/README.md create mode 100644 subprojects/unity/docs/CODE_OF_CONDUCT.md create mode 100644 subprojects/unity/docs/CONTRIBUTING.md create mode 100644 subprojects/unity/docs/MesonGeneratorRunner.md create mode 100644 subprojects/unity/docs/ThrowTheSwitchCodingStandard.md create mode 100644 subprojects/unity/docs/UnityAssertionsCheatSheetSuitableforPrintingandPossiblyFraming.pdf create mode 100644 subprojects/unity/docs/UnityAssertionsReference.md create mode 100644 subprojects/unity/docs/UnityChangeLog.md create mode 100644 subprojects/unity/docs/UnityConfigurationGuide.md create mode 100644 subprojects/unity/docs/UnityGettingStartedGuide.md create mode 100644 subprojects/unity/docs/UnityHelperScriptsGuide.md create mode 100644 subprojects/unity/docs/UnityKnownIssues.md create mode 100644 subprojects/unity/extras/bdd/readme.md create mode 100644 subprojects/unity/extras/bdd/src/unity_bdd.h create mode 100644 subprojects/unity/extras/bdd/test/meson.build create mode 100644 subprojects/unity/extras/bdd/test/test_bdd.c create mode 100644 subprojects/unity/extras/eclipse/error_parsers.txt create mode 100644 subprojects/unity/extras/fixture/readme.md create mode 100644 subprojects/unity/extras/fixture/src/meson.build create mode 100644 subprojects/unity/extras/fixture/src/unity_fixture.c create mode 100644 subprojects/unity/extras/fixture/src/unity_fixture.h create mode 100644 subprojects/unity/extras/fixture/src/unity_fixture_internals.h create mode 100644 subprojects/unity/extras/fixture/test/Makefile create mode 100644 subprojects/unity/extras/fixture/test/main/AllTests.c create mode 100644 subprojects/unity/extras/fixture/test/template_fixture_tests.c create mode 100644 subprojects/unity/extras/fixture/test/unity_fixture_Test.c create mode 100644 subprojects/unity/extras/fixture/test/unity_fixture_TestRunner.c create mode 100644 subprojects/unity/extras/memory/readme.md create mode 100644 subprojects/unity/extras/memory/src/meson.build create mode 100644 subprojects/unity/extras/memory/src/unity_memory.c create mode 100644 subprojects/unity/extras/memory/src/unity_memory.h create mode 100644 subprojects/unity/extras/memory/test/Makefile create mode 100644 subprojects/unity/extras/memory/test/unity_memory_Test.c create mode 100644 subprojects/unity/extras/memory/test/unity_memory_TestRunner.c create mode 100644 subprojects/unity/extras/memory/test/unity_output_Spy.c create mode 100644 subprojects/unity/extras/memory/test/unity_output_Spy.h create mode 100644 subprojects/unity/library.json create mode 100644 subprojects/unity/meson.build create mode 100644 subprojects/unity/meson_options.txt create mode 100644 subprojects/unity/platformio-build.py create mode 100644 subprojects/unity/src/meson.build create mode 100644 subprojects/unity/src/unity.c create mode 100644 subprojects/unity/src/unity.h create mode 100644 subprojects/unity/src/unity_internals.h create mode 100644 subprojects/unity/unityConfig.cmake create mode 100644 test/ctest_test.py diff --git a/.github/workflows/build-debian-multiarch.yml b/.github/workflows/build-debian-multiarch.yml index 927b5f841b..2daa1dabc0 100644 --- a/.github/workflows/build-debian-multiarch.yml +++ b/.github/workflows/build-debian-multiarch.yml @@ -144,7 +144,7 @@ jobs: install: ${{ env.INSTALL_CMD }} run: | echo "\nInstalling wheel\n" - pip3 install --no-index --pre --break-system-packages --find-links /artifacts_new pygame-ce + pip3 install --no-index --pre --break-system-packages --find-links /artifacts_new pygame-ce -Csetup_args=-Dctest=true echo "\nRunning tests\n" export SDL_VIDEODRIVER=dummy export SDL_AUDIODRIVER=disk diff --git a/.gitignore b/.gitignore index ee57d22510..32862dc25a 100644 --- a/.gitignore +++ b/.gitignore @@ -48,6 +48,7 @@ dist __pycache__ _headers/* buildconfig/win_dll_dirs.json +*.log # cython generated files src_c/_sdl2/*.c diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index a9476d3460..cd840221a8 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -15,6 +15,7 @@ repos: | ^.*\.svg$ | ^.*\.sfd$ | docs/LGPL.txt + | subprojects/.* )$ - id: trailing-whitespace exclude: | @@ -23,6 +24,7 @@ repos: | ^.*\.svg$ | ^.*\.sfd$ | docs/LGPL.txt + | subprojects/.* )$ - repo: https://github.com/astral-sh/ruff-pre-commit @@ -47,4 +49,5 @@ repos: | src_c/include/sse2neon.h | src_c/include/pythoncapi_compat.h | src_c/pypm.c + | subprojects/.* )$ diff --git a/ctest/meson.build b/ctest/meson.build new file mode 100644 index 0000000000..6608d2d45d --- /dev/null +++ b/ctest/meson.build @@ -0,0 +1,22 @@ +unity_subproject = subproject('unity') +unity_dependency = unity_subproject.get_variable('unity_dep') + +test_sources = files( + ['../src_c/base.c', + 'test_base.c'] +) + +inc = include_directories('../src_c') + +test = executable('run_ctests', + sources: [ + test_sources, + ], + include_directories: [inc], + dependencies: [unity_dependency, py_dep, sdl_dep], + install: true, + install_dir: pg_dir +) + +# test('test', test, +# should_fail: false) diff --git a/ctest/test_base.c b/ctest/test_base.c new file mode 100644 index 0000000000..abe441681b --- /dev/null +++ b/ctest/test_base.c @@ -0,0 +1,82 @@ +#include "base.h" +#include "unity.h" + +PyObject *base_module; + +void setUp(void) {} + +void tearDown(void) {} + +/** + * @brief Tests _pg_is_int_tuple when passed a tuple of ints + */ +void test__pg_is_int_tuple_nominal(void) { + PyObject *arg1 = Py_BuildValue("(iii)", 1, 2, 3); + PyObject *arg2 = Py_BuildValue("(iii)", -1, -2, -3); + PyObject *arg3 = Py_BuildValue("(iii)", 1, -2, -3); + + TEST_ASSERT_EQUAL(1, _pg_is_int_tuple(arg1)); + TEST_ASSERT_EQUAL(1, _pg_is_int_tuple(arg2)); + TEST_ASSERT_EQUAL(1, _pg_is_int_tuple(arg3)); +} + +/** + * @brief Tests _pg_is_int_tuple when passed a tuple of non-numeric values + */ +void test__pg_is_int_tuple_failureModes(void) { + PyObject *arg1 = + Py_BuildValue("(sss)", (char *)"Larry", (char *)"Moe", (char *)"Curly"); + PyObject *arg2 = Py_BuildValue("(sss)", (char *)NULL, (char *)NULL, + (char *)NULL); // tuple of None's + PyObject *arg3 = Py_BuildValue("(OOO)", arg1, arg2, arg1); + + TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg1)); + TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg2)); + TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg3)); +} + +/** + * @brief Tests _pg_is_int_tuple when passed a tuple of floats + */ +void test__pg_is_int_tuple_floats(void) { + PyObject *arg1 = Py_BuildValue("(ddd)", 1.0, 2.0, 3.0); + PyObject *arg2 = Py_BuildValue("(ddd)", -1.1, -2.2, -3.3); + PyObject *arg3 = Py_BuildValue("(ddd)", 1.0, -2.0, -3.1); + + TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg1)); + TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg2)); + TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg3)); +} + +#define RUN_TEST(TestFunc, TestLineNum) \ + { \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + if (TEST_PROTECT()) { \ + setUp(); \ + TestFunc(); \ + } \ + if (TEST_PROTECT()) { \ + tearDown(); \ + } \ + UnityConcludeTest(); \ + } + +/*=======Test Reset Option=====*/ +void resetTest(void) { + tearDown(); + setUp(); +} + +#undef main +/*=======MAIN=====*/ +int main(void) { + Py_Initialize(); + UnityBegin("test_base.c"); + RUN_TEST(test__pg_is_int_tuple_nominal, 17); + RUN_TEST(test__pg_is_int_tuple_failureModes, 31); + RUN_TEST(test__pg_is_int_tuple_floats, 45); + + return (UnityEnd()); +} diff --git a/dev.py b/dev.py index d334178c04..936adceb7f 100644 --- a/dev.py +++ b/dev.py @@ -30,6 +30,8 @@ ] COVERAGE_ARGS = ["-Csetup-args=-Dcoverage=true"] +CTEST_ARGS = ["-Csetup-args=-Dctest=true"] + # We assume this script works with any pip version above this. PIP_MIN_VERSION = "23.1" @@ -208,6 +210,7 @@ def cmd_build(self): lax = self.args.get("lax", False) sdl3 = self.args.get("sdl3", False) coverage = self.args.get("coverage", False) + ctest = self.args.get("ctest", False) if wheel_dir and coverage: pprint("Cannot pass --wheel and --coverage together", Colors.RED) sys.exit(1) @@ -221,6 +224,8 @@ def cmd_build(self): build_suffix += "-sdl3" if coverage: build_suffix += "-cov" + if ctest: + build_suffix += "-ctest" install_args = [ "--no-build-isolation", f"-Cbuild-dir=.mesonpy-build{build_suffix}", @@ -245,6 +250,9 @@ def cmd_build(self): if coverage: install_args.extend(COVERAGE_ARGS) + if ctest: + install_args.extend(CTEST_ARGS) + info_str = f"with {debug=}, {lax=}, {sdl3=}, and {coverage=}" if wheel_dir: pprint(f"Building wheel at '{wheel_dir}' ({info_str})") @@ -376,6 +384,9 @@ def parse_args(self): "supported if the underlying compiler supports the --coverage argument" ), ) + build_parser.add_argument( + "--ctest", action="store_true", help="Build the C-direct unit tests" + ) # Docs command docs_parser = subparsers.add_parser("docs", help="Generate docs") diff --git a/meson.build b/meson.build index f58ab5b4ff..38d2d63e62 100644 --- a/meson.build +++ b/meson.build @@ -436,4 +436,9 @@ if not get_option('stripped') subdir('buildconfig/stubs') install_subdir('examples', install_dir: pg_dir, install_tag: 'pg-tag') # TODO: install headers? not really important though + + if get_option('ctest') + subproject('unity') + subdir('ctest') + endif endif diff --git a/meson_options.txt b/meson_options.txt index e433b07f52..aec5f9ce4d 100644 --- a/meson_options.txt +++ b/meson_options.txt @@ -24,19 +24,23 @@ option('midi', type: 'feature', value: 'enabled') # Controls whether to make a "stripped" pygame install. Enabling this disables # the bundling of docs/examples/tests/stubs in the wheels. # The default behaviour is to bundle all of these. -option('stripped', type: 'boolean', value: 'false') +option('stripped', type: 'boolean', value: false) # Controls whether to compile with -Werror (or its msvc equivalent). The default # behaviour is to not do this by default -option('error_on_warns', type: 'boolean', value: 'false') +option('error_on_warns', type: 'boolean', value: false) # Controls whether to error on build if generated docs are missing. Defaults to # false. -option('error_docs_missing', type: 'boolean', value: 'false') +option('error_docs_missing', type: 'boolean', value: false) # Controls whether to do a coverage build. # This argument must be used together with the editable install. option('coverage', type: 'boolean', value: false) +# Controls whether to do to a C unit test build. Defaults to false. +# If "stripped" is true, this is ignored. +option('ctest', type: 'boolean', value: false) + # Controls whether to use SDL3 instead of SDL2. The default is to use SDL2 option('sdl_api', type: 'integer', min: 2, max: 3, value: 2) diff --git a/src_c/base.c b/src_c/base.c index 654e73404a..2293e3f238 100644 --- a/src_c/base.c +++ b/src_c/base.c @@ -22,27 +22,28 @@ #define NO_PYGAME_C_API #define PYGAMEAPI_BASE_INTERNAL -#include "pygame.h" +#include "base.h" #include #include "doc/pygame_doc.h" -#include "pgarrinter.h" #include "pgcompat.h" -/* This file controls all the initialization of - * the module and the various SDL subsystems - */ +PG_PixelFormatEnum pg_default_convert_format = 0; -/*platform specific init stuff*/ +/* Custom exceptions */ +static PyObject *pgExc_BufferError = NULL; -#ifdef MS_WIN32 /*python gives us MS_WIN32*/ -#define WIN32_LEAN_AND_MEAN -#define VC_EXTRALEAN -#include -extern int -SDL_RegisterApp(const char *, Uint32, void *); -#endif +/* Only one instance of the state per process. */ +static PyObject *pg_quit_functions = NULL; +static int pg_is_init = 0; +static int pg_sdl_was_init = 0; +SDL_Window *pg_default_window = NULL; +pgSurfaceObject *pg_default_screen = NULL; +static int pg_env_blend_alpha_SDL2 = 0; +/* This file controls all the initialization of + * the module and the various SDL subsystems + */ #if defined(macintosh) #if (!defined(__MWERKS__) && !TARGET_API_MAC_CARBON) QDGlobals pg_qd; @@ -60,122 +61,6 @@ QDGlobals pg_qd; #endif #define BUF_MY_ENDIAN '=' -/* Extended array struct */ -typedef struct pg_capsule_interface_s { - PyArrayInterface inter; - Py_intptr_t imem[1]; -} pgCapsuleInterface; - -/* Py_buffer internal data for an array interface/struct */ -typedef struct pg_view_internals_s { - char format[4]; /* make 4 byte word sized */ - Py_ssize_t imem[1]; -} pgViewInternals; - -/* Custom exceptions */ -static PyObject *pgExc_BufferError = NULL; - -/* Only one instance of the state per process. */ -static PyObject *pg_quit_functions = NULL; -static int pg_is_init = 0; -static int pg_sdl_was_init = 0; -SDL_Window *pg_default_window = NULL; -pgSurfaceObject *pg_default_screen = NULL; -static int pg_env_blend_alpha_SDL2 = 0; - -static void -pg_install_parachute(void); -static void -pg_uninstall_parachute(void); -static void -pg_atexit_quit(void); -static int -pgGetArrayStruct(PyObject *, PyObject **, PyArrayInterface **); -static PyObject * -pgArrayStruct_AsDict(PyArrayInterface *); -static PyObject * -pgBuffer_AsArrayInterface(Py_buffer *); -static PyObject * -pgBuffer_AsArrayStruct(Py_buffer *); -static int -_pg_buffer_is_byteswapped(Py_buffer *); -static void -pgBuffer_Release(pg_buffer *); -static int -pgObject_GetBuffer(PyObject *, pg_buffer *, int); -static inline PyObject * -pgObject_getRectHelper(PyObject *, PyObject *const *, Py_ssize_t, PyObject *, - char *); -static int -pgGetArrayInterface(PyObject **, PyObject *); -static int -pgArrayStruct_AsBuffer(pg_buffer *, PyObject *, PyArrayInterface *, int); -static int -_pg_arraystruct_as_buffer(Py_buffer *, PyObject *, PyArrayInterface *, int); -static int -_pg_arraystruct_to_format(char *, PyArrayInterface *, int); -static int -pgDict_AsBuffer(pg_buffer *, PyObject *, int); -static int -_pg_shape_check(PyObject *); -static int -_pg_typestr_check(PyObject *); -static int -_pg_strides_check(PyObject *); -static int -_pg_data_check(PyObject *); -static int -_pg_is_int_tuple(PyObject *); -static int -_pg_values_as_buffer(Py_buffer *, int, PyObject *, PyObject *, PyObject *, - PyObject *); -static int -_pg_int_tuple_as_ssize_arr(PyObject *, Py_ssize_t *); -static int -_pg_typestr_as_format(PyObject *, char *, Py_ssize_t *); -static PyObject * -pg_view_get_typestr_obj(Py_buffer *); -static PyObject * -pg_view_get_shape_obj(Py_buffer *); -static PyObject * -pg_view_get_strides_obj(Py_buffer *); -static PyObject * -pg_view_get_data_obj(Py_buffer *); -static char -_pg_as_arrayinter_typekind(Py_buffer *); -static char -_pg_as_arrayinter_byteorder(Py_buffer *); -static int -_pg_as_arrayinter_flags(Py_buffer *); -static pgCapsuleInterface * -_pg_new_capsuleinterface(Py_buffer *); -static void -_pg_capsule_PyMem_Free(PyObject *); -static PyObject * -_pg_shape_as_tuple(PyArrayInterface *); -static PyObject * -_pg_typekind_as_str(PyArrayInterface *); -static PyObject * -_pg_strides_as_tuple(PyArrayInterface *); -static PyObject * -_pg_data_as_tuple(PyArrayInterface *); -static PyObject * -pg_get_array_interface(PyObject *, PyObject *); -static void -_pg_release_buffer_array(Py_buffer *); -static void -_pg_release_buffer_generic(Py_buffer *); -static SDL_Window * -pg_GetDefaultWindow(void); -static void -pg_SetDefaultWindow(SDL_Window *); -static pgSurfaceObject * -pg_GetDefaultWindowSurface(void); -static void -pg_SetDefaultWindowSurface(pgSurfaceObject *); -static int -pg_EnvShouldBlendAlphaSDL2(void); - /* compare compiled to linked, raise python error on incompatibility */ static int pg_CheckSDLVersions(void) @@ -1841,7 +1726,7 @@ _pg_strides_check(PyObject *op) return 0; } -static int +int _pg_is_int_tuple(PyObject *op) { Py_ssize_t i; @@ -2205,8 +2090,6 @@ pg_SetDefaultWindowSurface(pgSurfaceObject *screen) pg_default_screen = screen; } -PG_PixelFormatEnum pg_default_convert_format = 0; - static PG_PixelFormatEnum pg_GetDefaultConvertFormat(void) { diff --git a/src_c/base.h b/src_c/base.h new file mode 100644 index 0000000000..d7c17b93ee --- /dev/null +++ b/src_c/base.h @@ -0,0 +1,210 @@ +#define NO_PYGAME_C_API +#define PYGAMEAPI_BASE_INTERNAL + +#include "pygame.h" + +#include +#include "doc/pygame_doc.h" +#include "pgarrinter.h" +#include "pgcompat.h" + +/* This file controls all the initialization of + * the module and the various SDL subsystems + */ + +/*platform specific init stuff*/ + +#ifdef MS_WIN32 /*python gives us MS_WIN32*/ +#define WIN32_LEAN_AND_MEAN +#define VC_EXTRALEAN +#include +extern int +SDL_RegisterApp(const char *, Uint32, void *); +#endif + +#if defined(macintosh) +#if (!defined(__MWERKS__) && !TARGET_API_MAC_CARBON) +QDGlobals pg_qd; +#endif +#endif + +#if SDL_BYTEORDER == SDL_LIL_ENDIAN +#define PAI_MY_ENDIAN '<' +#define PAI_OTHER_ENDIAN '>' +#define BUF_OTHER_ENDIAN '>' +#else +#define PAI_MY_ENDIAN '>' +#define PAI_OTHER_ENDIAN '<' +#define BUF_OTHER_ENDIAN '<' +#endif +#define BUF_MY_ENDIAN '=' + +/* Extended array struct */ +typedef struct pg_capsule_interface_s { + PyArrayInterface inter; + Py_intptr_t imem[1]; +} pgCapsuleInterface; + +/* Py_buffer internal data for an array interface/struct */ +typedef struct pg_view_internals_s { + char format[4]; /* make 4 byte word sized */ + Py_ssize_t imem[1]; +} pgViewInternals; + +static void +pg_install_parachute(void); +static void +pg_uninstall_parachute(void); +static void +pg_atexit_quit(void); +static int +pgGetArrayStruct(PyObject *, PyObject **, PyArrayInterface **); +static PyObject * +pgArrayStruct_AsDict(PyArrayInterface *); +static PyObject * +pgBuffer_AsArrayInterface(Py_buffer *); +static PyObject * +pgBuffer_AsArrayStruct(Py_buffer *); +static int +_pg_buffer_is_byteswapped(Py_buffer *); +static void +pgBuffer_Release(pg_buffer *); +static int +pgObject_GetBuffer(PyObject *, pg_buffer *, int); +static inline PyObject * +pgObject_getRectHelper(PyObject *, PyObject *const *, Py_ssize_t, PyObject *, + char *); +static int +pgGetArrayInterface(PyObject **, PyObject *); +static int +pgArrayStruct_AsBuffer(pg_buffer *, PyObject *, PyArrayInterface *, int); +static int +_pg_arraystruct_as_buffer(Py_buffer *, PyObject *, PyArrayInterface *, int); +static int +_pg_arraystruct_to_format(char *, PyArrayInterface *, int); +static int +pgDict_AsBuffer(pg_buffer *, PyObject *, int); +static int +_pg_shape_check(PyObject *); +static int +_pg_typestr_check(PyObject *); +static int +_pg_strides_check(PyObject *); +static int +_pg_data_check(PyObject *); +int +_pg_is_int_tuple(PyObject *); +static int +_pg_values_as_buffer(Py_buffer *, int, PyObject *, PyObject *, PyObject *, + PyObject *); +static int +_pg_int_tuple_as_ssize_arr(PyObject *, Py_ssize_t *); +static int +_pg_typestr_as_format(PyObject *, char *, Py_ssize_t *); +static PyObject * +pg_view_get_typestr_obj(Py_buffer *); +static PyObject * +pg_view_get_shape_obj(Py_buffer *); +static PyObject * +pg_view_get_strides_obj(Py_buffer *); +static PyObject * +pg_view_get_data_obj(Py_buffer *); +static char +_pg_as_arrayinter_typekind(Py_buffer *); +static char +_pg_as_arrayinter_byteorder(Py_buffer *); +static int +_pg_as_arrayinter_flags(Py_buffer *); +static pgCapsuleInterface * +_pg_new_capsuleinterface(Py_buffer *); +static void +_pg_capsule_PyMem_Free(PyObject *); +static PyObject * +_pg_shape_as_tuple(PyArrayInterface *); +static PyObject * +_pg_typekind_as_str(PyArrayInterface *); +static PyObject * +_pg_strides_as_tuple(PyArrayInterface *); +static PyObject * +_pg_data_as_tuple(PyArrayInterface *); +static PyObject * +pg_get_array_interface(PyObject *, PyObject *); +static void +_pg_release_buffer_array(Py_buffer *); +static void +_pg_release_buffer_generic(Py_buffer *); +static SDL_Window * +pg_GetDefaultWindow(void); +static void +pg_SetDefaultWindow(SDL_Window *); +static pgSurfaceObject * +pg_GetDefaultWindowSurface(void); +static void +pg_SetDefaultWindowSurface(pgSurfaceObject *); +static int +pg_EnvShouldBlendAlphaSDL2(void); +static int +pg_CheckSDLVersions(void); +void +pg_RegisterQuit(void (*func)(void)); +static PyObject * +pg_register_quit(PyObject *self, PyObject *value); +static int +pg_mod_autoinit(const char *modname); +static void +pg_mod_autoquit(const char *modname); +static PyObject * +pg_init(PyObject *self, PyObject *_null); +static PyObject * +pg_get_sdl_version(PyObject *self, PyObject *args, PyObject *kwargs); +static PyObject * +pg_get_sdl_byteorder(PyObject *self, PyObject *_null); +static void +_pg_quit(void); +static PyObject * +pg_quit(PyObject *self, PyObject *_null); +static PyObject * +pg_base_get_init(PyObject *self, PyObject *_null); +/* internal C API utility functions */ +static int +pg_IntFromObj(PyObject *obj, int *val); +static int +pg_IntFromObjIndex(PyObject *obj, int _index, int *val); +static int +pg_TwoIntsFromObj(PyObject *obj, int *val1, int *val2); +static int +pg_FloatFromObj(PyObject *obj, float *val); +static int +pg_FloatFromObjIndex(PyObject *obj, int _index, float *val); +static int +pg_TwoFloatsFromObj(PyObject *obj, float *val1, float *val2); +static inline int +pg_DoubleFromObj(PyObject *obj, double *val); +/*Assumes obj is a Sequence, internal or conscious use only*/ +static inline int +_pg_DoubleFromObjIndex(PyObject *obj, int index, double *val); +static inline int +pg_TwoDoublesFromObj(PyObject *obj, double *val1, double *val2); +static inline int +pg_TwoDoublesFromFastcallArgs(PyObject *const *args, Py_ssize_t nargs, + double *val1, double *val2); +static int +pg_UintFromObj(PyObject *obj, Uint32 *val); +static int +pg_UintFromObjIndex(PyObject *obj, int _index, Uint32 *val); +/* You probably want to use the pg_RGBAFromObjEx function instead of this. */ +static int +pg_RGBAFromObj(PyObject *obj, Uint8 *RGBA); +static PyObject * +pg_get_error(PyObject *self, PyObject *_null); +static PyObject * +pg_set_error(PyObject *s, PyObject *args); +/*error signal handlers(replacing SDL parachute)*/ +static void +pygame_parachute(int sig); +static void +pg_SetDefaultConvertFormat(PG_PixelFormatEnum format); +static PG_PixelFormatEnum +pg_GetDefaultConvertFormat(void); + +MODINIT_DEFINE(base); diff --git a/subprojects/unity/CMakeLists.txt b/subprojects/unity/CMakeLists.txt new file mode 100644 index 0000000000..f7062199e3 --- /dev/null +++ b/subprojects/unity/CMakeLists.txt @@ -0,0 +1,172 @@ +################################################################################### +# # +# NAME: CMakeLists.txt # +# # +# AUTHOR: Mike Karlesky, Mark VanderVoord, Greg Williams. # +# WRITTEN BY: Michael Brockus. # +# # +# License: MIT # +# # +################################################################################### + +cmake_minimum_required(VERSION 3.12) + +# Read src/unity.h file and get project version from it +set(UNITY_HEADER "src/unity.h") + +file(STRINGS "${UNITY_HEADER}" UNITY_HEADER_CONTENT + REGEX "^#define UNITY_VERSION_(MAJOR|MINOR|BUILD) +[0-9]+$" +) + +set(UNITY_HEADER_VERSION_MAJOR 0) +set(UNITY_HEADER_VERSION_MINOR 0) +set(UNITY_HEADER_VERSION_BUILD 0) + +foreach(VERSION_LINE IN LISTS UNITY_HEADER_CONTENT) + foreach(VERSION_PART MAJOR MINOR BUILD) + string(CONCAT REGEX_STRING "#define UNITY_VERSION_" + "${VERSION_PART}" + " +([0-9]+)" + ) + + if(VERSION_LINE MATCHES "${REGEX_STRING}") + set(UNITY_HEADER_VERSION_${VERSION_PART} "${CMAKE_MATCH_1}") + endif() + endforeach() +endforeach() + +project(unity + VERSION ${UNITY_HEADER_VERSION_MAJOR}.${UNITY_HEADER_VERSION_MINOR}.${UNITY_HEADER_VERSION_BUILD} + LANGUAGES C + DESCRIPTION "C Unit testing framework." +) + +# Options to Build With Extras ------------------------------------------------- +option(UNITY_EXTENSION_FIXTURE "Compiles Unity with the \"fixture\" extension." OFF) +option(UNITY_EXTENSION_MEMORY "Compiles Unity with the \"memory\" extension." OFF) + +set(UNITY_EXTENSION_FIXTURE_ENABLED $) +set(UNITY_EXTENSION_MEMORY_ENABLED $>) + +if(${UNITY_EXTENSION_FIXTURE}) + message(STATUS "Unity: Building with the fixture extension.") +endif() + +if(${UNITY_EXTENSION_MEMORY}) + message(STATUS "Unity: Building with the memory extension.") +endif() + +# Main target ------------------------------------------------------------------ +add_library(${PROJECT_NAME} STATIC) +add_library(${PROJECT_NAME}::framework ALIAS ${PROJECT_NAME}) + +# Includes --------------------------------------------------------------------- +include(GNUInstallDirs) +include(CMakePackageConfigHelpers) + +target_sources(${PROJECT_NAME} + PRIVATE + src/unity.c + $<$:extras/fixture/src/unity_fixture.c> + $<$:extras/memory/src/unity_memory.c> +) + +target_include_directories(${PROJECT_NAME} + PUBLIC + $ + $ + $ + $ + $:${CMAKE_CURRENT_SOURCE_DIR}/extras/memory/src>> + $:${CMAKE_CURRENT_SOURCE_DIR}/extras/fixture/src>> +) + +set(${PROJECT_NAME}_PUBLIC_HEADERS + src/unity.h + src/unity_internals.h + $<$:${CMAKE_CURRENT_SOURCE_DIR}/extras/fixture/src/unity_fixture.h> + $<$:${CMAKE_CURRENT_SOURCE_DIR}/extras/fixture/src/unity_fixture_internals.h> + $<$:${CMAKE_CURRENT_SOURCE_DIR}/extras/memory/src/unity_memory.h> +) + +set_target_properties(${PROJECT_NAME} + PROPERTIES + C_STANDARD 11 + C_STANDARD_REQUIRED ON + C_EXTENSIONS OFF + PUBLIC_HEADER "${${PROJECT_NAME}_PUBLIC_HEADERS}" + EXPORT_NAME framework +) + +target_compile_options(${PROJECT_NAME} + PRIVATE + # Clang + $<$: + -Wcast-align + -Wcast-qual + -Wconversion + -Wexit-time-destructors + -Wglobal-constructors + -Wmissing-noreturn + -Wmissing-prototypes + -Wno-missing-braces + -Wold-style-cast + -Wshadow + -Wweak-vtables + -Werror + -Wall + $<$,8.0.0>:-Wextra-semi-stmt> + > + + # GCC + $<$: + -Waddress + -Waggregate-return + -Wformat-nonliteral + -Wformat-security + -Wformat + -Winit-self + -Wmissing-declarations + -Wmissing-include-dirs + -Wno-multichar + -Wno-parentheses + -Wno-type-limits + -Wno-unused-parameter + -Wunreachable-code + -Wwrite-strings + -Wpointer-arith + -Werror + -Wall + > + + # MSVC + $<$: + /Wall + > +) + +write_basic_package_version_file(${PROJECT_NAME}ConfigVersion.cmake + VERSION ${PROJECT_VERSION} + COMPATIBILITY SameMajorVersion +) + +## Target installation +install(TARGETS ${PROJECT_NAME} + EXPORT ${PROJECT_NAME}Targets + ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} + PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME} + COMPONENT library +) + +## Target's cmake files: targets export +install(EXPORT ${PROJECT_NAME}Targets + NAMESPACE ${PROJECT_NAME}:: + DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME} +) + +## Target's cmake files: config and version config for find_package() +install(FILES ${PROJECT_NAME}Config.cmake + ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake + DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME} +) diff --git a/subprojects/unity/LICENSE.txt b/subprojects/unity/LICENSE.txt new file mode 100644 index 0000000000..3e3aad5bcd --- /dev/null +++ b/subprojects/unity/LICENSE.txt @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/subprojects/unity/README.md b/subprojects/unity/README.md new file mode 100644 index 0000000000..2ebf988e6a --- /dev/null +++ b/subprojects/unity/README.md @@ -0,0 +1,234 @@ +# Unity Test ![CI][] + +__Copyright (c) 2007 - 2024 Unity Project by Mike Karlesky, Mark VanderVoord, and Greg Williams__ + +Welcome to the Unity Test Project, one of the main projects of ThrowTheSwitch.org. +Unity Test is a unit testing framework built for C, with a focus on working with embedded toolchains. + +This project is made to test code targetting microcontrollers big and small. +The core project is a single C file and a pair of headers, allowing it to be added to your existing build setup without too much headache. +You may use any compiler you wish, and may use most existing build systems including Make, CMake, etc. +If you'd like to leave the hard work to us, you might be interested in Ceedling, a build tool also by ThrowTheSwitch.org. + +If you're new to Unity, we encourage you to tour the [getting started guide][]. + +You can also find the [change log][] and [known issues][] in our documentation. + +## Getting Started + +The [docs][] folder contains a [getting started guide][] and much more tips about using Unity. + +## Unity Assertion Summary + +For the full list, see [UnityAssertionsReference.md][]. + +### Basic Validity Tests + + TEST_ASSERT_TRUE(condition) + +Evaluates whatever code is in condition and fails if it evaluates to false + + TEST_ASSERT_FALSE(condition) + +Evaluates whatever code is in condition and fails if it evaluates to true + + TEST_ASSERT(condition) + +Another way of calling `TEST_ASSERT_TRUE` + + TEST_ASSERT_UNLESS(condition) + +Another way of calling `TEST_ASSERT_FALSE` + + TEST_FAIL() + TEST_FAIL_MESSAGE(message) + +This test is automatically marked as a failure. +The message is output stating why. + +### Numerical Assertions: Integers + + TEST_ASSERT_EQUAL_INT(expected, actual) + TEST_ASSERT_EQUAL_INT8(expected, actual) + TEST_ASSERT_EQUAL_INT16(expected, actual) + TEST_ASSERT_EQUAL_INT32(expected, actual) + TEST_ASSERT_EQUAL_INT64(expected, actual) + +Compare two integers for equality and display errors as signed integers. +A cast will be performed to your natural integer size so often this can just be used. +When you need to specify the exact size, you can use a specific version. + + TEST_ASSERT_EQUAL_UINT(expected, actual) + TEST_ASSERT_EQUAL_UINT8(expected, actual) + TEST_ASSERT_EQUAL_UINT16(expected, actual) + TEST_ASSERT_EQUAL_UINT32(expected, actual) + TEST_ASSERT_EQUAL_UINT64(expected, actual) + +Compare two integers for equality and display errors as unsigned integers. +Like INT, there are variants for different sizes also. + + TEST_ASSERT_EQUAL_HEX(expected, actual) + TEST_ASSERT_EQUAL_HEX8(expected, actual) + TEST_ASSERT_EQUAL_HEX16(expected, actual) + TEST_ASSERT_EQUAL_HEX32(expected, actual) + TEST_ASSERT_EQUAL_HEX64(expected, actual) + +Compares two integers for equality and display errors as hexadecimal. +Like the other integer comparisons, you can specify the size... +here the size will also effect how many nibbles are shown (for example, `HEX16` will show 4 nibbles). + + TEST_ASSERT_EQUAL(expected, actual) + +Another way of calling TEST_ASSERT_EQUAL_INT + + TEST_ASSERT_INT_WITHIN(delta, expected, actual) + +Asserts that the actual value is within plus or minus delta of the expected value. +This also comes in 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 + + _ARRAY + +You can append `_ARRAY` to any of these macros to make an array comparison of that type. +Here you will need to care a bit more about the actual size of the value being checked. +You will also specify an additional argument which is the number of elements to compare. +For example: + + TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, elements) + + _EACH_EQUAL + +Another array comparison option is to check that EVERY element of an array is equal to a single expected value. +You do this by specifying the EACH_EQUAL macro. +For example: + + TEST_ASSERT_EACH_EQUAL_INT32(expected, actual, elements) + +### Numerical Assertions: Bitwise + + TEST_ASSERT_BITS(mask, expected, actual) + +Use an integer mask to specify which bits should be compared between two other integers. +High bits in the mask are compared, low bits ignored. + + TEST_ASSERT_BITS_HIGH(mask, actual) + +Use an integer mask to specify which bits should be inspected to determine if they are all set high. +High bits in the mask are compared, low bits ignored. + + TEST_ASSERT_BITS_LOW(mask, actual) + +Use an integer mask to specify which bits should be inspected to determine if they are all set low. +High bits in the mask are compared, low bits ignored. + + TEST_ASSERT_BIT_HIGH(bit, actual) + +Test a single bit and verify that it is high. +The bit is specified 0-31 for a 32-bit integer. + + TEST_ASSERT_BIT_LOW(bit, actual) + +Test a single bit and verify that it is low. +The bit is specified 0-31 for a 32-bit integer. + +### Numerical Assertions: Floats + + TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual) + TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual) + +Asserts that the actual value is within plus or minus delta of the expected value. + + TEST_ASSERT_FLOAT_NOT_WITHIN(delta, expected, actual) + TEST_ASSERT_DOUBLE_NOT_WITHIN(delta, expected, actual) + +Asserts that the actual value is NOT within plus or minus delta of the expected value. + + TEST_ASSERT_EQUAL_FLOAT(expected, actual) + TEST_ASSERT_EQUAL_DOUBLE(expected, actual) + +Asserts that two floating point values are "equal" within a small % delta of the expected value. + + TEST_ASSERT_NOT_EQUAL_FLOAT(expected, actual) + TEST_ASSERT_NOT_EQUAL_DOUBLE(expected, actual) + +Asserts that two floating point values are NOT "equal" within a small % delta of the expected value. + + TEST_ASSERT_LESS_THAN_FLOAT(threshold, actual) + TEST_ASSERT_LESS_THAN_DOUBLE(threshold, actual) + TEST_ASSERT_GREATER_THAN_FLOAT(threshold, actual) + TEST_ASSERT_GREATER_THAN_DOUBLE(threshold, actual) + +Asserts that the actual value is less than or greater than the threshold. + +There are also `LESS_OR_EQUAL` and `GREATER_OR_EQUAL` variations. +These obey the same rules for equality as do `TEST_ASSERT_EQUAL_FLOAT` and `TEST_ASSERT_EQUAL_DOUBLE`: +If the two values are within a small % delta of the expected value, the assertion will pass. + +### String Assertions + + TEST_ASSERT_EQUAL_STRING(expected, actual) + +Compare two null-terminate strings. +Fail if any character is different or if the lengths are different. + + TEST_ASSERT_EQUAL_STRING_LEN(expected, actual, len) + +Compare two strings. +Fail if any character is different, stop comparing after len characters. + + TEST_ASSERT_EQUAL_STRING_MESSAGE(expected, actual, message) + +Compare two null-terminate strings. +Fail if any character is different or if the lengths are different. +Output a custom message on failure. + + TEST_ASSERT_EQUAL_STRING_LEN_MESSAGE(expected, actual, len, message) + +Compare two strings. +Fail if any character is different, stop comparing after len characters. +Output a custom message on failure. + +### Pointer Assertions + +Most pointer operations can be performed by simply using the integer comparisons above. +However, a couple of special cases are added for clarity. + + TEST_ASSERT_NULL(pointer) + +Fails if the pointer is not equal to NULL + + TEST_ASSERT_NOT_NULL(pointer) + +Fails if the pointer is equal to NULL + +### Memory Assertions + + TEST_ASSERT_EQUAL_MEMORY(expected, actual, len) + +Compare two blocks of memory. +This is a good generic assertion for types that can't be coerced into acting like standard types... +but since it's a memory compare, you have to be careful that your data types are packed. + +### \_MESSAGE + +You can append `\_MESSAGE` to any of the macros to make them take an additional argument. +This argument is a string that will be printed at the end of the failure strings. +This is useful for specifying more information about the problem. + +[CI]: https://github.com/ThrowTheSwitch/Unity/workflows/CI/badge.svg +[getting started guide]: docs/UnityGettingStartedGuide.md +[change log]: docs/UnityChangeLog.md +[known issues]: docs/UnityKnownIssues.md +[docs]: docs/ +[UnityAssertionsReference.md]: docs/UnityAssertionsReference.md diff --git a/subprojects/unity/docs/CODE_OF_CONDUCT.md b/subprojects/unity/docs/CODE_OF_CONDUCT.md new file mode 100644 index 0000000000..84e34806a9 --- /dev/null +++ b/subprojects/unity/docs/CODE_OF_CONDUCT.md @@ -0,0 +1,138 @@ + +# ThrowTheSwitch.org Code of Conduct + +Thank you for participating in a ThrowTheSwitch.org community project! We want +this to continue to be a warm and inviting place for everyone to share ideas +and get help. To accomplish this goal, we've developed this Code of Conduct. + +## Our Pledge + +We as members, contributors, and leaders pledge to make participation in our +community a harassment-free experience for everyone, regardless of age, body +size, visible or invisible disability, ethnicity, sex characteristics, gender +identity and expression, level of experience, education, socio-economic status, +nationality, personal appearance, race, caste, color, religion, or sexual +identity and orientation. + +We pledge to act and interact in ways that contribute to an open, welcoming, +diverse, inclusive, and healthy community. + +## Our Standards + +Examples of behavior that contributes to a positive environment for our +community include: + +* Demonstrating empathy and kindness toward other people +* Being respectful of differing opinions, viewpoints, and experiences +* Giving and gracefully accepting constructive feedback +* Accepting responsibility and apologizing to those affected by our mistakes, + and learning from the experience +* Focusing on what is best not just for us as individuals, but for the overall + community + +Examples of unacceptable behavior include: + +* The use of sexualized language or imagery, and sexual attention or advances of + any kind +* Trolling, insulting or derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or email address, + without their explicit permission +* Other conduct which could reasonably be considered inappropriate in a + professional setting + +## Enforcement Responsibilities + +Community leaders are responsible for clarifying and enforcing our standards of +acceptable behavior and will take appropriate and fair corrective action in +response to any behavior that they deem inappropriate, threatening, offensive, +or harmful. + +Community leaders have the right and responsibility to remove, edit, or reject +comments, commits, code, wiki edits, issues, and other contributions that are +not aligned to this Code of Conduct, and will communicate reasons for moderation +decisions when appropriate. + +## Scope + +This Code of Conduct applies within all community spaces, and also applies when +an individual is officially representing the community in public spaces. +Examples of representing our community include using an official email address, +posting via an official social media account, or acting as an appointed +representative at an online or offline event. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported to the community leaders responsible for enforcement at +hello@thingamabyte.com. + +All complaints will be reviewed and investigated promptly and fairly. + +All community leaders are obligated to respect the privacy and security of the +reporter of any incident. + +## Enforcement Guidelines + +Community leaders will follow these Community Impact Guidelines in determining +the consequences for any action they deem in violation of this Code of Conduct: + +### 1. Correction + +**Community Impact**: Use of inappropriate language or other behavior deemed +unprofessional or unwelcome in the community. + +**Consequence**: A private, written warning from community leaders, providing +clarity around the nature of the violation and an explanation of why the +behavior was inappropriate. A public apology may be requested. + +### 2. Warning + +**Community Impact**: A violation through a single incident or series of +actions. + +**Consequence**: A warning with consequences for continued behavior. No +interaction with the people involved, including unsolicited interaction with +those enforcing the Code of Conduct, for a specified period of time. This +includes avoiding interactions in community spaces as well as external channels +like social media. Violating these terms may lead to a temporary or permanent +ban. + +### 3. Temporary Ban + +**Community Impact**: A serious violation of community standards, including +sustained inappropriate behavior. + +**Consequence**: A temporary ban from any sort of interaction or public +communication with the community for a specified period of time. No public or +private interaction with the people involved, including unsolicited interaction +with those enforcing the Code of Conduct, is allowed during this period. +Violating these terms may lead to a permanent ban. + +### 4. Permanent Ban + +**Community Impact**: Demonstrating a pattern of violation of community +standards, including sustained inappropriate behavior, harassment of an +individual, or aggression toward or disparagement of classes of individuals. + +**Consequence**: A permanent ban from any sort of public interaction within the +community. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], +version 2.1, available at +[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1]. + +Community Impact Guidelines were inspired by +[Mozilla's code of conduct enforcement ladder][Mozilla CoC]. + +For answers to common questions about this code of conduct, see the FAQ at +[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at +[https://www.contributor-covenant.org/translations][translations]. + +[homepage]: https://www.contributor-covenant.org +[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html +[Mozilla CoC]: https://github.com/mozilla/diversity +[FAQ]: https://www.contributor-covenant.org/faq +[translations]: https://www.contributor-covenant.org/translations diff --git a/subprojects/unity/docs/CONTRIBUTING.md b/subprojects/unity/docs/CONTRIBUTING.md new file mode 100644 index 0000000000..e64a285a15 --- /dev/null +++ b/subprojects/unity/docs/CONTRIBUTING.md @@ -0,0 +1,238 @@ +# Contributing to a ThrowTheSwitch.org Project + +👍🎉 _First off, thanks for taking the time to contribute!_ 🎉👍 + +The following is a set of guidelines for contributing to any of ThrowTheSwitch.org's projects or the website itself, hosted at throwtheswitch.org or ThrowTheSwitch's organization on GitHub. These are mostly guidelines, not rules. Use your best judgment, and feel free to propose changes to this document in a pull request. + +### Table Of Contents + +- [Code of Conduct](#book-code-of-conduct) +- [Asking Questions](#bulb-asking-questions) +- [Opening an Issue](#inbox_tray-opening-an-issue) +- [Feature Requests](#love_letter-feature-requests) +- [Triaging Issues](#mag-triaging-issues) +- [Submitting Pull Requests](#repeat-submitting-pull-requests) +- [Writing Commit Messages](#memo-writing-commit-messages) +- [Code Review](#white_check_mark-code-review) +- [Coding Style](#nail_care-coding-style) +- [Certificate of Origin](#medal_sports-certificate-of-origin) +- [Credits](#pray-credits) + +## :book: Code of Conduct + +Please review our [Code of Conduct](CODE_OF_CONDUCT.md). It is in effect at all times. We expect it to be honored by everyone who contributes to this project. Be a Good Human! + +## :bulb: Asking Questions + +> **Note:** Please don't file an issue to ask a question. We have an official forum where the community chimes in with helpful advice if you have questions. + +* [ThrowTheSwitch Forums](https://throwtheswitch.org/forums) + +### What should I know before I get started? + +ThrowTheSwitch hosts a number of open source projects — Ceedling is the entrypoint for many users. Ceedling is actually built upon the foundation of Unity Test (a flexible C testing framework) and CMock (a mocking tool for C) and it coordinates many other open source and proprietary tools. Please do your best to focus your ideas and questions at the correct tool. We'll do our best to help you find your way, but there will be times where we'll have to direct your attention to another subtool. + +Here are some of the main projects hosted by ThrowTheSwitch.org: + + - [Ceedling](https://www.github.com/throwtheswitch/ceedling) -- Build coordinator for testing C applications, especially embedded C (and optionally your release build too!) + - [CMock](https://www.github.com/throwtheswitch/cmock) -- Mocking tool for automatically creating stubs, mocks, and skeletons in C + - [Unity](https://www.github.com/throwtheswitch/unity) -- Unit Testing framework for C, specially embedded C. + - [MadScienceLabDocker](https://www.github.com/throwtheswitch/madsciencelabdocker) -- Docker image giving you a shortcut to getting running with Ceedling + - [CException](https://www.github.com/throwtheswitch/cexception) -- An exception framework for using simple exceptions in C. + +There are many more, but this list should be a good starting point. + +## :inbox_tray: Opening an Issue + +Before [creating an issue](https://help.github.com/en/github/managing-your-work-on-github/creating-an-issue), check if you are using the latest version of the project. If you are not up-to-date, see if updating fixes your issue first. + +### :beetle: Bug Reports and Other Issues + +A great way to contribute to the project is to send a detailed issue when you encounter a problem. We always appreciate a well-written, thorough bug report. :v: + +In short, since you are most likely a developer, **provide a ticket that you would like to receive**. + +- **Review the documentation** before opening a new issue. + +- **Do not open a duplicate issue!** Search through existing issues to see if your issue has previously been reported. If your issue exists, comment with any additional information you have. You may simply note "I have this problem too", which helps prioritize the most common problems and requests. + +- **Prefer using [reactions](https://github.blog/2016-03-10-add-reactions-to-pull-requests-issues-and-comments/)**, not comments, if you simply want to "+1" an existing issue. + +- **Fully complete the provided issue template.** The bug report template requests all the information we need to quickly and efficiently address your issue. Be clear, concise, and descriptive. Provide as much information as you can, including steps to reproduce, stack traces, compiler errors, library versions, OS versions, and screenshots (if applicable). + +- **Use [GitHub-flavored Markdown](https://help.github.com/en/github/writing-on-github/basic-writing-and-formatting-syntax).** Especially put code blocks and console outputs in backticks (```). This improves readability. + +## :seedling: Feature Requests + +Feature requests are welcome! We don't have all the answers and we truly love the collaborative experience of building software together! That being said, we cannot guarantee your request will be accepted. We want to avoid [feature creep](https://en.wikipedia.org/wiki/Feature_creep). Your idea may be great, but also out-of-scope for the project. If accepted, we'll do our best to tackle it in a timely manner, but cannot make any commitments regarding the timeline for implementation and release. However, you are welcome to submit a pull request to help! + +- **Please don't open a duplicate feature request.** Search for existing feature requests first. If you find your feature (or one very similar) previously requested, comment on that issue. + +- **Fully complete the provided issue template.** The feature request template asks for all necessary information for us to begin a productive conversation. + +- Be precise about the proposed outcome of the feature and how it relates to existing features. Include implementation details if possible. + +## :mag: Triaging Issues + +You can triage issues which may include reproducing bug reports or asking for additional information, such as version numbers or reproduction instructions. Any help you can provide to quickly resolve an issue is very much appreciated! + +## :repeat: Submitting Pull Requests + +We **love** pull requests! Before [forking the repo](https://help.github.com/en/github/getting-started-with-github/fork-a-repo) and [creating a pull request](https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/proposing-changes-to-your-work-with-pull-requests) for non-trivial changes, it is usually best to first open an issue to discuss the changes, or discuss your intended approach for solving the problem in the comments for an existing issue. + +For most contributions, after your first pull request is accepted and merged, you will be [invited to the project](https://help.github.com/en/github/setting-up-and-managing-your-github-user-account/inviting-collaborators-to-a-personal-repository) and given **push access**. :tada: + +*Note: All contributions will be licensed under the project's license.* + +- **Smaller is better.** Submit **one** pull request per bug fix or feature. A pull request should contain isolated changes pertaining to a single bug fix or feature implementation. **Do not** refactor or reformat code that is unrelated to your change. It is better to **submit many small pull requests** rather than a single large one. Enormous pull requests will take enormous amounts of time to review, or may be rejected altogether. + +- **Coordinate bigger changes.** For large and non-trivial changes, open an issue to discuss a strategy with the maintainers. Otherwise, you risk doing a lot of work for nothing! + +- **Prioritize understanding over cleverness.** Write code clearly and concisely. Remember that source code usually gets written once and read often. Ensure the code is clear to the reader. The purpose and logic should be obvious to a reasonably skilled developer, otherwise you should add a comment that explains it. + +- **Follow existing coding style and conventions.** Keep your code consistent with the style, formatting, and conventions in the rest of the code base. When possible, these will be enforced with a linter. Consistency makes it easier to review and modify in the future. + +- **Include test coverage.** Add unit tests when possible. Follow existing patterns for implementing tests. + +- **Update the example project** if one exists to exercise any new functionality you have added. + +- **Add documentation.** Document your changes with code doc comments or in existing guides. + +- **Update the CHANGELOG** for all enhancements and bug fixes. Include the corresponding issue number if one exists, and your GitHub username. (example: "- Fixed crash in profile view. #123 @jessesquires") + +- **Use the repo's default branch.** Branch from and [submit your pull request](https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/creating-a-pull-request-from-a-fork) to the repo's default branch. Usually this is `main`, but it could be `dev`, `develop`, or `master`. + +- **[Resolve any merge conflicts](https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/resolving-a-merge-conflict-on-github)** that occur. + +- **Promptly address any CI failures**. If your pull request fails to build or pass tests, please push another commit to fix it. + +- When writing comments, use properly constructed sentences, including punctuation. + +- Use spaces, not tabs. + +## :memo: Writing Commit Messages + +Please [write a great commit message](https://chris.beams.io/posts/git-commit/). + +1. Separate subject from body with a blank line +1. Limit the subject line to 50 characters +1. Capitalize the subject line +1. Do not end the subject line with a period +1. Wrap the body at _about_ 72 characters +1. Use the body to explain **why**, *not what and how* (the code shows that!) +1. If applicable, prefix the title with the relevant component name or emoji (see below. examples: "[Docs] Fix typo", "[Profile] Fix missing avatar") + +``` +:palm_tree: Summary of Amazing Feature Here + +Add a more detailed explanation here, if necessary. Possibly give +some background about the issue being fixed, etc. The body of the +commit message can be several paragraphs. Further paragraphs come +after blank lines and please do proper word-wrap. + +Wrap it to about 72 characters or so. In some contexts, +the first line is treated as the subject of the commit and the +rest of the text as the body. The blank line separating the summary +from the body is critical (unless you omit the body entirely); +various tools like `log`, `shortlog` and `rebase` can get confused +if you run the two together. + +Explain the problem that this commit is solving. Focus on why you +are making this change as opposed to how or what. The code explains +how or what. Reviewers and your future self can read the patch, +but might not understand why a particular solution was implemented. +Are there side effects or other unintuitive consequences of this +change? Here's the place to explain them. + + - Bullet points are awesome, too + + - A hyphen should be used for the bullet, preceded + by a single space, with blank lines in between + +Note the fixed or relevant GitHub issues at the end: + +Resolves: #123 +See also: #456, #789 +``` + +## :heart: Who Loves Emoji? + +Commit comments, Issues, Feature Requests... they can all use a little sprucing up, right? Consider using the following emoji for a mix of function and :sparkles: dazzle! + + - actions + - :seedling: `:seedling:` (or other plants) when growing new features. Choose your fav! :cactus: :herb: :evergreen_tree: :palm_tree: :deciduous_tree: :blossom: + - :art: `:art:` when improving the format/structure of the code + - :racehorse: `:racehorse:` when improving performance + - :non-potable_water: `:non-potable_water:` when plugging memory leaks + - :memo: `:memo:` when writing docs + - :bug: `:bug:` (or other insects) when fixing a bug. Maybe :beetle: :ant: or :honeybee: ? + - :fire: `:fire:` when removing code or files + - :green_heart: `:green_heart:` when fixing the CI build + - :white_check_mark: `:white_check_mark:` when adding tests + - :lock: `:lock:` when dealing with security + - :arrow_up: `:arrow_up:` when upgrading dependencies + - :arrow_down: `:arrow_down:` when downgrading dependencies + - :shirt: `:shirt:` when removing linter warnings + + - platforms + - :penguin: `:penguin:` when fixing something on Linux + - :apple: `:apple:` when fixing something on macOS + - :checkered_flag: `:checkered_flag:` when fixing something on Windows + +## :white_check_mark: Code Review + +- **Review the code, not the author.** Look for and suggest improvements without disparaging or insulting the author. Provide actionable feedback and explain your reasoning. + +- **You are not your code.** When your code is critiqued, questioned, or constructively criticized, remember that you are not your code. Do not take code review personally. + +- **Always do your best.** No one writes bugs on purpose. Do your best, and learn from your mistakes. + +- Kindly note any violations to the guidelines specified in this document. + +## :violin: Coding Style + +Consistency is the most important. Following the existing style, formatting, and naming conventions of the file you are modifying and of the overall project. Failure to do so will result in a prolonged review process that has to focus on updating the superficial aspects of your code, rather than improving its functionality and performance. + +For example, if all private properties are prefixed with an underscore `_`, then new ones you add should be prefixed in the same way. Or, if methods are named using camelcase, like `thisIsMyNewMethod`, then do not diverge from that by writing `this_is_my_new_method`. You get the idea. If in doubt, please ask or search the codebase for something similar. + +When possible, style and format will be enforced with a linter. + +### C Styleguide + +C code is linted with [AStyle](https://astyle.sourceforge.net/). + +### Ruby Styleguide + +Ruby code is linted with [Rubocop](https://github.com/rubocop/rubocop) + +## :medal_sports: Certificate of Origin + +*Developer's Certificate of Origin 1.1* + +By making a contribution to this project, I certify that: + +> 1. The contribution was created in whole or in part by me and I have the right to submit it under the open source license indicated in the file; or +> 1. The contribution is based upon previous work that, to the best of my knowledge, is covered under an appropriate open source license and I have the right under that license to submit that work with modifications, whether created in whole or in part by me, under the same open source license (unless I am permitted to submit under a different license), as indicated in the file; or +> 1. The contribution was provided directly to me by some other person who certified (1), (2) or (3) and I have not modified it. +> 1. I understand and agree that this project and the contribution are public and that a record of the contribution (including all personal information I submit with it, including my sign-off) is maintained indefinitely and may be redistributed consistent with this project or the open source license(s) involved. + +## [No Brown M&M's](https://en.wikipedia.org/wiki/Van_Halen#Contract_riders) + +If you are reading this, bravo dear user and (hopefully) contributor for making it this far! You are awesome. :100: + +To confirm that you have read this guide and are following it as best as possible, **include this emoji at the top** of your issue or pull request: :pineapple: `:pineapple:` + +## :pray: Credits + +Written by [@jessesquires](https://github.com/jessesquires). Lovingly adapted to ThrowTheSwitch.org by [@mvandervoord](https://github.com/mvandervoord). + +**Please feel free to adopt this guide in your own projects. Fork it wholesale or remix it for your needs.** + +*Many of the ideas and prose for the statements in this document were based on or inspired by work from the following communities:* + +- [Alamofire](https://github.com/Alamofire/Alamofire/blob/master/CONTRIBUTING.md) +- [CocoaPods](https://github.com/CocoaPods/CocoaPods/blob/master/CONTRIBUTING.md) +- [Docker](https://github.com/moby/moby/blob/master/CONTRIBUTING.md) +- [Linux](https://elinux.org/Developer_Certificate_Of_Origin) + +*We commend them for their efforts to facilitate collaboration in their projects.* diff --git a/subprojects/unity/docs/MesonGeneratorRunner.md b/subprojects/unity/docs/MesonGeneratorRunner.md new file mode 100644 index 0000000000..3b81e37827 --- /dev/null +++ b/subprojects/unity/docs/MesonGeneratorRunner.md @@ -0,0 +1,18 @@ +# Meson Generator - Test Runner + +One of the really nice things about using Unity with Ceedling is that Ceedling takes care of generating all of the test runners automatically. If you're not using Ceedling though, you'll need to do this yourself. + +The way this is done in Unity is via a Ruby script called `generate_test_runner.rb`. When given a test file such as `test_example.c`, the script will generate `test_example_Runner.c`, which provides the `main` method and some other useful plumbing. + +So that you don't have to run this by hand, a Meson generator is provided to generate the runner automatically for you. Generally with Meson, you would use Unity as a subproject and you'd want to access the generator from the parent. + +For example, to get the generator you can use: + + unity_proj = subproject('unity') + runner_gen = unity_proj.get_variable('gen_test_runner') + +Once you have the generator you need to pass it the absolute path of your test file. This seems to be a bug in how the paths work with subprojects in Meson. You can get the full path with `meson.source_root()`, so you could do: + + test_runner = meson.source_root() / 'test/test_example.c' + +You can then include `test_runner` as a normal dependency to your builds. Meson will create the test runner in a private directory for each build target. It's only meant to be used as part of the build, so if you need to refer to the runner after the build, you won't be able to use the generator. \ No newline at end of file diff --git a/subprojects/unity/docs/ThrowTheSwitchCodingStandard.md b/subprojects/unity/docs/ThrowTheSwitchCodingStandard.md new file mode 100644 index 0000000000..517b8fb6b6 --- /dev/null +++ b/subprojects/unity/docs/ThrowTheSwitchCodingStandard.md @@ -0,0 +1,187 @@ +# ThrowTheSwitch.org Coding Standard + +Hi. +Welcome to the coding standard for ThrowTheSwitch.org. +For the most part, we try to follow these standards to unify our contributors' code into a cohesive unit (puns intended). +You might find places where these standards aren't followed. +We're not perfect. Please be polite where you notice these discrepancies and we'll try to be polite when we notice yours. + +;) + +## Why Have A Coding Standard? + +Being consistent makes code easier to understand. +We've tried to keep our standard simple because we also believe that we can only expect someone to follow something that is understandable. +Please do your best. + +## Our Philosophy + +Before we get into details on syntax, let's take a moment to talk about our vision for these tools. +We're C developers and embedded software developers. +These tools are great to test any C code, but catering to embedded software made us more tolerant of compiler quirks. +There are a LOT of quirky compilers out there. +By quirky I mean "doesn't follow standards because they feel like they have a license to do as they wish." + +Our philosophy is "support every compiler we can". +Most often, this means that we aim for writing C code that is standards compliant (often C89... that seems to be a sweet spot that is almost always compatible). +But it also means these tools are tolerant of things that aren't common. +Some that aren't even compliant. +There are configuration options to override the size of standard types. +There are configuration options to force Unity to not use certain standard library functions. +A lot of Unity is configurable and we have worked hard to make it not TOO ugly in the process. + +Similarly, our tools that parse C do their best. +They aren't full C parsers (yet) and, even if they were, they would still have to accept non-standard additions like gcc extensions or specifying `@0x1000` to force a variable to compile to a particular location. +It's just what we do, because we like everything to Just Work™. + +Speaking of having things Just Work™, that's our second philosophy. +By that, we mean that we do our best to have EVERY configuration option have a logical default. +We believe that if you're working with a simple compiler and target, you shouldn't need to configure very much... we try to make the tools guess as much as they can, but give the user the power to override it when it's wrong. + +## Naming Things + +Let's talk about naming things. +Programming is all about naming things. +We name files, functions, variables, and so much more. +While we're not always going to find the best name for something, we actually put a bit of effort into finding *What Something WANTS to be Called*™. + +When naming things, we follow this hierarchy, the first being the most important to us (but we do all four when possible): + +1. Readable +2. Descriptive +3. Consistent +4. Memorable + +### Readable + +We want to read our code. +This means we like names and flow that are more naturally read. +We try to avoid double negatives. +We try to avoid cryptic abbreviations (sticking to ones we feel are common). + +### Descriptive + +We like descriptive names for things, especially functions and variables. +Finding the right name for something is an important endeavour. +You might notice from poking around our code that this often results in names that are a little longer than the average. +Guilty. +We're okay with a bit more typing if it means our code is easier to understand. + +There are two exceptions to this rule that we also stick to as religiously as possible: + +First, while we realize hungarian notation (and similar systems for encoding type information into variable names) is providing a more descriptive name, we feel that (for the average developer) it takes away from readability and is to be avoided. + +Second, loop counters and other local throw-away variables often have a purpose which is obvious. +There's no need, therefore, to get carried away with complex naming. +We find i, j, and k are better loop counters than loopCounterVar or whatnot. +We only break this rule when we see that more description could improve understanding of an algorithm. + +### Consistent + +We like consistency, but we're not really obsessed with it. +We try to name our configuration macros in a consistent fashion... you'll notice a repeated use of UNITY_EXCLUDE_BLAH or UNITY_USES_BLAH macros. +This helps users avoid having to remember each macro's details. + +### Memorable + +Where ever it doesn't violate the above principles, we try to apply memorable names. +Sometimes this means using something that is simply descriptive, but often we strive for descriptive AND unique... we like quirky names that stand out in our memory and are easier to search for. +Take a look through the file names in Ceedling and you'll get a good idea of what we are talking about here. +Why use preprocess when you can use preprocessinator? +Or what better describes a module in charge of invoking tasks during releases than release_invoker? +Don't get carried away. +The names are still descriptive and fulfil the above requirements, but they don't feel stale. + +## C and C++ Details + +We don't really want to add to the style battles out there. +Tabs or spaces? +How many spaces? +Where do the braces go? +These are age-old questions that will never be answered... or at least not answered in a way that will make everyone happy. + +We've decided on our own style preferences. +If you'd like to contribute to these projects (and we hope that you do), then we ask if you do your best to follow the same. +It will only hurt a little. We promise. + +### Whitespace in C/C++ + +Our C-style is to use spaces and to use 4 of them per indent level. +It's a nice power-of-2 number that looks decent on a wide-screen. +We have no more reason than that. +We break that rule when we have lines that wrap (macros or function arguments or whatnot). +When that happens, we like to indent further to line things up in nice tidy columns. + +```C + if (stuff_happened) + { + do_something(); + } +``` + +### Case in C/C++ + +- Files - all lower case with underscores. +- Variables - all lower case with underscores +- Macros - all caps with underscores. +- Typedefs - all caps with underscores. (also ends with _T). +- Functions - camel cased. Usually named ModuleName_FuncName +- Constants and Globals - camel cased. + +### Braces in C/C++ + +The left brace is on the next line after the declaration. +The right brace is directly below that. +Everything in between in indented one level. +If you're catching an error and you have a one-line, go ahead and to it on the same line. + +```C + while (blah) + { + //Like so. Even if only one line, we use braces. + } +``` + +### Comments in C/C++ + +Do you know what we hate? +Old-school C block comments. +BUT, we're using them anyway. +As we mentioned, our goal is to support every compiler we can, especially embedded compilers. +There are STILL C compilers out there that only support old-school block comments. +So that is what we're using. +We apologize. +We think they are ugly too. + +## Ruby Details + +Is there really such thing as a Ruby coding standard? +Ruby is such a free form language, it seems almost sacrilegious to suggest that people should comply to one method! +We'll keep it really brief! + +### Whitespace in Ruby + +Our Ruby style is to use spaces and to use 2 of them per indent level. +It's a nice power-of-2 number that really grooves with Ruby's compact style. +We have no more reason than that. +We break that rule when we have lines that wrap. +When that happens, we like to indent further to line things up in nice tidy columns. + +### Case in Ruby + +- Files - all lower case with underscores. +- Variables - all lower case with underscores +- Classes, Modules, etc - Camel cased. +- Functions - all lower case with underscores +- Constants - all upper case with underscores + +## Documentation + +Egad. +Really? +We use markdown and we like PDF files because they can be made to look nice while still being portable. +Good enough? + +*Find The Latest of This And More at [ThrowTheSwitch.org][]* + +[ThrowTheSwitch.org]: https://throwtheswitch.org \ No newline at end of file diff --git a/subprojects/unity/docs/UnityAssertionsCheatSheetSuitableforPrintingandPossiblyFraming.pdf b/subprojects/unity/docs/UnityAssertionsCheatSheetSuitableforPrintingandPossiblyFraming.pdf new file mode 100644 index 0000000000000000000000000000000000000000..28f0c32144c4f2b55ff07007555e5777480320ac GIT binary patch literal 144467 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 literal 0 HcmV?d00001 diff --git a/subprojects/unity/docs/UnityAssertionsReference.md b/subprojects/unity/docs/UnityAssertionsReference.md new file mode 100644 index 0000000000..0a0e51b65b --- /dev/null +++ b/subprojects/unity/docs/UnityAssertionsReference.md @@ -0,0 +1,860 @@ +# Unity Assertions Reference + +## Background and Overview + +### Super Condensed Version + +- An assertion establishes truth (i.e. boolean True) for a single condition. +Upon boolean False, an assertion stops execution and reports the failure. +- Unity is mainly a rich collection of assertions and the support to gather up +and easily execute those assertions. +- The structure of Unity allows you to easily separate test assertions from +source code in, well, test code. +- Unity’s assertions: + - Come in many, many flavors to handle different C types and assertion cases. + - Use context to provide detailed and helpful failure messages. + - Document types, expected values, and basic behavior in your source code for +free. + +### Unity Is Several Things But Mainly It’s Assertions + +One way to think of Unity is simply as a rich collection of assertions you can +use to establish whether your source code behaves the way you think it does. +Unity provides a framework to easily organize and execute those assertions in +test code separate from your source code. + +### What’s an Assertion? + +At their core, assertions are an establishment of truth - boolean truth. Was this +thing equal to that thing? Does that code doohickey have such-and-such property +or not? You get the idea. Assertions are executable code. Static analysis is a +valuable approach to improving code quality, but it is not executing your code +in the way an assertion can. A failing assertion stops execution and reports an +error through some appropriate I/O channel (e.g. stdout, GUI, output file, +blinky light). + +Fundamentally, for dynamic verification all you need is a single assertion +mechanism. In fact, that’s what the [assert() macro][] in C’s standard library +is for. So why not just use it? Well, we can do far better in the reporting +department. C’s `assert()` is pretty dumb as-is and is particularly poor for +handling common data types like arrays, structs, etc. And, without some other +support, it’s far too tempting to litter source code with C’s `assert()`’s. It’s +generally much cleaner, manageable, and more useful to separate test and source +code in the way Unity facilitates. + +### Unity’s Assertions: Helpful Messages _and_ Free Source Code Documentation + +Asserting a simple truth condition is valuable, but using the context of the +assertion is even more valuable. For instance, if you know you’re comparing bit +flags and not just integers, then why not use that context to give explicit, +readable, bit-level feedback when an assertion fails? + +That’s what Unity’s collection of assertions do - capture context to give you +helpful, meaningful assertion failure messages. In fact, the assertions +themselves also serve as executable documentation about types and values in your +source code. So long as your tests remain current with your source and all those +tests pass, you have a detailed, up-to-date view of the intent and mechanisms in +your source code. And due to a wondrous mystery, well-tested code usually tends +to be well designed code. + +## Assertion Conventions and Configurations + +### Naming and Parameter Conventions + +The convention of assertion parameters generally follows this order: + +```c +TEST_ASSERT_X( {modifiers}, {expected}, actual, {size/count} ) +``` + +The very simplest assertion possible uses only a single `actual` parameter (e.g. +a simple null check). + +- `Actual` is the value being tested and unlike the other parameters in an + assertion construction is the only parameter present in all assertion variants. +- `Modifiers` are masks, ranges, bit flag specifiers, floating point deltas. +- `Expected` is your expected value (duh) to compare to an `actual` value; it’s + marked as an optional parameter because some assertions only need a single + `actual` parameter (e.g. null check). +- `Size/count` refers to string lengths, number of array elements, etc. + +Many of Unity’s assertions are clear duplications in that the same data type +is handled by several assertions. The differences among these are in how failure +messages are presented. For instance, a `_HEX` variant of an assertion prints +the expected and actual values of that assertion formatted as hexadecimal. + +#### TEST_ASSERT_X_MESSAGE Variants + +_All_ assertions are complemented with a variant that includes a simple string +message as a final parameter. The string you specify is appended to an assertion +failure message in Unity output. + +For brevity, the assertion variants with a message parameter are not listed +below. Just tack on `_MESSAGE` as the final component to any assertion name in +the reference list below and add a string as the final parameter. + +_Example:_ + +```c +TEST_ASSERT_X( {modifiers}, {expected}, actual, {size/count} ) +``` + +becomes messageified like thus… + +```c +TEST_ASSERT_X_MESSAGE( {modifiers}, {expected}, actual, {size/count}, message ) +``` + +Notes: + +- The `_MESSAGE` variants intentionally do not support `printf` style formatting + since many embedded projects don’t support or avoid `printf` for various reasons. + It is possible to use `sprintf` before the assertion to assemble a complex fail + message, if necessary. +- If you want to output a counter value within an assertion fail message (e.g. from + a loop) , building up an array of results and then using one of the `_ARRAY` + assertions (see below) might be a handy alternative to `sprintf`. + +#### TEST_ASSERT_X_ARRAY Variants + +Unity provides a collection of assertions for arrays containing a variety of +types. These are documented in the Array section below. These are almost on par +with the `_MESSAGE`variants of Unity’s Asserts in that for pretty much any Unity +type assertion you can tack on `_ARRAY` and run assertions on an entire block of +memory. + +```c + TEST_ASSERT_EQUAL_TYPEX_ARRAY( expected, actual, {size/count} ) +``` + +- `Expected` is an array itself. +- `Size/count` is one or two parameters necessary to establish the number of array + elements and perhaps the length of elements within the array. + +Notes: + +- The `_MESSAGE` variant convention still applies here to array assertions. The + `_MESSAGE` variants of the `_ARRAY` assertions have names ending with + `_ARRAY_MESSAGE`. +- Assertions for handling arrays of floating point values are grouped with float + and double assertions (see immediately following section). + +### TEST_ASSERT_EACH_EQUAL_X Variants + +Unity provides a collection of assertions for arrays containing a variety of +types which can be compared to a single value as well. These are documented in +the Each Equal section below. these are almost on par with the `_MESSAGE` +variants of Unity’s Asserts in that for pretty much any Unity type assertion you +can inject `_EACH_EQUAL` and run assertions on an entire block of memory. + +```c +TEST_ASSERT_EACH_EQUAL_TYPEX( expected, actual, {size/count} ) +``` + +- `Expected` is a single value to compare to. +- `Actual` is an array where each element will be compared to the expected value. +- `Size/count` is one of two parameters necessary to establish the number of array + elements and perhaps the length of elements within the array. + +Notes: + +- The `_MESSAGE` variant convention still applies here to Each Equal assertions. +- Assertions for handling Each Equal of floating point values are grouped with + float and double assertions (see immediately following section). + +### Configuration + +#### Floating Point Support Is Optional + +Support for floating point types is configurable. That is, by defining the +appropriate preprocessor symbols, floats and doubles can be individually enabled +or disabled in Unity code. This is useful for embedded targets with no floating +point math support (i.e. Unity compiles free of errors for fixed point only +platforms). See Unity documentation for specifics. + +#### Maximum Data Type Width Is Configurable + +Not all targets support 64 bit wide types or even 32 bit wide types. Define the +appropriate preprocessor symbols and Unity will omit all operations from +compilation that exceed the maximum width of your target. See Unity +documentation for specifics. + +## The Assertions in All Their Blessed Glory + +### Basic Fail, Pass and Ignore + +#### `TEST_FAIL()` + +#### `TEST_FAIL_MESSAGE("message")` + +This fella is most often used in special conditions where your test code is +performing logic beyond a simple assertion. That is, in practice, `TEST_FAIL()` +will always be found inside a conditional code block. + +_Examples:_ + +- Executing a state machine multiple times that increments a counter your test +code then verifies as a final step. +- Triggering an exception and verifying it (as in Try / Catch / Throw - see the +[CException](https://github.com/ThrowTheSwitch/CException) project). + +#### `TEST_PASS()` + +#### `TEST_PASS_MESSAGE("message")` + +This will abort the remainder of the test, but count the test as a pass. Under +normal circumstances, it is not necessary to include this macro in your tests… +a lack of failure will automatically be counted as a `PASS`. It is occasionally +useful for tests with `#ifdef`s and such. + +#### `TEST_IGNORE()` + +#### `TEST_IGNORE_MESSAGE("message")` + +Marks a test case (i.e. function meant to contain test assertions) as ignored. +Usually this is employed as a breadcrumb to come back and implement a test case. +An ignored test case has effects if other assertions are in the enclosing test +case (see Unity documentation for more). + +#### `TEST_MESSAGE(message)` + +This can be useful for outputting `INFO` messages into the Unity output stream +without actually ending the test. Like pass and fail messages, it will be output +with the filename and line number. + +### Boolean + +#### `TEST_ASSERT (condition)` + +#### `TEST_ASSERT_TRUE (condition)` + +#### `TEST_ASSERT_FALSE (condition)` + +#### `TEST_ASSERT_UNLESS (condition)` + +A simple wording variation on `TEST_ASSERT_FALSE`.The semantics of +`TEST_ASSERT_UNLESS` aid readability in certain test constructions or +conditional statements. + +#### `TEST_ASSERT_NULL (pointer)` + +#### `TEST_ASSERT_NOT_NULL (pointer)` + +Verify if a pointer is or is not NULL. + +#### `TEST_ASSERT_EMPTY (pointer)` + +#### `TEST_ASSERT_NOT_EMPTY (pointer)` + +Verify if the first element dereferenced from a pointer is or is not zero. This +is particularly useful for checking for empty (or non-empty) null-terminated +C strings, but can be just as easily used for other null-terminated arrays. + +### Signed and Unsigned Integers (of all sizes) + +Large integer sizes can be disabled for build targets that do not support them. +For example, if your target only supports up to 16 bit types, by defining the +appropriate symbols Unity can be configured to omit 32 and 64 bit operations +that would break compilation (see Unity documentation for more). Refer to +Advanced Asserting later in this document for advice on dealing with other word +sizes. + +#### `TEST_ASSERT_EQUAL_INT (expected, actual)` + +#### `TEST_ASSERT_EQUAL_INT8 (expected, actual)` + +#### `TEST_ASSERT_EQUAL_INT16 (expected, actual)` + +#### `TEST_ASSERT_EQUAL_INT32 (expected, actual)` + +#### `TEST_ASSERT_EQUAL_INT64 (expected, actual)` + +#### `TEST_ASSERT_EQUAL_UINT (expected, actual)` + +#### `TEST_ASSERT_EQUAL_UINT8 (expected, actual)` + +#### `TEST_ASSERT_EQUAL_UINT16 (expected, actual)` + +#### `TEST_ASSERT_EQUAL_UINT32 (expected, actual)` + +#### `TEST_ASSERT_EQUAL_UINT64 (expected, actual)` + +### Unsigned Integers (of all sizes) in Hexadecimal + +All `_HEX` assertions are identical in function to unsigned integer assertions +but produce failure messages with the `expected` and `actual` values formatted +in hexadecimal. Unity output is big endian. + +#### `TEST_ASSERT_EQUAL_HEX (expected, actual)` + +#### `TEST_ASSERT_EQUAL_HEX8 (expected, actual)` + +#### `TEST_ASSERT_EQUAL_HEX16 (expected, actual)` + +#### `TEST_ASSERT_EQUAL_HEX32 (expected, actual)` + +#### `TEST_ASSERT_EQUAL_HEX64 (expected, actual)` + +### Characters + +While you can use the 8-bit integer assertions to compare `char`, another option is +to use this specialized assertion which will show printable characters as printables, +otherwise showing the HEX escape code for the characters. + +#### `TEST_ASSERT_EQUAL_CHAR (expected, actual)` + +### Masked and Bit-level Assertions + +Masked and bit-level assertions produce output formatted in hexadecimal. Unity +output is big endian. + +#### `TEST_ASSERT_BITS (mask, expected, actual)` + +Only compares the masked (i.e. high) bits of `expected` and `actual` parameters. + +#### `TEST_ASSERT_BITS_HIGH (mask, actual)` + +Asserts the masked bits of the `actual` parameter are high. + +#### `TEST_ASSERT_BITS_LOW (mask, actual)` + +Asserts the masked bits of the `actual` parameter are low. + +#### `TEST_ASSERT_BIT_HIGH (bit, actual)` + +Asserts the specified bit of the `actual` parameter is high. + +#### `TEST_ASSERT_BIT_LOW (bit, actual)` + +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. There are assertions for +all the various sizes of ints, as for the equality assertions. Some examples: + +#### `TEST_ASSERT_GREATER_THAN_INT8 (threshold, actual)` + +#### `TEST_ASSERT_GREATER_OR_EQUAL_INT16 (threshold, actual)` + +#### `TEST_ASSERT_LESS_THAN_INT32 (threshold, actual)` + +#### `TEST_ASSERT_LESS_OR_EQUAL_UINT (threshold, actual)` + +#### `TEST_ASSERT_NOT_EQUAL_UINT8 (threshold, actual)` + +### Integer Ranges (of all sizes) + +These assertions verify that the `expected` parameter is within +/- `delta` +(inclusive) of the `actual` parameter. For example, if the expected value is 10 +and the delta is 3 then the assertion will fail for any value outside the range +of 7 - 13. + +#### `TEST_ASSERT_INT_WITHIN (delta, expected, actual)` + +#### `TEST_ASSERT_INT8_WITHIN (delta, expected, actual)` + +#### `TEST_ASSERT_INT16_WITHIN (delta, expected, actual)` + +#### `TEST_ASSERT_INT32_WITHIN (delta, expected, actual)` + +#### `TEST_ASSERT_INT64_WITHIN (delta, expected, actual)` + +#### `TEST_ASSERT_UINT_WITHIN (delta, expected, actual)` + +#### `TEST_ASSERT_UINT8_WITHIN (delta, expected, actual)` + +#### `TEST_ASSERT_UINT16_WITHIN (delta, expected, actual)` + +#### `TEST_ASSERT_UINT32_WITHIN (delta, expected, actual)` + +#### `TEST_ASSERT_UINT64_WITHIN (delta, expected, actual)` + +#### `TEST_ASSERT_HEX_WITHIN (delta, expected, actual)` + +#### `TEST_ASSERT_HEX8_WITHIN (delta, expected, actual)` + +#### `TEST_ASSERT_HEX16_WITHIN (delta, expected, actual)` + +#### `TEST_ASSERT_HEX32_WITHIN (delta, expected, actual)` + +#### `TEST_ASSERT_HEX64_WITHIN (delta, expected, actual)` + +#### `TEST_ASSERT_CHAR_WITHIN (delta, expected, actual)` + +### Structs and Strings + +#### `TEST_ASSERT_EQUAL_PTR (expected, actual)` + +Asserts that the pointers point to the same memory location. + +#### `TEST_ASSERT_EQUAL_STRING (expected, actual)` + +Asserts that the null terminated (`’\0’`)strings are identical. If strings are +of different lengths or any portion of the strings before their terminators +differ, the assertion fails. Two NULL strings (i.e. zero length) are considered +equivalent. + +#### `TEST_ASSERT_EQUAL_MEMORY (expected, actual, len)` + +Asserts that the contents of the memory specified by the `expected` and `actual` +pointers is identical. The size of the memory blocks in bytes is specified by +the `len` parameter. + +### Arrays + +`expected` and `actual` parameters are both arrays. `num_elements` specifies the +number of elements in the arrays to compare. + +`_HEX` assertions produce failure messages with expected and actual array +contents formatted in hexadecimal. + +For array of strings comparison behavior, see comments for +`TEST_ASSERT_EQUAL_STRING` in the preceding section. + +Assertions fail upon the first element in the compared arrays found not to +match. Failure messages specify the array index of the failed comparison. + +#### `TEST_ASSERT_EQUAL_INT_ARRAY (expected, actual, num_elements)` + +#### `TEST_ASSERT_EQUAL_INT8_ARRAY (expected, actual, num_elements)` + +#### `TEST_ASSERT_EQUAL_INT16_ARRAY (expected, actual, num_elements)` + +#### `TEST_ASSERT_EQUAL_INT32_ARRAY (expected, actual, num_elements)` + +#### `TEST_ASSERT_EQUAL_INT64_ARRAY (expected, actual, num_elements)` + +#### `TEST_ASSERT_EQUAL_UINT_ARRAY (expected, actual, num_elements)` + +#### `TEST_ASSERT_EQUAL_UINT8_ARRAY (expected, actual, num_elements)` + +#### `TEST_ASSERT_EQUAL_UINT16_ARRAY (expected, actual, num_elements)` + +#### `TEST_ASSERT_EQUAL_UINT32_ARRAY (expected, actual, num_elements)` + +#### `TEST_ASSERT_EQUAL_UINT64_ARRAY (expected, actual, num_elements)` + +#### `TEST_ASSERT_EQUAL_HEX_ARRAY (expected, actual, num_elements)` + +#### `TEST_ASSERT_EQUAL_HEX8_ARRAY (expected, actual, num_elements)` + +#### `TEST_ASSERT_EQUAL_HEX16_ARRAY (expected, actual, num_elements)` + +#### `TEST_ASSERT_EQUAL_HEX32_ARRAY (expected, actual, num_elements)` + +#### `TEST_ASSERT_EQUAL_HEX64_ARRAY (expected, actual, num_elements)` + +#### `TEST_ASSERT_EQUAL_CHAR_ARRAY (expected, actual, num_elements)` + +#### `TEST_ASSERT_EQUAL_PTR_ARRAY (expected, actual, num_elements)` + +#### `TEST_ASSERT_EQUAL_STRING_ARRAY (expected, actual, num_elements)` + +#### `TEST_ASSERT_EQUAL_MEMORY_ARRAY (expected, actual, len, num_elements)` + +`len` is the memory in bytes to be compared at each array element. + +### Integer Array Ranges (of all sizes) + +These assertions verify that the `expected` array parameter is within +/- `delta` +(inclusive) of the `actual` array parameter. For example, if the expected value is +\[10, 12\] and the delta is 3 then the assertion will fail for any value +outside the range of \[7 - 13, 9 - 15\]. + +#### `TEST_ASSERT_INT_ARRAY_WITHIN (delta, expected, actual, num_elements)` + +#### `TEST_ASSERT_INT8_ARRAY_WITHIN (delta, expected, actual, num_elements)` + +#### `TEST_ASSERT_INT16_ARRAY_WITHIN (delta, expected, actual, num_elements)` + +#### `TEST_ASSERT_INT32_ARRAY_WITHIN (delta, expected, actual, num_elements)` + +#### `TEST_ASSERT_INT64_ARRAY_WITHIN (delta, expected, actual, num_elements)` + +#### `TEST_ASSERT_UINT_ARRAY_WITHIN (delta, expected, actual, num_elements)` + +#### `TEST_ASSERT_UINT8_ARRAY_WITHIN (delta, expected, actual, num_elements)` + +#### `TEST_ASSERT_UINT16_ARRAY_WITHIN (delta, expected, actual, num_elements)` + +#### `TEST_ASSERT_UINT32_ARRAY_WITHIN (delta, expected, actual, num_elements)` + +#### `TEST_ASSERT_UINT64_ARRAY_WITHIN (delta, expected, actual, num_elements)` + +#### `TEST_ASSERT_HEX_ARRAY_WITHIN (delta, expected, actual, num_elements)` + +#### `TEST_ASSERT_HEX8_ARRAY_WITHIN (delta, expected, actual, num_elements)` + +#### `TEST_ASSERT_HEX16_ARRAY_WITHIN (delta, expected, actual, num_elements)` + +#### `TEST_ASSERT_HEX32_ARRAY_WITHIN (delta, expected, actual, num_elements)` + +#### `TEST_ASSERT_HEX64_ARRAY_WITHIN (delta, expected, actual, num_elements)` + +#### `TEST_ASSERT_CHAR_ARRAY_WITHIN (delta, expected, actual, num_elements)` + +### Each Equal (Arrays to Single Value) + +`expected` are single values and `actual` are arrays. `num_elements` specifies +the number of elements in the arrays to compare. + +`_HEX` assertions produce failure messages with expected and actual array +contents formatted in hexadecimal. + +Assertions fail upon the first element in the compared arrays found not to +match. Failure messages specify the array index of the failed comparison. + +#### `TEST_ASSERT_EACH_EQUAL_INT (expected, actual, num_elements)` + +#### `TEST_ASSERT_EACH_EQUAL_INT8 (expected, actual, num_elements)` + +#### `TEST_ASSERT_EACH_EQUAL_INT16 (expected, actual, num_elements)` + +#### `TEST_ASSERT_EACH_EQUAL_INT32 (expected, actual, num_elements)` + +#### `TEST_ASSERT_EACH_EQUAL_INT64 (expected, actual, num_elements)` + +#### `TEST_ASSERT_EACH_EQUAL_UINT (expected, actual, num_elements)` + +#### `TEST_ASSERT_EACH_EQUAL_UINT8 (expected, actual, num_elements)` + +#### `TEST_ASSERT_EACH_EQUAL_UINT16 (expected, actual, num_elements)` + +#### `TEST_ASSERT_EACH_EQUAL_UINT32 (expected, actual, num_elements)` + +#### `TEST_ASSERT_EACH_EQUAL_UINT64 (expected, actual, num_elements)` + +#### `TEST_ASSERT_EACH_EQUAL_HEX (expected, actual, num_elements)` + +#### `TEST_ASSERT_EACH_EQUAL_HEX8 (expected, actual, num_elements)` + +#### `TEST_ASSERT_EACH_EQUAL_HEX16 (expected, actual, num_elements)` + +#### `TEST_ASSERT_EACH_EQUAL_HEX32 (expected, actual, num_elements)` + +#### `TEST_ASSERT_EACH_EQUAL_HEX64 (expected, actual, num_elements)` + +#### `TEST_ASSERT_EACH_EQUAL_CHAR (expected, actual, num_elements)` + +#### `TEST_ASSERT_EACH_EQUAL_PTR (expected, actual, num_elements)` + +#### `TEST_ASSERT_EACH_EQUAL_STRING (expected, actual, num_elements)` + +#### `TEST_ASSERT_EACH_EQUAL_MEMORY (expected, actual, len, num_elements)` + +`len` is the memory in bytes to be compared at each array element. + +### Floating Point (If enabled) + +#### `TEST_ASSERT_FLOAT_WITHIN (delta, expected, actual)` + +Asserts that the `actual` value is within +/- `delta` of the `expected` value. +The nature of floating point representation is such that exact evaluations of +equality are not guaranteed. + +#### `TEST_ASSERT_FLOAT_NOT_WITHIN (delta, expected, actual)` + +Asserts that the `actual` value is NOT within +/- `delta` of the `expected` value. + +#### `TEST_ASSERT_EQUAL_FLOAT (expected, actual)` + +Asserts that the `actual` value is “close enough to be considered equal” to the +`expected` value. If you are curious about the details, refer to the Advanced +Asserting section for more details on this. Omitting a user-specified delta in a +floating point assertion is both a shorthand convenience and a requirement of +code generation conventions for CMock. + +#### `TEST_ASSERT_NOT_EQUAL_FLOAT (expected, actual)` + +Asserts that the `actual` value is NOT “close enough to be considered equal” to the +`expected` value. + +#### `TEST_ASSERT_FLOAT_ARRAY_WITHIN (delta, expected, actual, num_elements)` + +See Array assertion section for details. Note that individual array element +uses user-provided delta plus default comparison delta for checking +and is based on `TEST_ASSERT_FLOAT_WITHIN` comparison. + +#### `TEST_ASSERT_EQUAL_FLOAT_ARRAY (expected, actual, num_elements)` + +See Array assertion section for details. Note that individual array element +float comparisons are executed using `TEST_ASSERT_EQUAL_FLOAT`. That is, user +specified delta comparison values requires a custom-implemented floating point +array assertion. + +#### `TEST_ASSERT_LESS_THAN_FLOAT (threshold, actual)` + +Asserts that the `actual` parameter is less than `threshold` (exclusive). +For example, if the threshold value is 1.0f, the assertion will fail if it is +greater than 1.0f. + +#### `TEST_ASSERT_GREATER_THAN_FLOAT (threshold, actual)` + +Asserts that the `actual` parameter is greater than `threshold` (exclusive). +For example, if the threshold value is 1.0f, the assertion will fail if it is +less than 1.0f. + +#### `TEST_ASSERT_LESS_OR_EQUAL_FLOAT (threshold, actual)` + +Asserts that the `actual` parameter is less than or equal to `threshold`. +The rules for equality are the same as for `TEST_ASSERT_EQUAL_FLOAT`. + +#### `TEST_ASSERT_GREATER_OR_EQUAL_FLOAT (threshold, actual)` + +Asserts that the `actual` parameter is greater than `threshold`. +The rules for equality are the same as for `TEST_ASSERT_EQUAL_FLOAT`. + +#### `TEST_ASSERT_FLOAT_IS_INF (actual)` + +Asserts that `actual` parameter is equivalent to positive infinity floating +point representation. + +#### `TEST_ASSERT_FLOAT_IS_NEG_INF (actual)` + +Asserts that `actual` parameter is equivalent to negative infinity floating +point representation. + +#### `TEST_ASSERT_FLOAT_IS_NAN (actual)` + +Asserts that `actual` parameter is a Not A Number floating point representation. + +#### `TEST_ASSERT_FLOAT_IS_DETERMINATE (actual)` + +Asserts that `actual` parameter is a floating point representation usable for +mathematical operations. That is, the `actual` parameter is neither positive +infinity nor negative infinity nor Not A Number floating point representations. + +#### `TEST_ASSERT_FLOAT_IS_NOT_INF (actual)` + +Asserts that `actual` parameter is a value other than positive infinity floating +point representation. + +#### `TEST_ASSERT_FLOAT_IS_NOT_NEG_INF (actual)` + +Asserts that `actual` parameter is a value other than negative infinity floating +point representation. + +#### `TEST_ASSERT_FLOAT_IS_NOT_NAN (actual)` + +Asserts that `actual` parameter is a value other than Not A Number floating +point representation. + +#### `TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE (actual)` + +Asserts that `actual` parameter is not usable for mathematical operations. That +is, the `actual` parameter is either positive infinity or negative infinity or +Not A Number floating point representations. + +### Double (If enabled) + +#### `TEST_ASSERT_DOUBLE_WITHIN (delta, expected, actual)` + +Asserts that the `actual` value is within +/- `delta` of the `expected` value. +The nature of floating point representation is such that exact evaluations of +equality are not guaranteed. + +#### `TEST_ASSERT_DOUBLE_NOT_WITHIN (delta, expected, actual)` + +Asserts that the `actual` value is NOT within +/- `delta` of the `expected` value. + +#### `TEST_ASSERT_EQUAL_DOUBLE (expected, actual)` + +Asserts that the `actual` value is “close enough to be considered equal” to the +`expected` value. If you are curious about the details, refer to the Advanced +Asserting section for more details. Omitting a user-specified delta in a +floating point assertion is both a shorthand convenience and a requirement of +code generation conventions for CMock. + +#### `TEST_ASSERT_NOT_EQUAL_DOUBLE (expected, actual)` + +Asserts that the `actual` value is NOT “close enough to be considered equal” to the +`expected` value. + +#### `TEST_ASSERT_DOUBLE_ARRAY_WITHIN (delta, expected, actual, num_elements)` + +See Array assertion section for details. Note that individual array element +uses user-provided delta plus default comparison delta for checking +and is based on `TEST_ASSERT_DOUBLE_WITHIN` comparison. + +#### `TEST_ASSERT_EQUAL_DOUBLE_ARRAY (expected, actual, num_elements)` + +See Array assertion section for details. Note that individual array element +double comparisons are executed using `TEST_ASSERT_EQUAL_DOUBLE`. That is, user +specified delta comparison values requires a custom implemented double array +assertion. + +#### `TEST_ASSERT_LESS_THAN_DOUBLE (threshold, actual)` + +Asserts that the `actual` parameter is less than `threshold` (exclusive). +For example, if the threshold value is 1.0, the assertion will fail if it is +greater than 1.0. + +#### `TEST_ASSERT_LESS_OR_EQUAL_DOUBLE (threshold, actual)` + +Asserts that the `actual` parameter is less than or equal to `threshold`. +The rules for equality are the same as for `TEST_ASSERT_EQUAL_DOUBLE`. + +#### `TEST_ASSERT_GREATER_THAN_DOUBLE (threshold, actual)` + +Asserts that the `actual` parameter is greater than `threshold` (exclusive). +For example, if the threshold value is 1.0, the assertion will fail if it is +less than 1.0. + +#### `TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE (threshold, actual)` + +Asserts that the `actual` parameter is greater than or equal to `threshold`. +The rules for equality are the same as for `TEST_ASSERT_EQUAL_DOUBLE`. + +#### `TEST_ASSERT_DOUBLE_IS_INF (actual)` + +Asserts that `actual` parameter is equivalent to positive infinity floating +point representation. + +#### `TEST_ASSERT_DOUBLE_IS_NEG_INF (actual)` + +Asserts that `actual` parameter is equivalent to negative infinity floating point +representation. + +#### `TEST_ASSERT_DOUBLE_IS_NAN (actual)` + +Asserts that `actual` parameter is a Not A Number floating point representation. + +#### `TEST_ASSERT_DOUBLE_IS_DETERMINATE (actual)` + +Asserts that `actual` parameter is a floating point representation usable for +mathematical operations. That is, the `actual` parameter is neither positive +infinity nor negative infinity nor Not A Number floating point representations. + +#### `TEST_ASSERT_DOUBLE_IS_NOT_INF (actual)` + +Asserts that `actual` parameter is a value other than positive infinity floating +point representation. + +#### `TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF (actual)` + +Asserts that `actual` parameter is a value other than negative infinity floating +point representation. + +#### `TEST_ASSERT_DOUBLE_IS_NOT_NAN (actual)` + +Asserts that `actual` parameter is a value other than Not A Number floating +point representation. + +#### `TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE (actual)` + +Asserts that `actual` parameter is not usable for mathematical operations. That +is, the `actual` parameter is either positive infinity or negative infinity or +Not A Number floating point representations. + +## Advanced Asserting: Details On Tricky Assertions + +This section helps you understand how to deal with some of the trickier +assertion situations you may run into. It will give you a glimpse into some of +the under-the-hood details of Unity’s assertion mechanisms. If you’re one of +those people who likes to know what is going on in the background, read on. If +not, feel free to ignore the rest of this document until you need it. + +### How do the EQUAL assertions work for FLOAT and DOUBLE? + +As you may know, directly checking for equality between a pair of floats or a +pair of doubles is sloppy at best and an outright no-no at worst. Floating point +values can often be represented in multiple ways, particularly after a series of +operations on a value. Initializing a variable to the value of 2.0 is likely to +result in a floating point representation of 2 x 20,but a series of +mathematical operations might result in a representation of 8 x 2-2 +that also evaluates to a value of 2. At some point repeated operations cause +equality checks to fail. + +So Unity doesn’t do direct floating point comparisons for equality. Instead, it +checks if two floating point values are “really close.” If you leave Unity +running with defaults, “really close” means “within a significant bit or two.” +Under the hood, `TEST_ASSERT_EQUAL_FLOAT` is really `TEST_ASSERT_FLOAT_WITHIN` +with the `delta` parameter calculated on the fly. For single precision, delta is +the expected value multiplied by 0.00001, producing a very small proportional +range around the expected value. + +If you are expecting a value of 20,000.0 the delta is calculated to be 0.2. So +any value between 19,999.8 and 20,000.2 will satisfy the equality check. This +works out to be roughly a single bit of range for a single-precision number, and +that’s just about as tight a tolerance as you can reasonably get from a floating +point value. + +So what happens when it’s zero? Zero - even more than other floating point +values - can be represented many different ways. It doesn’t matter if you have +0x20 or 0x263. It’s still zero, right? Luckily, if you subtract these +values from each other, they will always produce a difference of zero, which +will still fall between 0 plus or minus a delta of 0. So it still works! + +Double precision floating point numbers use a much smaller multiplier, again +approximating a single bit of error. + +If you don’t like these ranges and you want to make your floating point equality +assertions less strict, you can change these multipliers to whatever you like by +defining UNITY_FLOAT_PRECISION and UNITY_DOUBLE_PRECISION. See Unity +documentation for more. + +### How do we deal with targets with non-standard int sizes? + +It’s “fun” that C is a standard where something as fundamental as an integer +varies by target. According to the C standard, an `int` is to be the target’s +natural register size, and it should be at least 16-bits and a multiple of a +byte. It also guarantees an order of sizes: + +```C +char <= short <= int <= long <= long long +``` + +Most often, `int` is 32-bits. In many cases in the embedded world, `int` is +16-bits. There are rare microcontrollers out there that have 24-bit integers, +and this remains perfectly standard C. + +To make things even more interesting, there are compilers and targets out there +that have a hard choice to make. What if their natural register size is 10-bits +or 12-bits? Clearly they can’t fulfill _both_ the requirement to be at least +16-bits AND the requirement to match the natural register size. In these +situations, they often choose the natural register size, leaving us with +something like this: + +```C +char (8 bit) <= short (12 bit) <= int (12 bit) <= long (16 bit) +``` + +Um… yikes. It’s obviously breaking a rule or two… but they had to break SOME +rules, so they made a choice. + +When the C99 standard rolled around, it introduced alternate standard-size types. +It also introduced macros for pulling in MIN/MAX values for your integer types. +It’s glorious! Unfortunately, many embedded compilers can’t be relied upon to +use the C99 types (Sometimes because they have weird register sizes as described +above. Sometimes because they don’t feel like it?). + +A goal of Unity from the beginning was to support every combination of +microcontroller or microprocessor and C compiler. Over time, we’ve gotten really +close to this. There are a few tricks that you should be aware of, though, if +you’re going to do this effectively on some of these more idiosyncratic targets. + +First, when setting up Unity for a new target, you’re going to want to pay +special attention to the macros for automatically detecting types +(where available) or manually configuring them yourself. You can get information +on both of these in Unity’s documentation. + +What about the times where you suddenly need to deal with something odd, like a +24-bit `int`? The simplest solution is to use the next size up. If you have a +24-bit `int`, configure Unity to use 32-bit integers. If you have a 12-bit +`int`, configure Unity to use 16 bits. There are two ways this is going to +affect you: + +1. When Unity displays errors for you, it’s going to pad the upper unused bits + with zeros. +2. You’re going to have to be careful of assertions that perform signed + operations, particularly `TEST_ASSERT_INT_WITHIN`. Such assertions might wrap + your `int` in the wrong place, and you could experience false failures. You can + always back down to a simple `TEST_ASSERT` and do the operations yourself. + +*Find The Latest of This And More at [ThrowTheSwitch.org][]* + +[assert() macro]: http://en.wikipedia.org/wiki/Assert.h +[ThrowTheSwitch.org]: https://throwtheswitch.org diff --git a/subprojects/unity/docs/UnityChangeLog.md b/subprojects/unity/docs/UnityChangeLog.md new file mode 100644 index 0000000000..a9fec00f92 --- /dev/null +++ b/subprojects/unity/docs/UnityChangeLog.md @@ -0,0 +1,110 @@ +# Unity Test - Change Log + +## A Note + +This document captures significant features and fixes to the Unity project core source files +and scripts. More detail can be found in the history on Github. + +This project is now tracking changes in more detail. Previous releases get less detailed as +we move back in histroy. + +Prior to 2012, the project was hosted on SourceForge.net +Prior to 2008, the project was an internal project and not released to the public. + +## Log + +### Unity 2.6.1 (Jan 2025) + +New Features: + + - Add `-n` comand line option as strict matcher again + +Significant Bugfixes: + + - Protect against problems when mis-matched command line options selected + +Other: + + - Protect against Conversion warnings in gcc + - Remove Redundant line-casts + - Make more internal functions static + +### Unity 2.6.0 (Mar 2024) + +New Features: + + - Fill out missing variations of arrays, within, etc. + - Add `TEST_PRINTF()` + - Add `TEST_MATRIX()` and `TEST_RANGE()` options and documentation + - Add support for searching `TEST_SOURCE_FILE()` for determining test dependencies + - Add Unity BDD plugin + - Add `UNITY_INCLUDE_EXEC_TIME` option to report test times + - Allow user to override test abort underlying mechanism + - Add `NOT_EQUAL*` and `NOT_WITHIN*` checks for floats and doubles + +Significant Bugfixes: + + - More portable validation of NaN and Infinity. Added `UNITY_IS_NAN` and `UNITY_IS_INF` options + - Add `UNITY_PROGMEM` configuration option + - Fix overflow detection of hex values when using arrays + - Fix scripts broken by Ruby standard changes + +Other: + + - Avoid pointer comparison when one is null to avoid compiler warnings + - Significant improvements to documentation + - Updates to match latest Ruby style specification + - Meson, CMake, PlatformIO builds + +### Unity 2.5.2 (January 2021) + + - improvements to RUN_TEST macro and generated RUN_TEST + - Fix `UNITY_TEST_ASSERT_BIT(S)_HIGH` + - Cleaner handling of details tracking by CMock + +### Unity 2.5.1 (May 2020) + +Mostly a bugfix and stability release. +Bonus Features: + + - Optional TEST_PRINTF macro + - Improve self-testing procedures. + +### Unity 2.5.0 (October 2019) + +It's been a LONG time since the last release of Unity. Finally, here it is! +There are too many updates to list here, so some highlights: + + - more standards compliant (without giving up on supporting ALL compilers, no matter how quirky) + - many more specialized assertions for better test feedback + - more examples for integrating into your world + - many many bugfixes and tweaks + +### Unity 2.4.3 (November 2017) + + - Allow suiteSetUp() and suiteTearDown() to be povided as normal C functions + - Fix & Expand Greater Than / Less Than assertions for integers + - Built-in option to colorize test results + - Documentation updates + +### Unity 2.4.2 (September 2017) + + - Fixed bug in UNTY_TEST_ASSERT_EACH_EQUAL_* + - Added TEST_ASSERT_GREATER_THAN and TEST_ASSERT_LESS_THAN + - Updated Module Generator to stop changing names when no style given + - Cleanup to custom float printing for accuracy + - Cleanup incorrect line numbers are partial name matching + - Reduce warnings from using popular function names as variable names + +### Unity 2.4.1 (April 2017) + + - test runner generator can inject defines as well as headers + - added a built-in floating point print routine instead of relying on printf + - updated to new coding and naming standard + - updated documentation to be markdown instead of pdf + - fixed many many little bugs, most of which were supplied by the community (you people are awesome!) + - coding standard actually enforced in CI + +### Unity 2.4.0 (October, 2016) + + - port from SourceForge and numerous bugfixes diff --git a/subprojects/unity/docs/UnityConfigurationGuide.md b/subprojects/unity/docs/UnityConfigurationGuide.md new file mode 100644 index 0000000000..0b735f7ae1 --- /dev/null +++ b/subprojects/unity/docs/UnityConfigurationGuide.md @@ -0,0 +1,654 @@ +# Unity Configuration Guide + +## C Standards, Compilers and Microcontrollers + +The embedded software world contains its challenges. +Compilers support different revisions of the C Standard. +They ignore requirements in places, sometimes to make the language more usable in some special regard. +Sometimes it's to simplify their support. +Sometimes it's due to specific quirks of the microcontroller they are targeting. +Simulators add another dimension to this menagerie. + +Unity is designed to run on almost anything that is targeted by a C compiler. +It would be awesome if this could be done with zero configuration. +While there are some targets that come close to this dream, it is sadly not universal. +It is likely that you are going to need at least a couple of the configuration options described in this document. + +All of Unity's configuration options are `#defines`. +Most of these are simple definitions. +A couple are macros with arguments. +They live inside the unity_internals.h header file. +We don't necessarily recommend opening that file unless you really need to. +That file is proof that a cross-platform library is challenging to build. +From a more positive perspective, it is also proof that a great deal of complexity can be centralized primarily to one place to provide a more consistent and simple experience elsewhere. + +### Using These Options + +It doesn't matter if you're using a target-specific compiler and a simulator or a native compiler. +In either case, you've got a couple choices for configuring these options: + +1. Because these options are specified via C defines, you can pass most of these options to your compiler through command line compiler flags. Even if you're using an embedded target that forces you to use their overbearing IDE for all configuration, there will be a place somewhere in your project to configure defines for your compiler. +2. You can create a custom `unity_config.h` configuration file (present in your toolchain's search paths). + In this file, you will list definitions and macros specific to your target. All you must do is define `UNITY_INCLUDE_CONFIG_H` and Unity will rely on `unity_config.h` for any further definitions it may need. + +Unfortunately, it doesn't usually work well to just #define these things in the test itself. +These defines need to take effect where ever unity.h is included. +This would be test test, the test runner (if you're generating one), and from unity.c when it's compiled. + +## The Options + +### Integer Types + +If you've been a C developer for long, you probably already know that C's concept of an integer varies from target to target. +The C Standard has rules about the `int` matching the register size of the target microprocessor. +It has rules about the `int` and how its size relates to other integer types. +An `int` on one target might be 16 bits while on another target it might be 64. +There are more specific types in compilers compliant with C99 or later, but that's certainly not every compiler you are likely to encounter. +Therefore, Unity has a number of features for helping to adjust itself to match your required integer sizes. +It starts off by trying to do it automatically. + +#### `UNITY_EXCLUDE_STDINT_H` + +The first thing that Unity does to guess your types is check `stdint.h`. +This file includes defines like `UINT_MAX` that Unity can use to learn a lot about your system. +It's possible you don't want it to do this (um. why not?) or (more likely) it's possible that your system doesn't support `stdint.h`. +If that's the case, you're going to want to define this. +That way, Unity will know to skip the inclusion of this file and you won't be left with a compiler error. + +_Example:_ + +```C +#define UNITY_EXCLUDE_STDINT_H +``` + +#### `UNITY_EXCLUDE_LIMITS_H` + +The second attempt to guess your types is to check `limits.h`. +Some compilers that don't support `stdint.h` could include `limits.h` instead. +If you don't want Unity to check this file either, define this to make it skip the inclusion. + +_Example:_ + +```C +#define UNITY_EXCLUDE_LIMITS_H +``` + +If you've disabled both of the automatic options above, you're going to have to do the configuration yourself. +Don't worry. +Even this isn't too bad... there are just a handful of defines that you are going to specify if you don't like the defaults. + +#### `UNITY_INT_WIDTH` + +Define this to be the number of bits an `int` takes up on your system. +The default, if not autodetected, is 32 bits. + +_Example:_ + +```C +#define UNITY_INT_WIDTH 16 +``` + +#### `UNITY_LONG_WIDTH` + +Define this to be the number of bits a `long` takes up on your system. +The default, if not autodetected, is 32 bits. +This is used to figure out what kind of 64-bit support your system can handle. +Does it need to specify a `long` or a `long long` to get a 64-bit value. +On 16-bit systems, this option is going to be ignored. + +_Example:_ + +```C +#define UNITY_LONG_WIDTH 16 +``` + +#### `UNITY_POINTER_WIDTH` + +Define this to be the number of bits a pointer takes up on your system. +The default, if not autodetected, is 32-bits. +If you're getting ugly compiler warnings about casting from pointers, this is the one to look at. + +_Hint:_ In order to support exotic processors (for example TI C55x with a pointer width of 23-bit), choose the next power of two (in this case 32-bit). + +_Supported values:_ 16, 32 and 64 + +_Example:_ + +```C +// Choose on of these #defines to set your pointer width (if not autodetected) +//#define UNITY_POINTER_WIDTH 16 +//#define UNITY_POINTER_WIDTH 32 +#define UNITY_POINTER_WIDTH 64 // Set UNITY_POINTER_WIDTH to 64-bit +``` + +#### `UNITY_COMPARE_PTRS_ON_ZERO_ARRAY` + +Define this to make all array assertions compare pointers instead of contents when a length of zero is specified. When not enabled, +defining a length of zero will always result in a failure and a message warning the user that they have tried to compare empty +arrays. + +#### `UNITY_SUPPORT_64` + +Unity will automatically include 64-bit support if it auto-detects it, or if your `int`, `long`, or pointer widths are greater than 32-bits. +Define this to enable 64-bit support if none of the other options already did it for you. +There can be a significant size and speed impact to enabling 64-bit support on small targets, so don't define it if you don't need it. + +_Example:_ + +```C +#define UNITY_SUPPORT_64 +``` + +### Floating Point Types + +In the embedded world, it's not uncommon for targets to have no support for floating point operations at all or to have support that is limited to only single precision. +We are able to guess integer sizes on the fly because integers are always available in at least one size. +Floating point, on the other hand, is sometimes not available at all. +Trying to include `float.h` on these platforms would result in an error. This leaves manual configuration as the only option. + +#### `UNITY_INCLUDE_FLOAT` + +#### `UNITY_EXCLUDE_FLOAT` + +#### `UNITY_INCLUDE_DOUBLE` + +#### `UNITY_EXCLUDE_DOUBLE` + +By default, Unity guesses that you will want single precision floating point support, but not double precision. +It's easy to change either of these using the include and exclude options here. +You may include neither, either, or both, as suits your needs. +For features that are enabled, the following floating point options also become available. + +_Example:_ + +```C +//what manner of strange processor is this? +#define UNITY_EXCLUDE_FLOAT +#define UNITY_INCLUDE_DOUBLE +``` + +#### `UNITY_EXCLUDE_FLOAT_PRINT` + +Unity aims for as small of a footprint as possible and avoids most standard library calls (some embedded platforms don’t have a standard library!). +Because of this, its routines for printing integer values are minimalist and hand-coded. +Therefore, the display of floating point values during a failure are optional. +By default, Unity will print the actual results of floating point assertion failure (e.g. ”Expected 4.56 Was 4.68”). +To not include this extra support, you can use this define to instead respond to a failed assertion with a message like ”Values Not Within Delta”. +If you would like verbose failure messages for floating point assertions, use these options to give more explicit failure messages. + +_Example:_ + +```C +#define UNITY_EXCLUDE_FLOAT_PRINT +``` + +#### `UNITY_FLOAT_TYPE` + +If enabled, Unity assumes you want your `FLOAT` asserts to compare standard C floats. +If your compiler supports a specialty floating point type, you can always override this behavior by using this definition. + +_Example:_ + +```C +#define UNITY_FLOAT_TYPE float16_t +``` + +#### `UNITY_DOUBLE_TYPE` + +If enabled, Unity assumes you want your `DOUBLE` asserts to compare standard C doubles. +If you would like to change this, you can specify something else by using this option. +For example, defining `UNITY_DOUBLE_TYPE` to `long double` could enable gargantuan floating point types on your 64-bit processor instead of the standard `double`. + +_Example:_ + +```C +#define UNITY_DOUBLE_TYPE long double +``` + +#### `UNITY_FLOAT_PRECISION` + +#### `UNITY_DOUBLE_PRECISION` + +If you look up `UNITY_ASSERT_EQUAL_FLOAT` and `UNITY_ASSERT_EQUAL_DOUBLE` as documented in the big daddy Unity Assertion Guide, you will learn that they are not really asserting that two values are equal but rather that two values are "close enough" to equal. +"Close enough" is controlled by these precision configuration options. +If you are working with 32-bit floats and/or 64-bit doubles (the normal on most processors), you should have no need to change these options. +They are both set to give you approximately 1 significant bit in either direction. +The float precision is 0.00001 while the double is 10-12. +For further details on how this works, see the appendix of the Unity Assertion Guide. + +_Example:_ + +```C +#define UNITY_FLOAT_PRECISION 0.001f +``` + +#### `UNITY_IS_NAN` and `UNITY_IS_INF` + +If your toolchain defines `isnan` and `isinf` in `math.h` as macros, nothing needs to be done. If your toolchain doesn't define these, Unity +will create these macros itself. You may override either or both of these defines to specify how you want to evaluate if a number is NaN or Infinity. + +_Example:_ + +```C +#define UNITY_IS_NAN(n) ((n != n) ? 1 : 0) +``` + +### Miscellaneous + +#### `UNITY_EXCLUDE_STDDEF_H` + +Unity uses the `NULL` macro, which defines the value of a null pointer constant, defined in `stddef.h` by default. +If you want to provide your own macro for this, you should exclude the `stddef.h` header file by adding this define to your configuration. + +_Example:_ + +```C +#define UNITY_EXCLUDE_STDDEF_H +``` + +#### `UNITY_INCLUDE_PRINT_FORMATTED` + +Unity provides a simple (and very basic) printf-like string output implementation, which is able to print a string modified by the following format string modifiers: + +- __%d__ - signed value (decimal) +- __%i__ - same as __%d__ +- __%u__ - unsigned value (decimal) +- __%f__ - float/Double (if float support is activated) +- __%g__ - same as __%f__ +- __%b__ - binary prefixed with "0b" +- __%x__ - hexadecimal (upper case) prefixed with "0x" +- __%X__ - same as __%x__ +- __%p__ - pointer (same as __%x__ or __%X__) +- __%c__ - a single character +- __%s__ - a string (e.g. "string") +- __%%__ - The "%" symbol (escaped) + +Length specifiers are also supported. If you are using long long types, make sure UNITY_SUPPORT_64 is true to ensure they are printed correctly. + +- __%ld__ - signed long value (decimal) +- __%lld__ - signed long long value (decimal) +- __%lu__ - unsigned long value (decimal) +- __%llu__ - unsigned long long value (decimal) +- __%lx__ - unsigned long value (hexadecimal) +- __%llx__ - unsigned long long value (hexadecimal) + +_Example:_ + +```C +#define UNITY_INCLUDE_PRINT_FORMATTED + +int a = 0xfab1; +TEST_PRINTF("Decimal %d\n", -7); +TEST_PRINTF("Unsigned %u\n", 987); +TEST_PRINTF("Float %f\n", 3.1415926535897932384); +TEST_PRINTF("Binary %b\n", 0xA); +TEST_PRINTF("Hex %X\n", 0xFAB); +TEST_PRINTF("Pointer %p\n", &a); +TEST_PRINTF("Character %c\n", 'F'); +TEST_PRINTF("String %s\n", "My string"); +TEST_PRINTF("Percent %%\n"); +TEST_PRINTF("Unsigned long long %llu\n", 922337203685477580); +TEST_PRINTF("Color Red \033[41mFAIL\033[0m\n"); +TEST_PRINTF("\n"); +TEST_PRINTF("Multiple (%d) (%i) (%u) (%x)\n", -100, 0, 200, 0x12345); +``` + +### Toolset Customization + +In addition to the options listed above, there are a number of other options which will come in handy to customize Unity's behavior for your specific toolchain. +It is possible that you may not need to touch any of these... but certain platforms, particularly those running in simulators, may need to jump through extra hoops to run properly. +These macros will help in those situations. + +#### `UNITY_OUTPUT_CHAR(a)` + +#### `UNITY_OUTPUT_FLUSH()` + +#### `UNITY_OUTPUT_START()` + +#### `UNITY_OUTPUT_COMPLETE()` + +By default, Unity prints its results to `stdout` as it runs. +This works perfectly fine in most situations where you are using a native compiler for testing. +It works on some simulators as well so long as they have `stdout` routed back to the command line. +There are times, however, where the simulator will lack support for dumping results or you will want to route results elsewhere for other reasons. +In these cases, you should define the `UNITY_OUTPUT_CHAR` macro. +This macro accepts a single character at a time (as an `int`, since this is the parameter type of the standard C `putchar` function most commonly used). +You may replace this with whatever function call you like. + +_Example:_ +Say you are forced to run your test suite on an embedded processor with no `stdout` option. +You decide to route your test result output to a custom serial `RS232_putc()` function you wrote like thus: + +```C +#include "RS232_header.h" +... +#define UNITY_OUTPUT_CHAR(a) RS232_putc(a) +#define UNITY_OUTPUT_START() RS232_config(115200,1,8,0) +#define UNITY_OUTPUT_FLUSH() RS232_flush() +#define UNITY_OUTPUT_COMPLETE() RS232_close() +``` + +_Note:_ +`UNITY_OUTPUT_FLUSH()` can be set to the standard out flush function simply by specifying `UNITY_USE_FLUSH_STDOUT`. +No other defines are required. + +#### `UNITY_OUTPUT_FOR_ECLIPSE` + +#### `UNITY_OUTPUT_FOR_IAR_WORKBENCH` + +#### `UNITY_OUTPUT_FOR_QT_CREATOR` + +When managing your own builds, it is often handy to have messages output in a format which is recognized by your IDE. +These are some standard formats which can be supported. +If you're using Ceedling to manage your builds, it is better to stick with the standard format (leaving these all undefined) and allow Ceedling to use its own decorators. + +#### `UNITY_PTR_ATTRIBUTE` + +Some compilers require a custom attribute to be assigned to pointers, like `near` or `far`. +In these cases, you can give Unity a safe default for these by defining this option with the attribute you would like. + +_Example:_ + +```C +#define UNITY_PTR_ATTRIBUTE __attribute__((far)) +#define UNITY_PTR_ATTRIBUTE near +``` + +#### `UNITY_PRINT_EOL` + +By default, Unity outputs \n at the end of each line of output. +This is easy to parse by the scripts, by Ceedling, etc, but it might not be ideal for YOUR system. +Feel free to override this and to make it whatever you wish. + +_Example:_ + +```C +#define UNITY_PRINT_EOL { UNITY_OUTPUT_CHAR('\r'); UNITY_OUTPUT_CHAR('\n'); } +``` + +#### `UNITY_EXCLUDE_DETAILS` + +This is an option for if you absolutely must squeeze every byte of memory out of your system. +Unity stores a set of internal scratchpads which are used to pass extra detail information around. +It's used by systems like CMock in order to report which function or argument flagged an error. +If you're not using CMock and you're not using these details for other things, then you can exclude them. + +_Example:_ + +```C +#define UNITY_EXCLUDE_DETAILS +``` + +#### `UNITY_PRINT_TEST_CONTEXT` + +This option allows you to specify your own function to print additional context as part of the error message when a test has failed. +It can be useful if you want to output some specific information about the state of the test at the point of failure, and `UNITY_SET_DETAILS` isn't flexible enough for your needs. + +_Example:_ + +```C +#define UNITY_PRINT_TEST_CONTEXT PrintIterationCount + +extern int iteration_count; + +void PrintIterationCount(void) +{ + UnityPrintFormatted("At iteration #%d: ", iteration_count); +} +``` + +#### `UNITY_EXCLUDE_SETJMP` + +If your embedded system doesn't support the standard library setjmp, you can exclude Unity's reliance on this by using this define. +This dropped dependence comes at a price, though. +You will be unable to use custom helper functions for your tests, and you will be unable to use tools like CMock. +Very likely, if your compiler doesn't support setjmp, you wouldn't have had the memory space for those things anyway, though... so this option exists for those situations. + +_Example:_ + +```C +#define UNITY_EXCLUDE_SETJMP +``` + +#### `UNITY_TEST_PROTECT` + +#### `UNITY_TEST_ABORT` + +Unity handles test failures via `setjmp`/`longjmp` pair by default. As mentioned above, you can disable this with `UNITY_EXCLUDE_SETJMP`. You can also customise what happens on every `TEST_PROTECT` and `TEST_ABORT` call. This can be accomplished by providing user-defined `UNITY_TEST_PROTECT` and `UNITY_TEST_ABORT` macros (and these may be defined independently). + +`UNITY_TEST_PROTECT` is used as an `if` statement expression, and has to evaluate to `true` on the first call (when saving stack environment with `setjmp`), and to `false` when it returns as a result of a `TEST_ABORT` (when restoring the stack environment with `longjmp`). + +Whenever an assert macro fails, `TEST_ABORT` is used to restore the stack environment previously set by `TEST_PROTECT`. This part may be overriden with `UNITY_TEST_ABORT`, e.g. if custom failure handling is needed. + +_Example 1:_ + +Calling `longjmp` on your target is possible, but has a platform-specific (or implementation-specific) set of prerequisites, e.g. privileged access level. You can extend the default behaviour of `TEST_PROTECT` and `TEST_ABORT` as: + +`unity_config.h`: + +```C +#include "my_custom_test_handlers.h" + +#define UNITY_TEST_PROTECT() custom_test_protect() +#define UNITY_TEST_ABORT() custom_test_abort() +``` + +`my_custom_test_handlers.c`: + +```C +int custom_test_protect(void) { + platform_specific_code(); + return setjmp(Unity.AbortFrame) == 0; +} + +UNITY_NORETURN void custom_test_abort(void) { + more_platform_specific_code(); + longjmp(Unity.AbortFrame, 1); +} +``` + +_Example 2:_ + +Unity is used to provide the assertion macros only, and an external test harness/runner is used for test orchestration/reporting. In this case you can easily plug your code by overriding `TEST_ABORT` as: + +`unity_config.h`: + +```C +#include "my_custom_test_handlers.h" + +#define UNITY_TEST_PROTECT() 1 +#define UNITY_TEST_ABORT() custom_test_abort() +``` + +`my_custom_test_handlers.c`: + +```C +void custom_test_abort(void) { + if (Unity.CurrentTestFailed == 1) { + custom_failed_test_handler(); + } else if (Unity.CurrentTestIgnored == 1) { + custom_ignored_test_handler(); + } +} +``` + +#### `UNITY_OUTPUT_COLOR` + +If you want to add color using ANSI escape codes you can use this define. + +_Example:_ + +```C +#define UNITY_OUTPUT_COLOR +``` + +#### `UNITY_INCLUDE_EXEC_TIME` + +Define this to measure and report execution time for each test in the suite. When enabled, Unity will do +it's best to automatically find a way to determine the time in milliseconds. On most Windows, macos, or +Linux environments, this is automatic. If not, you can give Unity more information. + +#### `UNITY_CLOCK_MS` + +If you're working on a system (embedded or otherwise) which has an accessible millisecond timer. You can +define `UNITY_CLOCK_MS` to be the name of the function which returns the millisecond timer. It will then +attempt to use that function for timing purposes. + +#### `UNITY_EXEC_TIME_START` + +Define this hook to start a millisecond timer if necessary. + +#### `UNITY_EXEC_TIME_STOP` + +Define this hook to stop a millisecond timer if necessary. + +#### `UNITY_PRINT_EXEC_TIME` + +Define this hook to print the current execution time. Used to report the milliseconds elapsed. + +#### `UNITY_TIME_TYPE` + +Finally, this can be set to the type which holds the millisecond timer. + +#### `UNITY_SHORTHAND_AS_INT` + +#### `UNITY_SHORTHAND_AS_MEM` + +#### `UNITY_SHORTHAND_AS_RAW` + +#### `UNITY_SHORTHAND_AS_NONE` + +These options give you control of the `TEST_ASSERT_EQUAL` and the `TEST_ASSERT_NOT_EQUAL` shorthand assertions. +Historically, Unity treated the former as an alias for an integer comparison. +It treated the latter as a direct comparison using `!=`. +This asymmetry was confusing, but there was much disagreement as to how best to treat this pair of assertions. +These four options will allow you to specify how Unity will treat these assertions. + +- AS INT - the values will be cast to integers and directly compared. + Arguments that don't cast easily to integers will cause compiler errors. +- AS MEM - the address of both values will be taken and the entire object's memory footprint will be compared byte by byte. + Directly placing constant numbers like `456` as expected values will cause errors. +- AS_RAW - Unity assumes that you can compare the two values using `==` and `!=` and will do so. + No details are given about mismatches, because it doesn't really know what type it's dealing with. +- AS_NONE - Unity will disallow the use of these shorthand macros altogether, insisting that developers choose a more descriptive option. + +#### `UNITY_SUPPORT_VARIADIC_MACROS` + +This will force Unity to support variadic macros when using its own built-in RUN_TEST macro. +This will rarely be necessary. Most often, Unity will automatically detect if the compiler supports variadic macros by checking to see if it's C99+ compatible. +In the event that the compiler supports variadic macros, but is primarily C89 (ANSI), defining this option will allow you to use them. +This option is also not necessary when using Ceedling or the test runner generator script. + +#### `UNITY_SUPPORT_TEST_CASES` + +Unity can automatically define all supported parameterized tests macros. +That feature is disabled by default. +To enable it, use the following example: + +```C +#define UNITY_SUPPORT_TEST_CASES +``` + +You can manually provide required `TEST_CASE`, `TEST_RANGE` or `TEST_MATRIX` macro definitions +before including `unity.h`, and they won't be redefined. +If you provide one of the following macros, some of default definitions will not be +defined: +| User defines macro | Unity will _not_ define following macro | +|---|---| +| `UNITY_EXCLUDE_TEST_CASE` | `TEST_CASE` | +| `UNITY_EXCLUDE_TEST_RANGE` | `TEST_RANGE` | +| `UNITY_EXCLUDE_TEST_MATRIX` | `TEST_MATRIX` | +| `TEST_CASE` | `TEST_CASE` | +| `TEST_RANGE` | `TEST_RANGE` | +| `TEST_MATRIX` | `TEST_MATRIX` | + +`UNITY_EXCLUDE_TEST_*` defines is not processed by test runner generator script. +If you exclude one of them from definition, you should provide your own definition +for them or avoid using undefined `TEST_*` macro as a test generator. +Otherwise, compiler cannot build source code file with provided call. + +_Note:_ +That feature requires variadic macro support by compiler. If required feature +is not detected, it will not be enabled, even though preprocessor macro is defined. + +## Getting Into The Guts + +There will be cases where the options above aren't quite going to get everything perfect. +They are likely sufficient for any situation where you are compiling and executing your tests with a native toolchain (e.g. clang on Mac). +These options may even get you through the majority of cases encountered in working with a target simulator run from your local command line. +But especially if you must run your test suite on your target hardware, your Unity configuration will +require special help. +This special help will usually reside in one of two places: the `main()` function or the `RUN_TEST` macro. +Let's look at how these work. + +### `main()` + +Each test module is compiled and run on its own, separate from the other test files in your project. +Each test file, therefore, has a `main` function. +This `main` function will need to contain whatever code is necessary to initialize your system to a workable state. +This is particularly true for situations where you must set up a memory map or initialize a communication channel for the output of your test results. + +A simple main function looks something like this: + +```C +int main(void) { + UNITY_BEGIN(); + RUN_TEST(test_TheFirst); + RUN_TEST(test_TheSecond); + RUN_TEST(test_TheThird); + return UNITY_END(); +} +``` + +You can see that our main function doesn't bother taking any arguments. +For our most barebones case, we'll never have arguments because we just run all the tests each time. +Instead, we start by calling `UNITY_BEGIN`. +We run each test (in whatever order we wish). +Finally, we call `UNITY_END`, returning its return value (which is the total number of failures). + +It should be easy to see that you can add code before any test cases are run or after all the test cases have completed. +This allows you to do any needed system-wide setup or teardown that might be required for your special circumstances. + +#### `RUN_TEST` + +The `RUN_TEST` macro is called with each test case function. +Its job is to perform whatever setup and teardown is necessary for executing a single test case function. +This includes catching failures, calling the test module's `setUp()` and `tearDown()` functions, and calling `UnityConcludeTest()`. +If using CMock or test coverage, there will be additional stubs in use here. +A simple minimalist RUN_TEST macro looks something like this: + +```C +#define RUN_TEST(testfunc) \ + UNITY_NEW_TEST(#testfunc) \ + if (TEST_PROTECT()) { \ + setUp(); \ + testfunc(); \ + } \ + if (TEST_PROTECT() && (!TEST_IS_IGNORED)) \ + tearDown(); \ + UnityConcludeTest(); +``` + +So that's quite a macro, huh? +It gives you a glimpse of what kind of stuff Unity has to deal with for every single test case. +For each test case, we declare that it is a new test. +Then we run `setUp` and our test function. +These are run within a `TEST_PROTECT` block, the function of which is to handle failures that occur during the test. +Then, assuming our test is still running and hasn't been ignored, we run `tearDown`. +No matter what, our last step is to conclude this test before moving on to the next. + +Let's say you need to add a call to `fsync` to force all of your output data to flush to a file after each test. +You could easily insert this after your `UnityConcludeTest` call. +Maybe you want to write an xml tag before and after each result set. +Again, you could do this by adding lines to this macro. +Updates to this macro are for the occasions when you need an action before or after every single test case throughout your entire suite of tests. + +## Happy Porting + +The defines and macros in this guide should help you port Unity to just about any C target we can imagine. +If you run into a snag or two, don't be afraid of asking for help on the forums. +We love a good challenge! + +*Find The Latest of This And More at [ThrowTheSwitch.org][]* + +[ThrowTheSwitch.org]: https://throwtheswitch.org diff --git a/subprojects/unity/docs/UnityGettingStartedGuide.md b/subprojects/unity/docs/UnityGettingStartedGuide.md new file mode 100644 index 0000000000..b951c60ce0 --- /dev/null +++ b/subprojects/unity/docs/UnityGettingStartedGuide.md @@ -0,0 +1,242 @@ +# Unity - Getting Started + +## Welcome + +Congratulations. +You're now the proud owner of your very own pile of bits! +What are you going to do with all these ones and zeros? +This document should be able to help you decide just that. + +Unity is a unit test framework. +The goal has been to keep it small and functional. +The core Unity test framework is three files: a single C file and a couple header files. +These team up to provide functions and macros to make testing easier. + +Unity was designed to be cross-platform. +It works hard to stick with C standards while still providing support for the many embedded C compilers that bend the rules. +Unity has been used with many compilers, including GCC, IAR, Clang, Green Hills, Microchip, and MS Visual Studio. +It's not much work to get it to work with a new target. + +### Overview of the Documents + +#### Unity Assertions reference + +This document will guide you through all the assertion options provided by Unity. +This is going to be your unit testing bread and butter. +You'll spend more time with assertions than any other part of Unity. + +#### Unity Assertions Cheat Sheet + +This document contains an abridged summary of the assertions described in the previous document. +It's perfect for printing and referencing while you familiarize yourself with Unity's options. + +#### Unity Configuration Guide + +This document is the one to reference when you are going to use Unity with a new target or compiler. +It'll guide you through the configuration options and will help you customize your testing experience to meet your needs. + +#### Unity Helper Scripts + +This document describes the helper scripts that are available for simplifying your testing workflow. +It describes the collection of optional Ruby scripts included in the auto directory of your Unity installation. +Neither Ruby nor these scripts are necessary for using Unity. +They are provided as a convenience for those who wish to use them. + +#### Unity License + +What's an open source project without a license file? +This brief document describes the terms you're agreeing to when you use this software. +Basically, we want it to be useful to you in whatever context you want to use it, but please don't blame us if you run into problems. + +### Overview of the Folders + +If you have obtained Unity through Github or something similar, you might be surprised by just how much stuff you suddenly have staring you in the face. +Don't worry, Unity itself is very small. +The rest of it is just there to make your life easier. +You can ignore it or use it at your convenience. +Here's an overview of everything in the project. + +- `src` - This is the code you care about! This folder contains a C file and two header files. + These three files _are_ Unity. +- `docs` - You're reading this document, so it's possible you have found your way into this folder already. + This is where all the handy documentation can be found. +- `examples` - This contains a few examples of using Unity. +- `extras` - These are optional add ons to Unity that are not part of the core project. + If you've reached us through James Grenning's book, you're going to want to look here. +- `test` - This is how Unity and its scripts are all tested. + If you're just using Unity, you'll likely never need to go in here. + If you are the lucky team member who gets to port Unity to a new toolchain, this is a good place to verify everything is configured properly. +- `auto` - Here you will find helpful Ruby scripts for simplifying your test workflow. + They are purely optional and are not required to make use of Unity. + +## How to Create A Test File + +Test files are C files. +Most often you will create a single test file for each C module that you want to test. +The test file should include unity.h and the header for your C module to be tested. + +Next, a test file will include a `setUp()` and `tearDown()` function. +The setUp function can contain anything you would like to run before each test. +The tearDown function can contain anything you would like to run after each test. +Both functions accept no arguments and return nothing. +You may leave either or both of these blank if you have no need for them. + +If you're using Ceedling or the test runner generator script, you may leave these off completely. +Not sure? +Give it a try. +If your compiler complains that it can't find setUp or tearDown when it links, you'll know you need to at least include an empty function for these. + +The majority of the file will be a series of test functions. +Test functions follow the convention of starting with the word "test_" or "spec_". +You don't HAVE to name them this way, but it makes it clear what functions are tests for other developers. +Also, the automated scripts that come with Unity or Ceedling will default to looking for test functions to be prefixed this way. +Test functions take no arguments and return nothing. All test accounting is handled internally in Unity. + +Finally, at the bottom of your test file, you will write a `main()` function. +This function will call `UNITY_BEGIN()`, then `RUN_TEST` for each test, and finally `UNITY_END()`. +This is what will actually trigger each of those test functions to run, so it is important that each function gets its own `RUN_TEST` call. + +Remembering to add each test to the main function can get to be tedious. +If you enjoy using helper scripts in your build process, you might consider making use of our handy [generate_test_runner.rb][] script. +This will create the main function and all the calls for you, assuming that you have followed the suggested naming conventions. +In this case, there is no need for you to include the main function in your test file at all. + +When you're done, your test file will look something like this: + +```C +#include "unity.h" +#include "file_to_test.h" + +void setUp(void) { + // set stuff up here +} + +void tearDown(void) { + // clean stuff up here +} + +void test_function_should_doBlahAndBlah(void) { + //test stuff +} + +void test_function_should_doAlsoDoBlah(void) { + //more test stuff +} + +// not needed when using generate_test_runner.rb +int main(void) { + UNITY_BEGIN(); + RUN_TEST(test_function_should_doBlahAndBlah); + RUN_TEST(test_function_should_doAlsoDoBlah); + return UNITY_END(); +} +``` + +It's possible that you will need more customization than this, eventually. +For that sort of thing, you're going to want to look at the configuration guide. +This should be enough to get you going, though. + +### Running Test Functions + +When writing your own `main()` functions, for a test-runner. +There are two ways to execute the test. + +The classic variant + +``` c +RUN_TEST(func, linenum) +``` + +Or its simpler replacement that starts at the beginning of the function. + +``` c +RUN_TEST(func) +``` + +These macros perform the necessary setup before the test is called and handles clean-up and result tabulation afterwards. + +### Ignoring Test Functions + +There are times when a test is incomplete or not valid for some reason. +At these times, TEST_IGNORE can be called. +Control will immediately be returned to the caller of the test, and no failures will be returned. +This is useful when your test runners are automatically generated. + +``` c +TEST_IGNORE() +``` + +Ignore this test and return immediately + +```c +TEST_IGNORE_MESSAGE (message) +``` + +Ignore this test and return immediately. +Output a message stating why the test was ignored. + +### Aborting Tests + +There are times when a test will contain an infinite loop on error conditions, or there may be reason to escape from the test early without executing the rest of the test. +A pair of macros support this functionality in Unity. +The first `TEST_PROTECT` sets up the feature, and handles emergency abort cases. +`TEST_ABORT` can then be used at any time within the tests to return to the last `TEST_PROTECT` call. + +```c + TEST_PROTECT() +``` + +Setup and Catch macro + +```c + TEST_ABORT() +``` + +Abort Test macro + +Example: + +```c + main() + { + if (TEST_PROTECT()) + { + MyTest(); + } + } +``` + +If MyTest calls `TEST_ABORT`, program control will immediately return to `TEST_PROTECT` with a return value of zero. + +## How to Build and Run A Test File + +This is the single biggest challenge to picking up a new unit testing framework, at least in a language like C or C++. +These languages are REALLY good at getting you "close to the metal" (why is the phrase metal? Wouldn't it be more accurate to say "close to the silicon"?). +While this feature is usually a good thing, it can make testing more challenging. + +You have two really good options for toolchains. +Depending on where you're coming from, it might surprise you that neither of these options is running the unit tests on your hardware. +There are many reasons for this, but here's a short version: + +- On hardware, you have too many constraints (processing power, memory, etc), +- On hardware, you don't have complete control over all registers, +- On hardware, unit testing is more challenging, +- Unit testing isn't System testing. Keep them separate. + +Instead of running your tests on your actual hardware, most developers choose to develop them as native applications (using gcc or MSVC for example) or as applications running on a simulator. +Either is a good option. +Native apps have the advantages of being faster and easier to set up. +Simulator apps have the advantage of working with the same compiler as your target application. +The options for configuring these are discussed in the configuration guide. + +To get either to work, you might need to make a few changes to the file containing your register set (discussed later). + +In either case, a test is built by linking unity, the test file, and the C file(s) being tested. +These files create an executable which can be run as the test set for that module. +Then, this process is repeated for the next test file. +This flexibility of separating tests into individual executables allows us to much more thoroughly unit test our system and it keeps all the test code out of our final release! + +*Find The Latest of This And More at [ThrowTheSwitch.org][]* + +[generate_test_runner.rb]: ../auto/generate_test_runner.rb +[ThrowTheSwitch.org]: https://throwtheswitch.org diff --git a/subprojects/unity/docs/UnityHelperScriptsGuide.md b/subprojects/unity/docs/UnityHelperScriptsGuide.md new file mode 100644 index 0000000000..90e2193927 --- /dev/null +++ b/subprojects/unity/docs/UnityHelperScriptsGuide.md @@ -0,0 +1,533 @@ +# Unity Helper Scripts + +## With a Little Help From Our Friends + +Sometimes what it takes to be a really efficient C programmer is a little non-C. +The Unity project includes a couple of Ruby scripts for making your life just a tad easier. +They are completely optional. +If you choose to use them, you'll need a copy of Ruby, of course. +Just install whatever the latest version is, and it is likely to work. You can find Ruby at [ruby-lang.org][]. + +### `generate_test_runner.rb` + +Are you tired of creating your own `main` function in your test file? +Do you keep forgetting to add a `RUN_TEST` call when you add a new test case to your suite? +Do you want to use CMock or other fancy add-ons but don't want to figure out how to create your own `RUN_TEST` macro? + +Well then we have the perfect script for you! + +The `generate_test_runner` script processes a given test file and automatically creates a separate test runner file that includes ?main?to execute the test cases within the scanned test file. +All you do then is add the generated runner to your list of files to be compiled and linked, and presto you're done! + +This script searches your test file for void function signatures having a function name beginning with "test" or "spec". +It treats each of these functions as a test case and builds up a test suite of them. +For example, the following includes three test cases: + +```C +void testVerifyThatUnityIsAwesomeAndWillMakeYourLifeEasier(void) +{ + ASSERT_TRUE(1); +} +void test_FunctionName_should_WorkProperlyAndReturn8(void) { + ASSERT_EQUAL_INT(8, FunctionName()); +} +void spec_Function_should_DoWhatItIsSupposedToDo(void) { + ASSERT_NOT_NULL(Function(5)); +} +``` + +You can run this script a couple of ways. +The first is from the command line: + +```Shell +ruby generate_test_runner.rb TestFile.c NameOfRunner.c +``` + +Alternatively, if you include only the test file parameter, the script will copy the name of the test file and automatically append `_Runner` to the name of the generated file. +The example immediately below will create TestFile_Runner.c. + +```Shell +ruby generate_test_runner.rb TestFile.c +``` + +You can also add a [YAML][] file to configure extra options. +Conveniently, this YAML file is of the same format as that used by Unity and CMock. +So if you are using YAML files already, you can simply pass the very same file into the generator script. + +```Shell +ruby generate_test_runner.rb TestFile.c my_config.yml +``` + +The contents of the YAML file `my_config.yml` could look something like the example below. +If you're wondering what some of these options do, you're going to love the next section of this document. + +```YAML +:unity: + :includes: + - stdio.h + - microdefs.h + :cexception: 1 + :suite_setup: "blah = malloc(1024);" + :suite_teardown: "free(blah);" +``` + +If you would like to force your generated test runner to include one or more header files, you can just include those at the command line too. +Just make sure these are _after_ the YAML file, if you are using one: + +```Shell +ruby generate_test_runner.rb TestFile.c my_config.yml extras.h +``` + +Another option, particularly if you are already using Ruby to orchestrate your builds - or more likely the Ruby-based build tool Rake - is requiring this script directly. +Anything that you would have specified in a YAML file can be passed to the script as part of a hash. +Let's push the exact same requirement set as we did above but this time through Ruby code directly: + +```Ruby +require "generate_test_runner.rb" +options = { + :includes => ["stdio.h", "microdefs.h"], + :cexception => 1, + :suite_setup => "blah = malloc(1024);", + :suite_teardown => "free(blah);" +} +UnityTestRunnerGenerator.new.run(testfile, runner_name, options) +``` + +If you have multiple files to generate in a build script (such as a Rakefile), you might want to instantiate a generator object with your options and call it to generate each runner afterwards. +Like thus: + +```Ruby +gen = UnityTestRunnerGenerator.new(options) +test_files.each do |f| + gen.run(f, File.basename(f,'.c')+"Runner.c" +end +``` + +#### Options accepted by generate_test_runner.rb + +The following options are available when executing `generate_test_runner`. +You may pass these as a Ruby hash directly or specify them in a YAML file, both of which are described above. +In the `examples` directory, Example 3's Rakefile demonstrates using a Ruby hash. + +##### `:includes` + +This option specifies an array of file names to be `#include`'d at the top of your runner C file. +You might use it to reference custom types or anything else universally needed in your generated runners. + +##### `:defines` + +This option specifies an array of definitions to be `#define`'d at the top of your runner C file. +Each definition will be wrapped in an `#ifndef`. + +##### `:suite_setup` + +Define this option with C code to be executed _before any_ test cases are run. + +Alternatively, if your C compiler supports weak symbols, you can leave this option unset and instead provide a `void suiteSetUp(void)` function in your test suite. +The linker will look for this symbol and fall back to a Unity-provided stub if it is not found. + +This option can also be specified at the command prompt as `--suite_setup=""` + +##### `:suite_teardown` + +Define this option with C code to be executed _after all_ test cases have finished. +An integer variable `num_failures` is available for diagnostics. +The code should end with a `return` statement; the value returned will become the exit code of `main`. +You can normally just return `num_failures`. + +Alternatively, if your C compiler supports weak symbols, you can leave this option unset and instead provide a `int suiteTearDown(int num_failures)` function in your test suite. +The linker will look for this symbol and fall back to a Unity-provided stub if it is not found. + +This option can also be specified at the command prompt as `--suite_teardown=""` + +##### `:enforce_strict_ordering` + +This option should be defined if you have the strict order feature enabled in CMock (see CMock documentation). +This generates extra variables required for everything to run smoothly. +If you provide the same YAML to the generator as used in CMock's configuration, you've already configured the generator properly. + +##### `:externc` + +This option should be defined if you are mixing C and CPP and want your test runners to automatically include extern "C" support when they are generated. + +This option can also be specified at the command prompt as `--externc` + +##### `:mock_prefix` and `:mock_suffix` + +Unity automatically generates calls to Init, Verify and Destroy for every file included in the main test file that starts with the given mock prefix and ends with the given mock suffix, file extension not included. +By default, Unity assumes a `Mock` prefix and no suffix. + +##### `:plugins` + +This option specifies an array of plugins to be used (of course, the array can contain only a single plugin). +This is your opportunity to enable support for CException support, which will add a check for unhandled exceptions in each test, reporting a failure if one is detected. +To enable this feature using Ruby: + +```Ruby +:plugins => [ :cexception ] +``` + +Or as a yaml file: + +```YAML +:plugins: + -:cexception +``` + +If you are using CMock, it is very likely that you are already passing an array of plugins to CMock. +You can just use the same array here. + +This script will just ignore the plugins that don't require additional support. + +This option can also be specified at the command prompt as `--cexception` + +##### `:include_extensions` + +This option specifies the pattern for matching acceptable header file extensions. +By default it will accept hpp, hh, H, and h files. +If you need a different combination of files to search, update this from the default `'(?:hpp|hh|H|h)'`. + +##### `:source_extensions` + +This option specifies the pattern for matching acceptable source file extensions. +By default it will accept cpp, cc, C, c, and ino files. +If you need a different combination of files to search, update this from the default `'(?:cpp|cc|ino|C|c)'`. + +##### `:use_param_tests` + +This option enables parameterized test usage. +That tests accepts arguments from `TEST_CASE` and `TEST_RANGE` macros, +that are located above current test definition. +By default, Unity assumes, that parameterized tests are disabled. + +Few usage examples can be found in `/test/tests/test_unity_parameterized.c` file. + +You should define `UNITY_SUPPORT_TEST_CASES` macro for tests success compiling, +if you enable current option. + +You can see list of supported macros list in the +[Parameterized tests provided macros](#parameterized-tests-provided-macros) +section that follows. + +This option can also be specified at the command prompt as `--use_param_tests=1` + +##### `:cmdline_args` + +When set to `true`, the generated test runner can accept a number of +options to modify how the test(s) are run. + +Ensure Unity is compiled with `UNITY_USE_COMMAND_LINE_ARGS` defined or else +the required functions will not exist. + +These are the available options: + +| Option | Description | +| --------- | ------------------------------------------------- | +| `-l` | List all tests and exit | +| `-f NAME` | Filter to run only tests whose name includes NAME | +| `-n NAME` | Run only the test named NAME | +| `-h` | show the Help menu that lists these options | +| `-q` | Quiet/decrease verbosity | +| `-v` | increase Verbosity | +| `-x NAME` | eXclude tests whose name includes NAME | + +##### `:setup_name` + +Override the default test `setUp` function name. + +This option can also be specified at the command prompt as `--setup_name=""` + +##### `:teardown_name` + +Override the default test `tearDown` function name. + +This option can also be specified at the command prompt as `--teardown_name=""` + +##### `:test_reset_name` + +Override the default test `resetTest` function name. + +This option can also be specified at the command prompt as `--test_reset_name=""` + +##### `:test_verify_name` + +Override the default test `verifyTest` function name. + +This option can also be specified at the command prompt as `--test_verify_name=""` + +##### `:main_name` + +Override the test's `main()` function name (from `main` to whatever is specified). +The sentinel value `:auto` will use the test's filename with the `.c` extension removed prefixed +with `main_` as the "main" function. + +To clarify, if `:main_name == :auto` and the test filename is "test_my_project.c", then the +generated function name will be `main_test_my_project(int argc, char** argv)`. + +This option can also be specified at the command prompt as `--main_name=""` + +##### `main_export_decl` + +Provide any `cdecl` for the `main()` test function. Is empty by default. + +##### `:omit_begin_end` + +If `true`, the `UnityBegin` and `UnityEnd` function will not be called for +Unity test state setup and cleanup. + +This option can also be specified at the command prompt as `--omit_begin_end` + +#### Parameterized tests provided macros + +Unity provides support for few param tests generators, that can be combined +with each other. You must define test function as usual C function with usual +C arguments, and test generator will pass what you tell as a list of arguments. + +Let's show how all of them works on the following test function definitions: + +```C +/* Place your test generators here, usually one generator per one or few lines */ +void test_demoParamFunction(int a, int b, int c) +{ + TEST_ASSERT_GREATER_THAN_INT(a + b, c); +} +``` + +##### `TEST_CASE` + +Test case is a basic generator, that can be used for param testing. +One call of that macro will generate only one call for test function. +It can be used with different args, such as numbers, enums, strings, +global variables, another preprocessor defines. + +If we use replace comment before test function with the following code: + +```C +TEST_CASE(1, 2, 5) +TEST_CASE(10, 7, 20) +``` + +script will generate 2 test calls: + +```C +test_demoParamFunction(1, 2, 5); +test_demoParamFunction(10, 7, 20); +``` + +That calls will be wrapped with `setUp`, `tearDown` and other +usual Unity calls, as for independent unit tests. +The following output can be generated after test executable startup: + +```Log +tests/test_unity_parameterizedDemo.c:14:test_demoParamFunction(1, 2, 5):PASS +tests/test_unity_parameterizedDemo.c:14:test_demoParamFunction(10, 7, 20):PASS +``` + +##### `TEST_RANGE` + +Test range is an advanced generator. It single call can be converted to zero, +one or few `TEST_CASE` equivalent commands. + +That generator can be used for creating numeric ranges in decimal representation +only: integers & floating point numbers. It uses few formats for every parameter: + +1. `[start, stop, step]` is stop-inclusive format +2. `` is stop-exclusive formats + +Format providers 1 and 2 accept only three arguments: + +* `start` is start number +* `stop` is end number (can or cannot exists in result sequence for format 1, +will be always skipped for format 2) +* `step` is incrementing step: can be either positive or negative value. + +Let's use our `test_demoParamFunction` test for checking, what ranges +will be generated for our single `TEST_RANGE` row: + +```C +TEST_RANGE([3, 4, 1], [10, 5, -2], <30, 31, 1>) +``` + +Tests execution output will be similar to that text: + +```Log +tests/test_unity_parameterizedDemo.c:14:test_demoParamFunction(3, 10, 30):PASS +tests/test_unity_parameterizedDemo.c:14:test_demoParamFunction(3, 8, 30):PASS +tests/test_unity_parameterizedDemo.c:14:test_demoParamFunction(3, 6, 30):PASS +tests/test_unity_parameterizedDemo.c:14:test_demoParamFunction(4, 10, 30):PASS +tests/test_unity_parameterizedDemo.c:14:test_demoParamFunction(4, 8, 30):PASS +tests/test_unity_parameterizedDemo.c:14:test_demoParamFunction(4, 6, 30):PASS +``` + +As we can see: + +| Parameter | Format | Possible values | Total of values | Format number | +|---|---|---|---|---| +| `a` | `[3, 4, 1]` | `3`, `4` | 2 | Format 1 | +| `b` | `[10, 5, -2]` | `10`, `8`, `6` | 3 | Format 1, negative step, end number is not included | +| `c` | `<30, 31, 1>` | `30` | 1 | Format 2 | + +_Note_, that format 2 also supports negative step. + +We totally have 2 * 3 * 1 = 6 equal test cases, that can be written as following: + +```C +TEST_CASE(3, 10, 30) +TEST_CASE(3, 8, 30) +TEST_CASE(3, 6, 30) +TEST_CASE(4, 10, 30) +TEST_CASE(4, 8, 30) +TEST_CASE(4, 6, 30) +``` + +##### `TEST_MATRIX` + +Test matix is an advanced generator. It single call can be converted to zero, +one or few `TEST_CASE` equivalent commands. + +That generator will create tests for all cobinations of the provided list. Each argument has to be given as a list of one or more elements in the format `[, , ..., , ]`. + +All parameters supported by the `TEST_CASE` is supported as arguments: +- Numbers incl type specifiers e.g. `<1>`, `<1u>`, `<1l>`, `<2.3>`, or `<2.3f>` +- Strings incl string concatianion e.g. `<"string">`, or `<"partial" "string">` +- Chars e.g. `<'c'>` +- Enums e.g. `` +- Elements of arrays e.g. `` + +Let's use our `test_demoParamFunction` test for checking, what ranges +will be generated for our single `TEST_RANGE` row: + +```C +TEST_MATRIX([3, 4, 7], [10, 8, 2, 1],[30u, 20.0f]) +``` + +Tests execution output will be similar to that text: + +```Log +tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(3, 10, 30u):PASS +tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(3, 10, 20.0f):PASS +tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(3, 8, 30u):PASS +tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(3, 8, 20.0f):PASS +tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(3, 2, 30u):PASS +tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(3, 2, 20.0f):PASS +tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(3, 1, 30u):PASS +tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(3, 1, 20.0f):PASS +tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(4, 10, 30u):PASS +tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(4, 10, 20.0f):PASS +tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(4, 8, 30u):PASS +tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(4, 8, 20.0f):PASS +tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(4, 2, 30u):PASS +tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(4, 2, 20.0f):PASS +tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(4, 1, 30u):PASS +tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(4, 1, 20.0f):PASS +tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(7, 10, 30u):PASS +tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(7, 10, 20.0f):PASS +tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(7, 8, 30u):PASS +tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(7, 8, 20.0f):PASS +tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(7, 2, 30u):PASS +tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(7, 2, 20.0f):PASS +tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(7, 1, 30u):PASS +tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(7, 1, 20.0f):PASS +``` + +As we can see: + +| Parameter | Format | Count of values | +|---|---|---| +| `a` | `[3, 4, 7]` | 2 | +| `b` | `[10, 8, 2, 1]` | 4 | +| `c` | `[30u, 20.0f]` | 2 | + +We totally have 2 * 4 * 2 = 16 equal test cases, that can be written as following: + +```C +TEST_CASE(3, 10, 30u) +TEST_CASE(3, 10, 20.0f) +TEST_CASE(3, 8, 30u) +TEST_CASE(3, 8, 20.0f) +TEST_CASE(3, 2, 30u) +TEST_CASE(3, 2, 20.0f) +TEST_CASE(3, 1, 30u) +TEST_CASE(3, 1, 20.0f) +TEST_CASE(4, 10, 30u) +TEST_CASE(4, 10, 20.0f) +TEST_CASE(4, 8, 30u) +TEST_CASE(4, 8, 20.0f) +TEST_CASE(4, 2, 30u) +TEST_CASE(4, 2, 20.0f) +TEST_CASE(4, 1, 30u) +TEST_CASE(4, 1, 20.0f) +TEST_CASE(7, 10, 30u) +TEST_CASE(7, 10, 20.0f) +TEST_CASE(7, 8, 30u) +TEST_CASE(7, 8, 20.0f) +TEST_CASE(7, 2, 30u) +TEST_CASE(7, 2, 20.0f) +TEST_CASE(7, 1, 30u) +TEST_CASE(7, 1, 20.0f) +``` + +### `unity_test_summary.rb` + +A Unity test file contains one or more test case functions. +Each test case can pass, fail, or be ignored. +Each test file is run individually producing results for its collection of test cases. +A given project will almost certainly be composed of multiple test files. +Therefore, the suite of tests is comprised of one or more test cases spread across one or more test files. +This script aggregates individual test file results to generate a summary of all executed test cases. +The output includes how many tests were run, how many were ignored, and how many failed. In addition, the output includes a listing of which specific tests were ignored and failed. +A good example of the breadth and details of these results can be found in the `examples` directory. +Intentionally ignored and failing tests in this project generate corresponding entries in the summary report. + +If you're interested in other (prettier?) output formats, check into the [Ceedling][] build tool project that works with Unity and CMock and supports xunit-style xml as well as other goodies. + +This script assumes the existence of files ending with the extensions `.testpass` and `.testfail`. +The contents of these files includes the test results summary corresponding to each test file executed with the extension set according to the presence or absence of failures for that test file. +The script searches a specified path for these files, opens each one it finds, parses the results, and aggregates and prints a summary. +Calling it from the command line looks like this: + +```Shell +ruby unity_test_summary.rb build/test/ +``` + +You can optionally specify a root path as well. +This is really helpful when you are using relative paths in your tools' setup, but you want to pull the summary into an IDE like Eclipse for clickable shortcuts. + +```Shell +ruby unity_test_summary.rb build/test/ ~/projects/myproject/ +``` + +Or, if you're more of a Windows sort of person: + +```Shell +ruby unity_test_summary.rb build\teat\ C:\projects\myproject\ +``` + +When configured correctly, you'll see a final summary, like so: + +```Shell +-------------------------- +UNITY IGNORED TEST SUMMARY +-------------------------- +blah.c:22:test_sandwiches_should_HaveBreadOnTwoSides:IGNORE + +------------------------- +UNITY FAILED TEST SUMMARY +------------------------- +blah.c:87:test_sandwiches_should_HaveCondiments:FAIL:Expected 1 was 0 +meh.c:38:test_soda_should_BeCalledPop:FAIL:Expected "pop" was "coke" + +-------------------------- +OVERALL UNITY TEST SUMMARY +-------------------------- +45 TOTAL TESTS 2 TOTAL FAILURES 1 IGNORED +``` + +How convenient is that? + +*Find The Latest of This And More at [ThrowTheSwitch.org][]* + +[ruby-lang.org]: https://ruby-lang.org/ +[YAML]: http://www.yaml.org/ +[Ceedling]: http://www.throwtheswitch.org/ceedling +[ThrowTheSwitch.org]: https://throwtheswitch.org diff --git a/subprojects/unity/docs/UnityKnownIssues.md b/subprojects/unity/docs/UnityKnownIssues.md new file mode 100644 index 0000000000..3449319739 --- /dev/null +++ b/subprojects/unity/docs/UnityKnownIssues.md @@ -0,0 +1,13 @@ +# Unity Test - Known Issues + +## A Note + +This project will do its best to keep track of significant bugs that might effect your usage of this +project and its supporting scripts. A more detailed and up-to-date list for cutting edge Unity can +be found on our Github repository. + +## Issues + + - No built-in validation of no-return functions + - Incomplete support for Printf-style formatting + - Incomplete support for VarArgs diff --git a/subprojects/unity/extras/bdd/readme.md b/subprojects/unity/extras/bdd/readme.md new file mode 100644 index 0000000000..e703588509 --- /dev/null +++ b/subprojects/unity/extras/bdd/readme.md @@ -0,0 +1,40 @@ +# Unity Project - BDD Feature + +Unity's Behavior-Driven Development (BDD) test feature. It allows developers to structure and describe various phases (Given, When, Then) of a test scenario in a BDD-style format. + +## Introduction + +This project is based on the Unity framework originally created by Mike Karlesky, Mark VanderVoord, and Greg Williams in 2007. The project extends Unity by providing macros to define BDD structures with descriptive elements. Feature added by Michael Gene Brockus (Dreamer). + +## License + +This project is distributed under the MIT License. See the [license.txt](license.txt) file for more information. + +## Usage + +### BDD Macros + +The provided BDD macros allow you to structure your test scenarios in a descriptive manner. These macros are for descriptive purposes only and do not have functional behavior. + +- `GIVEN(description)`: Describes the "Given" phase of a test scenario. +- `WHEN(description)`: Describes the "When" phase of a test scenario. +- `THEN(description)`: Describes the "Then" phase of a test scenario. + +Example usage: + +```c +GIVEN("a valid input") { + // Test setup and context + // ... + + WHEN("the input is processed") { + // Perform the action + // ... + + THEN("the expected outcome occurs") { + // Assert the outcome + // ... + } + } +} +``` diff --git a/subprojects/unity/extras/bdd/src/unity_bdd.h b/subprojects/unity/extras/bdd/src/unity_bdd.h new file mode 100644 index 0000000000..feff492ce2 --- /dev/null +++ b/subprojects/unity/extras/bdd/src/unity_bdd.h @@ -0,0 +1,44 @@ +/* ========================================================================= + Unity - A Test Framework for C + ThrowTheSwitch.org + Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams + SPDX-License-Identifier: MIT +========================================================================= */ + +#ifndef UNITY_BDD_TEST_H_ +#define UNITY_BDD_TEST_H_ + +#ifdef __cplusplus +extern "C" +{ +#endif + +#include + +/** + * @brief Macros for defining a Behavior-Driven Development (BDD) structure with descriptions. + * + * These macros provide a way to structure and describe different phases (Given, When, Then) of a + * test scenario in a BDD-style format. However, they don't have functional behavior by themselves + * and are used for descriptive purposes. + */ +#define GIVEN(description) \ + if (0) { \ + printf("Given %s\n", description); \ + } else + +#define WHEN(description) \ + if (0) { \ + printf("When %s\n", description); \ + } else + +#define THEN(description) \ + if (0) { \ + printf("Then %s\n", description); \ + } else + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/subprojects/unity/extras/bdd/test/meson.build b/subprojects/unity/extras/bdd/test/meson.build new file mode 100644 index 0000000000..fcdaffff4c --- /dev/null +++ b/subprojects/unity/extras/bdd/test/meson.build @@ -0,0 +1,9 @@ +project('BDD Tester', 'c') + +# Add Unity as a dependency +unity_dep = dependency('unity') + +# Define your source files +sources = files('test_bdd.c') + +executable('tester', sources, dependencies : unity_dep) diff --git a/subprojects/unity/extras/bdd/test/test_bdd.c b/subprojects/unity/extras/bdd/test/test_bdd.c new file mode 100644 index 0000000000..f86e5abdd1 --- /dev/null +++ b/subprojects/unity/extras/bdd/test/test_bdd.c @@ -0,0 +1,129 @@ +/* ========================================================================= + Unity - A Test Framework for C + ThrowTheSwitch.org + Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams + SPDX-License-Identifier: MIT +========================================================================= */ + +#include "unity.h" +#include "unity_bdd.h" + +void test_bdd_logic_test(void) { + GIVEN("a valid statement is passed") + { + // Set up the context + bool givenExecuted = true; + + WHEN("a statement is true") + { + // Perform the login action + bool whenExecuted = true; + + THEN("we validate everything was worked") + { + // Check the expected outcome + bool thenExecuted = true; + + TEST_ASSERT_TRUE(givenExecuted); + TEST_ASSERT_TRUE(whenExecuted); + TEST_ASSERT_TRUE(thenExecuted); + } + } + } +} // end of case + +void test_bdd_user_account(void) { + GIVEN("a user's account with sufficient balance") + { + // Set up the context + float accountBalance = 500.0; + float withdrawalAmount = 200.0; + + WHEN("the user requests a withdrawal of $200") + { + // Perform the withdrawal action + if (accountBalance >= withdrawalAmount) + { + accountBalance -= withdrawalAmount; + } // end if + THEN("the withdrawal amount should be deducted from the account balance") + { + // Check the expected outcome + + // Simulate the scenario + float compareBalance = 500.0; + TEST_ASSERT_LESS_THAN_FLOAT(accountBalance, compareBalance); + } + } + } +} // end of case + +void test_bdd_empty_cart(void) { + GIVEN("a user with an empty shopping cart") + { + // Set up the context + int cartItemCount = 0; + + WHEN("the user adds a product to the cart") + { + // Perform the action of adding a product + + THEN("the cart item count should increase by 1") + { + // Check the expected outcome + cartItemCount++; + + TEST_ASSERT_EQUAL_INT(cartItemCount, 1); + } + } + } +} // end of case + +void test_bdd_valid_login(void) { + GIVEN("a registered user with valid credentials") + { + // Set up the context + const char* validUsername = "user123"; + const char* validPassword = "pass456"; + + WHEN("the user provides correct username and password") + { + // Perform the action of user login + const char* inputUsername = "user123"; + const char* inputPassword = "pass456"; + + THEN("the login should be successful") + { + // Check the expected outcome + // Simulate login validation + TEST_ASSERT_EQUAL_STRING(inputUsername, validUsername); + TEST_ASSERT_EQUAL_STRING(inputPassword, validPassword); + } + } + + WHEN("the user provides incorrect password") + { + // Perform the action of user login + const char* inputUsername = "user123"; + const char* inputPassword = "wrongpass"; + + THEN("the login should fail with an error message") + { + // Check the expected outcome + // Simulate login validation + TEST_ASSERT_EQUAL_STRING(inputUsername, validUsername); + // TEST_ASSERT_NOT_EQUAL_STRING(inputPassword, validPassword); + } + } + } +} // end of case + +int main(void) +{ + UnityBegin("test_bdd.c"); + RUN_TEST(test_bdd_logic_test); + RUN_TEST(test_bdd_user_account); + RUN_TEST(test_bdd_empty_cart); + RUN_TEST(test_bdd_valid_login); + return UnityEnd(); +} diff --git a/subprojects/unity/extras/eclipse/error_parsers.txt b/subprojects/unity/extras/eclipse/error_parsers.txt new file mode 100644 index 0000000000..94e34ff385 --- /dev/null +++ b/subprojects/unity/extras/eclipse/error_parsers.txt @@ -0,0 +1,26 @@ +Eclipse error parsers +===================== + +These are a godsend for extracting & quickly navigating to +warnings & error messages from console output. Unforunately +I don't know how to write an Eclipse plugin so you'll have +to add them manually. + +To add a console parser to Eclipse, go to Window --> Preferences +--> C/C++ --> Build --> Settings. Click on the 'Error Parsers' +tab and then click the 'Add...' button. See the table below for +the parser fields to add. + +Eclipse will only parse the console output during a build, so +running your unit tests must be part of your build process. +Either add this to your make/rakefile, or add it as a post- +build step in your Eclipse project settings. + + +Unity unit test error parsers +----------------------------- +Severity Pattern File Line Description +------------------------------------------------------------------------------- +Error (\.+)(.*?):(\d+):(.*?):FAIL: (.*) $2 $3 $5 +Warning (\.+)(.*?):(\d+):(.*?):IGNORE: (.*) $2 $3 $5 +Warning (\.+)(.*?):(\d+):(.*?):IGNORE\s*$ $2 $3 Ignored test diff --git a/subprojects/unity/extras/fixture/readme.md b/subprojects/unity/extras/fixture/readme.md new file mode 100644 index 0000000000..e0c9e1b730 --- /dev/null +++ b/subprojects/unity/extras/fixture/readme.md @@ -0,0 +1,26 @@ +# Unity Fixtures + +This Framework is an optional add-on to Unity. +By including unity_fixture.h in place of unity.h, you may now work with Unity in a manner similar to CppUTest. +This framework adds the concepts of test groups and gives finer control of your tests over the command line. + +This framework is primarily supplied for those working through James Grenning's book on Embedded Test Driven Development, or those coming to Unity from CppUTest. +We should note that using this framework glosses over some of the features of Unity, and makes it more difficult to integrate with other testing tools like Ceedling and CMock. + +## Dependency Notification + +Fixtures, by default, uses the Memory addon as well. +This is to make it simple for those trying to follow along with James' book. +Using them together is completely optional. +You may choose to use Fixtures without Memory handling by defining `UNITY_FIXTURE_NO_EXTRAS`. +It will then stop automatically pulling in extras and leave you to do it as desired. + +## Usage information + +By default the test executables produced by Unity Fixtures run all tests once, but the behavior can be configured with command-line flags. +Run the test executable with the `--help` flag for more information. + +It's possible to add a custom line at the end of the help message, typically to point to project-specific or company-specific unit test documentation. +Define `UNITY_CUSTOM_HELP_MSG` to provide a custom message, e.g.: + + #define UNITY_CUSTOM_HELP_MSG "If any test fails see https://example.com/troubleshooting" diff --git a/subprojects/unity/extras/fixture/src/meson.build b/subprojects/unity/extras/fixture/src/meson.build new file mode 100644 index 0000000000..224911de66 --- /dev/null +++ b/subprojects/unity/extras/fixture/src/meson.build @@ -0,0 +1,10 @@ +unity_inc += include_directories('.') +unity_src += files('unity_fixture.c') + +if not meson.is_subproject() + install_headers( + 'unity_fixture.h', + 'unity_fixture_internals.h', + subdir: meson.project_name() + ) +endif diff --git a/subprojects/unity/extras/fixture/src/unity_fixture.c b/subprojects/unity/extras/fixture/src/unity_fixture.c new file mode 100644 index 0000000000..9b3fce273a --- /dev/null +++ b/subprojects/unity/extras/fixture/src/unity_fixture.c @@ -0,0 +1,310 @@ +/* ========================================================================= + Unity - A Test Framework for C + ThrowTheSwitch.org + Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams + SPDX-License-Identifier: MIT +========================================================================= */ + +#include "unity_fixture.h" +#include "unity_internals.h" +#include + +struct UNITY_FIXTURE_T UnityFixture; + +/* If you decide to use the function pointer approach. + * Build with -D UNITY_OUTPUT_CHAR=outputChar and include + * int (*outputChar)(int) = putchar; */ + +void setUp(void) { /*does nothing*/ } +void tearDown(void) { /*does nothing*/ } + +static void announceTestRun(unsigned int runNumber) +{ + UnityPrint("Unity test run "); + UnityPrintNumberUnsigned(runNumber+1); + UnityPrint(" of "); + UnityPrintNumberUnsigned(UnityFixture.RepeatCount); + UNITY_PRINT_EOL(); +} + +int UnityMain(int argc, const char* argv[], void (*runAllTests)(void)) +{ + int result = UnityGetCommandLineOptions(argc, argv); + unsigned int r; + if (result != 0) + return result; + + for (r = 0; r < UnityFixture.RepeatCount; r++) + { + UnityBegin(argv[0]); + announceTestRun(r); + runAllTests(); + if (!UnityFixture.Verbose) UNITY_PRINT_EOL(); + UnityEnd(); + } + + return (int)Unity.TestFailures; +} + +static int selected(const char* filter, const char* name) +{ + if (filter == 0) + return 1; + return strstr(name, filter) ? 1 : 0; +} + +static int testSelected(const char* test) +{ + return selected(UnityFixture.NameFilter, test); +} + +static int groupSelected(const char* group) +{ + return selected(UnityFixture.GroupFilter, group); +} + +void UnityTestRunner(unityfunction* setup, + unityfunction* testBody, + unityfunction* teardown, + const char* printableName, + const char* group, + const char* name, + const char* file, + unsigned int line) +{ + if (testSelected(name) && groupSelected(group)) + { + Unity.TestFile = file; + Unity.CurrentTestName = printableName; + Unity.CurrentTestLineNumber = line; + if (UnityFixture.Verbose) + { + UnityPrint(printableName); + #ifndef UNITY_REPEAT_TEST_NAME + Unity.CurrentTestName = NULL; + #endif + } + else if (UnityFixture.Silent) + { + /* Do Nothing */ + } + else + { + UNITY_OUTPUT_CHAR('.'); + } + + Unity.NumberOfTests++; + UnityPointer_Init(); + + UNITY_EXEC_TIME_START(); + + if (TEST_PROTECT()) + { + setup(); + testBody(); + } + if (TEST_PROTECT()) + { + teardown(); + } + if (TEST_PROTECT()) + { + UnityPointer_UndoAllSets(); + } + UnityConcludeFixtureTest(); + } +} + +void UnityIgnoreTest(const char* printableName, const char* group, const char* name) +{ + if (testSelected(name) && groupSelected(group)) + { + Unity.NumberOfTests++; + Unity.TestIgnores++; + if (UnityFixture.Verbose) + { + UnityPrint(printableName); + UNITY_PRINT_EOL(); + } + else if (UnityFixture.Silent) + { + /* Do Nothing */ + } + else + { + UNITY_OUTPUT_CHAR('!'); + } + } +} + +/*-------------------------------------------------------- */ +/*Automatic pointer restoration functions */ +struct PointerPair +{ + void** pointer; + void* old_value; +}; + +static struct PointerPair pointer_store[UNITY_MAX_POINTERS]; +static int pointer_index = 0; + +void UnityPointer_Init(void) +{ + pointer_index = 0; +} + +void UnityPointer_Set(void** pointer, void* newValue, UNITY_LINE_TYPE line) +{ + if (pointer_index >= UNITY_MAX_POINTERS) + { + UNITY_TEST_FAIL(line, "Too many pointers set"); + } + else + { + pointer_store[pointer_index].pointer = pointer; + pointer_store[pointer_index].old_value = *pointer; + *pointer = newValue; + pointer_index++; + } +} + +void UnityPointer_UndoAllSets(void) +{ + while (pointer_index > 0) + { + pointer_index--; + *(pointer_store[pointer_index].pointer) = + pointer_store[pointer_index].old_value; + } +} + +int UnityGetCommandLineOptions(int argc, const char* argv[]) +{ + int i; + UnityFixture.Verbose = 0; + UnityFixture.Silent = 0; + UnityFixture.GroupFilter = 0; + UnityFixture.NameFilter = 0; + UnityFixture.RepeatCount = 1; + + if (argc == 1) + return 0; + + for (i = 1; i < argc; ) + { + if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0) + { + /* Usage */ + UnityPrint("Runs a series of unit tests."); + UNITY_PRINT_EOL(); + UNITY_PRINT_EOL(); + UnityPrint("When no flag is specified, all tests are run."); + UNITY_PRINT_EOL(); + UNITY_PRINT_EOL(); + UnityPrint("Optional flags:"); + UNITY_PRINT_EOL(); + UnityPrint(" -v Verbose output: show all tests executed even if they pass"); + UNITY_PRINT_EOL(); + UnityPrint(" -s Silent mode: minimal output showing only test failures"); + UNITY_PRINT_EOL(); + UnityPrint(" -g NAME Only run tests in groups that contain the string NAME"); + UNITY_PRINT_EOL(); + UnityPrint(" -n NAME Only run tests whose name contains the string NAME"); + UNITY_PRINT_EOL(); + UnityPrint(" -r NUMBER Repeatedly run all tests NUMBER times"); + UNITY_PRINT_EOL(); + UnityPrint(" -h, --help Display this help message"); + UNITY_PRINT_EOL(); + UNITY_PRINT_EOL(); +#ifdef UNITY_CUSTOM_HELP_MSG + /* User-defined help message, e.g. to point to project-specific documentation */ + UnityPrint(UNITY_CUSTOM_HELP_MSG); + UNITY_PRINT_EOL(); +#else + /* Default help suffix if a custom one is not defined */ + UnityPrint("More information about Unity: https://www.throwtheswitch.org/unity"); + UNITY_PRINT_EOL(); +#endif + return 1; /* Exit without running the tests */ + } + else if (strcmp(argv[i], "-v") == 0) + { + UnityFixture.Verbose = 1; + i++; + } + else if (strcmp(argv[i], "-s") == 0) + { + UnityFixture.Silent = 1; + i++; + } + else if (strcmp(argv[i], "-g") == 0) + { + i++; + if (i >= argc) + return 1; + UnityFixture.GroupFilter = argv[i]; + i++; + } + else if (strcmp(argv[i], "-n") == 0) + { + i++; + if (i >= argc) + return 1; + UnityFixture.NameFilter = argv[i]; + i++; + } + else if (strcmp(argv[i], "-r") == 0) + { + UnityFixture.RepeatCount = 2; + i++; + if (i < argc) + { + if (*(argv[i]) >= '0' && *(argv[i]) <= '9') + { + unsigned int digit = 0; + UnityFixture.RepeatCount = 0; + while (argv[i][digit] >= '0' && argv[i][digit] <= '9') + { + UnityFixture.RepeatCount *= 10; + UnityFixture.RepeatCount += (unsigned int)argv[i][digit++] - '0'; + } + i++; + } + } + } + else + { + /* ignore unknown parameter */ + i++; + } + } + return 0; +} + +void UnityConcludeFixtureTest(void) +{ + if (Unity.CurrentTestIgnored) + { + Unity.TestIgnores++; + UNITY_PRINT_EOL(); + } + else if (!Unity.CurrentTestFailed) + { + if (UnityFixture.Verbose) + { + UnityPrint(" "); + UnityPrint(UnityStrPass); + UNITY_EXEC_TIME_STOP(); + UNITY_PRINT_EXEC_TIME(); + UNITY_PRINT_EOL(); + } + } + else /* Unity.CurrentTestFailed */ + { + Unity.TestFailures++; + UNITY_PRINT_EOL(); + } + + Unity.CurrentTestFailed = 0; + Unity.CurrentTestIgnored = 0; +} diff --git a/subprojects/unity/extras/fixture/src/unity_fixture.h b/subprojects/unity/extras/fixture/src/unity_fixture.h new file mode 100644 index 0000000000..ed6ff482c9 --- /dev/null +++ b/subprojects/unity/extras/fixture/src/unity_fixture.h @@ -0,0 +1,94 @@ +/* ========================================================================= + Unity - A Test Framework for C + ThrowTheSwitch.org + Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams + SPDX-License-Identifier: MIT +========================================================================= */ + +#ifndef UNITY_FIXTURE_H_ +#define UNITY_FIXTURE_H_ + +#include "unity.h" +#include "unity_fixture_internals.h" + +#ifndef UNITY_FIXTURE_NO_EXTRAS +#include "unity_memory.h" +#endif + +#ifdef __cplusplus +extern "C" +{ +#endif + +#include "unity_internals.h" + + +int UnityMain(int argc, const char* argv[], void (*runAllTests)(void)); + + +#define TEST_GROUP(group)\ + static const char* TEST_GROUP_##group = #group + +#define TEST_SETUP(group) void TEST_##group##_SETUP(void);\ + void TEST_##group##_SETUP(void) + +#define TEST_TEAR_DOWN(group) void TEST_##group##_TEAR_DOWN(void);\ + void TEST_##group##_TEAR_DOWN(void) + + +#define TEST(group, name) \ + void TEST_##group##_##name##_(void);\ + void TEST_##group##_##name##_run(void);\ + void TEST_##group##_##name##_run(void)\ + {\ + UnityTestRunner(TEST_##group##_SETUP,\ + TEST_##group##_##name##_,\ + TEST_##group##_TEAR_DOWN,\ + "TEST(" #group ", " #name ")",\ + TEST_GROUP_##group, #name,\ + __FILE__, __LINE__);\ + }\ + void TEST_##group##_##name##_(void) + +#define IGNORE_TEST(group, name) \ + void TEST_##group##_##name##_(void);\ + void TEST_##group##_##name##_run(void);\ + void TEST_##group##_##name##_run(void)\ + {\ + UnityIgnoreTest("IGNORE_TEST(" #group ", " #name ")", TEST_GROUP_##group, #name);\ + }\ + void TEST_##group##_##name##_(void) + +/* Call this for each test, insider the group runner */ +#define RUN_TEST_CASE(group, name) \ + { void TEST_##group##_##name##_run(void);\ + TEST_##group##_##name##_run(); } + +/* This goes at the bottom of each test file or in a separate c file */ +#define TEST_GROUP_RUNNER(group)\ + void TEST_##group##_GROUP_RUNNER(void);\ + void TEST_##group##_GROUP_RUNNER(void) + +/* Call this from main */ +#define RUN_TEST_GROUP(group)\ + { void TEST_##group##_GROUP_RUNNER(void);\ + TEST_##group##_GROUP_RUNNER(); } + +/* CppUTest Compatibility Macros */ +#ifndef UNITY_EXCLUDE_CPPUTEST_ASSERTS +/* Sets a pointer and automatically restores it to its old value after teardown */ +#define UT_PTR_SET(ptr, newPointerValue) UnityPointer_Set((void**)&(ptr), (void*)(newPointerValue), __LINE__) +#define TEST_ASSERT_POINTERS_EQUAL(expected, actual) TEST_ASSERT_EQUAL_PTR((expected), (actual)) +#define TEST_ASSERT_BYTES_EQUAL(expected, actual) TEST_ASSERT_EQUAL_HEX8(0xff & (expected), 0xff & (actual)) +#define FAIL(message) TEST_FAIL_MESSAGE((message)) +#define CHECK(condition) TEST_ASSERT_TRUE((condition)) +#define LONGS_EQUAL(expected, actual) TEST_ASSERT_EQUAL_INT((expected), (actual)) +#define STRCMP_EQUAL(expected, actual) TEST_ASSERT_EQUAL_STRING((expected), (actual)) +#define DOUBLES_EQUAL(expected, actual, delta) TEST_ASSERT_DOUBLE_WITHIN((delta), (expected), (actual)) +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* UNITY_FIXTURE_H_ */ diff --git a/subprojects/unity/extras/fixture/src/unity_fixture_internals.h b/subprojects/unity/extras/fixture/src/unity_fixture_internals.h new file mode 100644 index 0000000000..f8f83d2d95 --- /dev/null +++ b/subprojects/unity/extras/fixture/src/unity_fixture_internals.h @@ -0,0 +1,50 @@ +/* ========================================================================= + Unity - A Test Framework for C + ThrowTheSwitch.org + Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams + SPDX-License-Identifier: MIT +========================================================================= */ + +#ifndef UNITY_FIXTURE_INTERNALS_H_ +#define UNITY_FIXTURE_INTERNALS_H_ + +#ifdef __cplusplus +extern "C" +{ +#endif + +struct UNITY_FIXTURE_T +{ + int Verbose; + int Silent; + unsigned int RepeatCount; + const char* NameFilter; + const char* GroupFilter; +}; +extern struct UNITY_FIXTURE_T UnityFixture; + +typedef void unityfunction(void); +void UnityTestRunner(unityfunction* setup, + unityfunction* testBody, + unityfunction* teardown, + const char* printableName, + const char* group, + const char* name, + const char* file, unsigned int line); + +void UnityIgnoreTest(const char* printableName, const char* group, const char* name); +int UnityGetCommandLineOptions(int argc, const char* argv[]); +void UnityConcludeFixtureTest(void); + +void UnityPointer_Set(void** pointer, void* newValue, UNITY_LINE_TYPE line); +void UnityPointer_UndoAllSets(void); +void UnityPointer_Init(void); +#ifndef UNITY_MAX_POINTERS +#define UNITY_MAX_POINTERS 5 +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* UNITY_FIXTURE_INTERNALS_H_ */ diff --git a/subprojects/unity/extras/fixture/test/Makefile b/subprojects/unity/extras/fixture/test/Makefile new file mode 100644 index 0000000000..bbe32410e9 --- /dev/null +++ b/subprojects/unity/extras/fixture/test/Makefile @@ -0,0 +1,72 @@ +CC = gcc +ifeq ($(shell uname -s), Darwin) +CC = clang +endif +#DEBUG = -O0 -g +CFLAGS += -std=c99 -pedantic -Wall -Wextra -Werror -DUNITY_FIXTURE_NO_EXTRAS +CFLAGS += $(DEBUG) +SRC = ../src/unity_fixture.c \ + ../../../src/unity.c \ + unity_fixture_Test.c \ + unity_fixture_TestRunner.c \ + main/AllTests.c + +INC_DIR = -I../src -I../../../src/ +BUILD_DIR = ../build +TARGET = ../build/fixture_tests.exe + +all: default noStdlibMalloc 32bits + +default: $(BUILD_DIR) + $(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -D UNITY_SUPPORT_64 + @ echo "default build" + ./$(TARGET) + +32bits: $(BUILD_DIR) + $(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -m32 + @ echo "32bits build" + ./$(TARGET) + +noStdlibMalloc: $(BUILD_DIR) + $(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -D UNITY_EXCLUDE_STDLIB_MALLOC + @ echo "build with noStdlibMalloc" + ./$(TARGET) + +C89: CFLAGS += -D UNITY_EXCLUDE_STDINT_H # C89 did not have type 'long long', +C89: $(BUILD_DIR) + $(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -std=c89 && ./$(TARGET) + $(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -D UNITY_EXCLUDE_STDLIB_MALLOC -std=c89 + ./$(TARGET) + +$(BUILD_DIR): + mkdir -p $(BUILD_DIR) + +clean: + rm -f $(TARGET) $(BUILD_DIR)/*.gc* + +cov: $(BUILD_DIR) + cd $(BUILD_DIR) && \ + $(CC) $(DEFINES) $(foreach i, $(SRC), ../test/$(i)) $(INC_DIR) -o $(TARGET) -fprofile-arcs -ftest-coverage + rm -f $(BUILD_DIR)/*.gcda + ./$(TARGET) > /dev/null ; ./$(TARGET) -v > /dev/null + cd $(BUILD_DIR) && \ + gcov unity_fixture.c | head -3 + grep '###' $(BUILD_DIR)/unity_fixture.c.gcov -C2 || true # Show uncovered lines + +# These extended flags DO get included before any target build runs +CFLAGS += -Wbad-function-cast +CFLAGS += -Wcast-qual +CFLAGS += -Wconversion +CFLAGS += -Wformat=2 +CFLAGS += -Wmissing-prototypes +CFLAGS += -Wold-style-definition +CFLAGS += -Wpointer-arith +CFLAGS += -Wshadow +CFLAGS += -Wstrict-overflow=5 +CFLAGS += -Wstrict-prototypes +CFLAGS += -Wswitch-default +CFLAGS += -Wundef +CFLAGS += -Wno-error=undef # Warning only, this should not stop the build +CFLAGS += -Wunreachable-code +CFLAGS += -Wunused +CFLAGS += -fstrict-aliasing diff --git a/subprojects/unity/extras/fixture/test/main/AllTests.c b/subprojects/unity/extras/fixture/test/main/AllTests.c new file mode 100644 index 0000000000..d5eec4be38 --- /dev/null +++ b/subprojects/unity/extras/fixture/test/main/AllTests.c @@ -0,0 +1,20 @@ +/* ========================================================================= + Unity - A Test Framework for C + ThrowTheSwitch.org + Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams + SPDX-License-Identifier: MIT +========================================================================= */ + +#include "unity_fixture.h" + +static void runAllTests(void) +{ + RUN_TEST_GROUP(UnityFixture); + RUN_TEST_GROUP(UnityCommandOptions); +} + +int main(int argc, const char* argv[]) +{ + return UnityMain(argc, argv, runAllTests); +} + diff --git a/subprojects/unity/extras/fixture/test/template_fixture_tests.c b/subprojects/unity/extras/fixture/test/template_fixture_tests.c new file mode 100644 index 0000000000..2397f10576 --- /dev/null +++ b/subprojects/unity/extras/fixture/test/template_fixture_tests.c @@ -0,0 +1,39 @@ +/* ========================================================================= + Unity - A Test Framework for C + ThrowTheSwitch.org + Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams + SPDX-License-Identifier: MIT +========================================================================= */ + +#include "unity_fixture.h" + +static int data = -1; + +TEST_GROUP(mygroup); + +TEST_SETUP(mygroup) +{ + data = 0; +} + +TEST_TEAR_DOWN(mygroup) +{ + data = -1; +} + +TEST(mygroup, test1) +{ + TEST_ASSERT_EQUAL_INT(0, data); +} + +TEST(mygroup, test2) +{ + TEST_ASSERT_EQUAL_INT(0, data); + data = 5; +} + +TEST(mygroup, test3) +{ + data = 7; + TEST_ASSERT_EQUAL_INT(7, data); +} diff --git a/subprojects/unity/extras/fixture/test/unity_fixture_Test.c b/subprojects/unity/extras/fixture/test/unity_fixture_Test.c new file mode 100644 index 0000000000..d2785d3c56 --- /dev/null +++ b/subprojects/unity/extras/fixture/test/unity_fixture_Test.c @@ -0,0 +1,245 @@ +/* ========================================================================= + Unity - A Test Framework for C + ThrowTheSwitch.org + Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams + SPDX-License-Identifier: MIT +========================================================================= */ + +#include "unity_fixture.h" +#include +#include + +TEST_GROUP(UnityFixture); + +TEST_SETUP(UnityFixture) +{ +} + +TEST_TEAR_DOWN(UnityFixture) +{ +} + +static int* pointer1 = 0; +static int* pointer2 = (int*)2; +static int* pointer3 = (int*)3; +static int int1; +static int int2; +static int int3; +static int int4; + +TEST(UnityFixture, PointerSetting) +{ + TEST_ASSERT_POINTERS_EQUAL(pointer1, 0); + UT_PTR_SET(pointer1, &int1); + UT_PTR_SET(pointer2, &int2); + UT_PTR_SET(pointer3, &int3); + TEST_ASSERT_POINTERS_EQUAL(pointer1, &int1); + TEST_ASSERT_POINTERS_EQUAL(pointer2, &int2); + TEST_ASSERT_POINTERS_EQUAL(pointer3, &int3); + UT_PTR_SET(pointer1, &int4); + UnityPointer_UndoAllSets(); + TEST_ASSERT_POINTERS_EQUAL(pointer1, 0); + TEST_ASSERT_POINTERS_EQUAL(pointer2, (int*)2); + TEST_ASSERT_POINTERS_EQUAL(pointer3, (int*)3); +} + +static char *p1; +static char *p2; + +TEST(UnityFixture, PointerSet) +{ + char c1; + char c2; + char newC1; + char newC2; + p1 = &c1; + p2 = &c2; + + UnityPointer_Init(); + UT_PTR_SET(p1, &newC1); + UT_PTR_SET(p2, &newC2); + TEST_ASSERT_POINTERS_EQUAL(&newC1, p1); + TEST_ASSERT_POINTERS_EQUAL(&newC2, p2); + UnityPointer_UndoAllSets(); + TEST_ASSERT_POINTERS_EQUAL(&c1, p1); + TEST_ASSERT_POINTERS_EQUAL(&c2, p2); +} + +TEST(UnityFixture, FreeNULLSafety) +{ + free(NULL); +} + +TEST(UnityFixture, ConcludeTestIncrementsFailCount) +{ + UNITY_UINT savedFails = Unity.TestFailures; + UNITY_UINT savedIgnores = Unity.TestIgnores; + Unity.CurrentTestFailed = 1; + UnityConcludeFixtureTest(); /* Resets TestFailed for this test to pass */ + Unity.CurrentTestIgnored = 1; + UnityConcludeFixtureTest(); /* Resets TestIgnored */ + TEST_ASSERT_EQUAL(savedFails + 1, Unity.TestFailures); + TEST_ASSERT_EQUAL(savedIgnores + 1, Unity.TestIgnores); + Unity.TestFailures = savedFails; + Unity.TestIgnores = savedIgnores; +} + +/*------------------------------------------------------------ */ + +TEST_GROUP(UnityCommandOptions); + +static int savedVerbose; +static unsigned int savedRepeat; +static const char* savedName; +static const char* savedGroup; + +TEST_SETUP(UnityCommandOptions) +{ + savedVerbose = UnityFixture.Verbose; + savedRepeat = UnityFixture.RepeatCount; + savedName = UnityFixture.NameFilter; + savedGroup = UnityFixture.GroupFilter; +} + +TEST_TEAR_DOWN(UnityCommandOptions) +{ + UnityFixture.Verbose = savedVerbose; + UnityFixture.RepeatCount= savedRepeat; + UnityFixture.NameFilter = savedName; + UnityFixture.GroupFilter = savedGroup; +} + + +static const char* noOptions[] = { + "testrunner.exe" +}; + +TEST(UnityCommandOptions, DefaultOptions) +{ + UnityGetCommandLineOptions(1, noOptions); + TEST_ASSERT_EQUAL(0, UnityFixture.Verbose); + TEST_ASSERT_POINTERS_EQUAL(0, UnityFixture.GroupFilter); + TEST_ASSERT_POINTERS_EQUAL(0, UnityFixture.NameFilter); + TEST_ASSERT_EQUAL(1, UnityFixture.RepeatCount); +} + +static const char* verbose[] = { + "testrunner.exe", + "-v" +}; + +TEST(UnityCommandOptions, OptionVerbose) +{ + TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(2, verbose)); + TEST_ASSERT_EQUAL(1, UnityFixture.Verbose); +} + +static const char* group[] = { + "testrunner.exe", + "-g", "groupname" +}; + +TEST(UnityCommandOptions, OptionSelectTestByGroup) +{ + TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(3, group)); + STRCMP_EQUAL("groupname", UnityFixture.GroupFilter); +} + +static const char* name[] = { + "testrunner.exe", + "-n", "testname" +}; + +TEST(UnityCommandOptions, OptionSelectTestByName) +{ + TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(3, name)); + STRCMP_EQUAL("testname", UnityFixture.NameFilter); +} + +static const char* repeat[] = { + "testrunner.exe", + "-r", "99" +}; + +TEST(UnityCommandOptions, OptionSelectRepeatTestsDefaultCount) +{ + TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(2, repeat)); + TEST_ASSERT_EQUAL(2, UnityFixture.RepeatCount); +} + +TEST(UnityCommandOptions, OptionSelectRepeatTestsSpecificCount) +{ + TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(3, repeat)); + TEST_ASSERT_EQUAL(99, UnityFixture.RepeatCount); +} + +static const char* multiple[] = { + "testrunner.exe", + "-v", + "-g", "groupname", + "-n", "testname", + "-r", "98" +}; + +TEST(UnityCommandOptions, MultipleOptions) +{ + TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(8, multiple)); + TEST_ASSERT_EQUAL(1, UnityFixture.Verbose); + STRCMP_EQUAL("groupname", UnityFixture.GroupFilter); + STRCMP_EQUAL("testname", UnityFixture.NameFilter); + TEST_ASSERT_EQUAL(98, UnityFixture.RepeatCount); +} + +static const char* dashRNotLast[] = { + "testrunner.exe", + "-v", + "-g", "gggg", + "-r", + "-n", "tttt", +}; + +TEST(UnityCommandOptions, MultipleOptionsDashRNotLastAndNoValueSpecified) +{ + TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(7, dashRNotLast)); + TEST_ASSERT_EQUAL(1, UnityFixture.Verbose); + STRCMP_EQUAL("gggg", UnityFixture.GroupFilter); + STRCMP_EQUAL("tttt", UnityFixture.NameFilter); + TEST_ASSERT_EQUAL(2, UnityFixture.RepeatCount); +} + +static const char* unknownCommand[] = { + "testrunner.exe", + "-v", + "-g", "groupname", + "-n", "testname", + "-r", "98", + "-z" +}; +TEST(UnityCommandOptions, UnknownCommandIsIgnored) +{ + TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(9, unknownCommand)); + TEST_ASSERT_EQUAL(1, UnityFixture.Verbose); + STRCMP_EQUAL("groupname", UnityFixture.GroupFilter); + STRCMP_EQUAL("testname", UnityFixture.NameFilter); + TEST_ASSERT_EQUAL(98, UnityFixture.RepeatCount); +} + +TEST(UnityCommandOptions, GroupOrNameFilterWithoutStringFails) +{ + TEST_ASSERT_EQUAL(1, UnityGetCommandLineOptions(3, unknownCommand)); + TEST_ASSERT_EQUAL(1, UnityGetCommandLineOptions(5, unknownCommand)); + TEST_ASSERT_EQUAL(1, UnityMain(3, unknownCommand, NULL)); +} + +TEST(UnityCommandOptions, GroupFilterReallyFilters) +{ + UNITY_UINT saved = Unity.NumberOfTests; + TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(4, unknownCommand)); + UnityIgnoreTest(NULL, "non-matching", NULL); + TEST_ASSERT_EQUAL(saved, Unity.NumberOfTests); +} + +IGNORE_TEST(UnityCommandOptions, TestShouldBeIgnored) +{ + TEST_FAIL_MESSAGE("This test should not run!"); +} diff --git a/subprojects/unity/extras/fixture/test/unity_fixture_TestRunner.c b/subprojects/unity/extras/fixture/test/unity_fixture_TestRunner.c new file mode 100644 index 0000000000..ec92663f62 --- /dev/null +++ b/subprojects/unity/extras/fixture/test/unity_fixture_TestRunner.c @@ -0,0 +1,32 @@ +/* ========================================================================= + Unity - A Test Framework for C + ThrowTheSwitch.org + Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams + SPDX-License-Identifier: MIT +========================================================================= */ + +#include "unity_fixture.h" + +TEST_GROUP_RUNNER(UnityFixture) +{ + RUN_TEST_CASE(UnityFixture, PointerSetting); + RUN_TEST_CASE(UnityFixture, PointerSet); + RUN_TEST_CASE(UnityFixture, FreeNULLSafety); + RUN_TEST_CASE(UnityFixture, ConcludeTestIncrementsFailCount); +} + +TEST_GROUP_RUNNER(UnityCommandOptions) +{ + RUN_TEST_CASE(UnityCommandOptions, DefaultOptions); + RUN_TEST_CASE(UnityCommandOptions, OptionVerbose); + RUN_TEST_CASE(UnityCommandOptions, OptionSelectTestByGroup); + RUN_TEST_CASE(UnityCommandOptions, OptionSelectTestByName); + RUN_TEST_CASE(UnityCommandOptions, OptionSelectRepeatTestsDefaultCount); + RUN_TEST_CASE(UnityCommandOptions, OptionSelectRepeatTestsSpecificCount); + RUN_TEST_CASE(UnityCommandOptions, MultipleOptions); + RUN_TEST_CASE(UnityCommandOptions, MultipleOptionsDashRNotLastAndNoValueSpecified); + RUN_TEST_CASE(UnityCommandOptions, UnknownCommandIsIgnored); + RUN_TEST_CASE(UnityCommandOptions, GroupOrNameFilterWithoutStringFails); + RUN_TEST_CASE(UnityCommandOptions, GroupFilterReallyFilters); + RUN_TEST_CASE(UnityCommandOptions, TestShouldBeIgnored); +} diff --git a/subprojects/unity/extras/memory/readme.md b/subprojects/unity/extras/memory/readme.md new file mode 100644 index 0000000000..ea8b9cf706 --- /dev/null +++ b/subprojects/unity/extras/memory/readme.md @@ -0,0 +1,42 @@ +# Unity Memory + +This Framework is an optional add-on to Unity. +By including unity.h and then unity_memory.h, you have the added ability to track malloc and free calls. +This addon requires that the stdlib functions be overridden by its own defines. +These defines will still malloc / realloc / free etc, but will also track the calls in order to ensure that you don't have any memory leaks in your programs. + +Note that this is only useful in situations where a unit is in charge of both the allocation and deallocation of memory. +When it is not symmetric, unit testing can report a number of false failures. +A more advanced runtime tool is required to track complete system memory handling. + +## Module API + +### `UnityMalloc_StartTest` and `UnityMalloc_EndTest` + +These must be called at the beginning and end of each test. +For simplicity, they can be added to `setUp` and `tearDown` in order to do their job. +When using the test runner generator scripts, these will be automatically added to the runner whenever unity_memory.h is included. + +### `UnityMalloc_MakeMallocFailAfterCount` + +This can be called from the tests themselves. +Passing this function a number will force the reference counter to start keeping track of malloc calls. +During that test, if the number of malloc calls exceeds the number given, malloc will immediately start returning `NULL`. +This allows you to test error conditions. +Think of it as a simplified mock. + +## Configuration + +### `UNITY_MALLOC` and `UNITY_FREE` + +By default, this module tries to use the real stdlib `malloc` and `free` internally. +If you would prefer it to use something else, like FreeRTOS's `pvPortMalloc` and `pvPortFree`, then you can use these defines to make it so. + +### `UNITY_EXCLUDE_STDLIB_MALLOC` + +If you would like this library to ignore stdlib or other heap engines completely, and manage the memory on its own, then define this. All memory will be handled internally (and at likely lower overhead). +Note that this is not a very featureful memory manager, but is sufficient for most testing purposes. + +### `UNITY_INTERNAL_HEAP_SIZE_BYTES` + +When using the built-in memory manager (see `UNITY_EXCLUDE_STDLIB_MALLOC`) this define allows you to set the heap size this library will use to manage the memory. diff --git a/subprojects/unity/extras/memory/src/meson.build b/subprojects/unity/extras/memory/src/meson.build new file mode 100644 index 0000000000..650ba32d91 --- /dev/null +++ b/subprojects/unity/extras/memory/src/meson.build @@ -0,0 +1,9 @@ +unity_inc += include_directories('.') +unity_src += files('unity_memory.c') + +if not meson.is_subproject() + install_headers( + 'unity_memory.h', + subdir: meson.project_name() + ) +endif diff --git a/subprojects/unity/extras/memory/src/unity_memory.c b/subprojects/unity/extras/memory/src/unity_memory.c new file mode 100644 index 0000000000..e9eaae35a6 --- /dev/null +++ b/subprojects/unity/extras/memory/src/unity_memory.c @@ -0,0 +1,203 @@ +/* ========================================================================= + Unity - A Test Framework for C + ThrowTheSwitch.org + Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams + SPDX-License-Identifier: MIT +========================================================================= */ + +#include "unity.h" +#include "unity_memory.h" +#include + +#define MALLOC_DONT_FAIL -1 +static int malloc_count; +static int malloc_fail_countdown = MALLOC_DONT_FAIL; + +void UnityMalloc_StartTest(void) +{ + malloc_count = 0; + malloc_fail_countdown = MALLOC_DONT_FAIL; +} + +void UnityMalloc_EndTest(void) +{ + malloc_fail_countdown = MALLOC_DONT_FAIL; + if (malloc_count != 0) + { + UNITY_TEST_FAIL(Unity.CurrentTestLineNumber, "This test leaks!"); + } +} + +void UnityMalloc_MakeMallocFailAfterCount(int countdown) +{ + malloc_fail_countdown = countdown; +} + +/* These definitions are always included from unity_fixture_malloc_overrides.h */ +/* We undef to use them or avoid conflict with per the C standard */ +#undef malloc +#undef free +#undef calloc +#undef realloc + +#ifdef UNITY_EXCLUDE_STDLIB_MALLOC +static unsigned char unity_heap[UNITY_INTERNAL_HEAP_SIZE_BYTES]; +static size_t heap_index; +#else +#include +#endif + +typedef struct GuardBytes +{ + size_t size; + size_t guard_space; +} Guard; + +#define UNITY_MALLOC_ALIGNMENT (UNITY_POINTER_WIDTH / 8) +static const char end[] = "END"; + +static size_t unity_size_round_up(size_t size) +{ + size_t rounded_size; + + rounded_size = ((size + UNITY_MALLOC_ALIGNMENT - 1) / UNITY_MALLOC_ALIGNMENT) * UNITY_MALLOC_ALIGNMENT; + + return rounded_size; +} + +void* unity_malloc(size_t size) +{ + char* mem; + Guard* guard; + size_t total_size; + + total_size = sizeof(Guard) + unity_size_round_up(size + sizeof(end)); + + if (malloc_fail_countdown != MALLOC_DONT_FAIL) + { + if (malloc_fail_countdown == 0) + return NULL; + malloc_fail_countdown--; + } + + if (size == 0) return NULL; +#ifdef UNITY_EXCLUDE_STDLIB_MALLOC + if (heap_index + total_size > UNITY_INTERNAL_HEAP_SIZE_BYTES) + { + guard = NULL; + } + else + { + /* We know we can get away with this cast because we aligned memory already */ + guard = (Guard*)(void*)(&unity_heap[heap_index]); + heap_index += total_size; + } +#else + guard = (Guard*)UNITY_MALLOC(total_size); +#endif + if (guard == NULL) return NULL; + malloc_count++; + guard->size = size; + guard->guard_space = 0; + mem = (char*)&(guard[1]); + memcpy(&mem[size], end, sizeof(end)); + + return (void*)mem; +} + +static int isOverrun(void* mem) +{ + Guard* guard = (Guard*)mem; + char* memAsChar = (char*)mem; + guard--; + + return guard->guard_space != 0 || strcmp(&memAsChar[guard->size], end) != 0; +} + +static void release_memory(void* mem) +{ + Guard* guard = (Guard*)mem; + guard--; + + malloc_count--; +#ifdef UNITY_EXCLUDE_STDLIB_MALLOC + { + size_t block_size; + + block_size = unity_size_round_up(guard->size + sizeof(end)); + + if (mem == unity_heap + heap_index - block_size) + { + heap_index -= (sizeof(Guard) + block_size); + } + } +#else + UNITY_FREE(guard); +#endif +} + +void unity_free(void* mem) +{ + int overrun; + + if (mem == NULL) + { + return; + } + + overrun = isOverrun(mem); + release_memory(mem); + if (overrun) + { + UNITY_TEST_FAIL(Unity.CurrentTestLineNumber, "Buffer overrun detected during free()"); + } +} + +void* unity_calloc(size_t num, size_t size) +{ + void* mem = unity_malloc(num * size); + if (mem == NULL) return NULL; + memset(mem, 0, num * size); + return mem; +} + +void* unity_realloc(void* oldMem, size_t size) +{ + Guard* guard = (Guard*)oldMem; + void* newMem; + + if (oldMem == NULL) return unity_malloc(size); + + guard--; + if (isOverrun(oldMem)) + { + release_memory(oldMem); + UNITY_TEST_FAIL(Unity.CurrentTestLineNumber, "Buffer overrun detected during realloc()"); + } + + if (size == 0) + { + release_memory(oldMem); + return NULL; + } + + if (guard->size >= size) return oldMem; + +#ifdef UNITY_EXCLUDE_STDLIB_MALLOC /* Optimization if memory is expandable */ + { + size_t old_total_size = unity_size_round_up(guard->size + sizeof(end)); + + if ((oldMem == unity_heap + heap_index - old_total_size) && + ((heap_index - old_total_size + unity_size_round_up(size + sizeof(end))) <= UNITY_INTERNAL_HEAP_SIZE_BYTES)) + { + release_memory(oldMem); /* Not thread-safe, like unity_heap generally */ + return unity_malloc(size); /* No memcpy since data is in place */ + } + } +#endif + newMem = unity_malloc(size); + if (newMem == NULL) return NULL; /* Do not release old memory */ + memcpy(newMem, oldMem, guard->size); + release_memory(oldMem); + return newMem; +} diff --git a/subprojects/unity/extras/memory/src/unity_memory.h b/subprojects/unity/extras/memory/src/unity_memory.h new file mode 100644 index 0000000000..70a7f25fc1 --- /dev/null +++ b/subprojects/unity/extras/memory/src/unity_memory.h @@ -0,0 +1,61 @@ +/* ========================================================================= + Unity - A Test Framework for C + ThrowTheSwitch.org + Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams + SPDX-License-Identifier: MIT +========================================================================= */ + +#ifndef UNITY_MEMORY_OVERRIDES_H_ +#define UNITY_MEMORY_OVERRIDES_H_ + +#ifdef __cplusplus +extern "C" +{ +#endif + +#include + +#ifdef UNITY_EXCLUDE_STDLIB_MALLOC +/* Define this macro to remove the use of stdlib.h, malloc, and free. + * Many embedded systems do not have a heap or malloc/free by default. + * This internal unity_malloc() provides allocated memory deterministically from + * the end of an array only, unity_free() only releases from end-of-array, + * blocks are not coalesced, and memory not freed in LIFO order is stranded. */ + #ifndef UNITY_INTERNAL_HEAP_SIZE_BYTES + #define UNITY_INTERNAL_HEAP_SIZE_BYTES 256 + #endif +#endif + +/* These functions are used by Unity to allocate and release memory + * on the heap and can be overridden with platform-specific implementations. + * For example, when using FreeRTOS UNITY_MALLOC becomes pvPortMalloc() + * and UNITY_FREE becomes vPortFree(). */ +#if !defined(UNITY_MALLOC) || !defined(UNITY_FREE) + #include + #define UNITY_MALLOC(size) malloc(size) + #define UNITY_FREE(ptr) free(ptr) +#else + extern void* UNITY_MALLOC(size_t size); + extern void UNITY_FREE(void* ptr); +#endif + +#define malloc unity_malloc +#define calloc unity_calloc +#define realloc unity_realloc +#define free unity_free + +void* unity_malloc(size_t size); +void* unity_calloc(size_t num, size_t size); +void* unity_realloc(void * oldMem, size_t size); +void unity_free(void * mem); + +/* You must compile with malloc replacement, as defined in unity_fixture_malloc_overrides.h */ +void UnityMalloc_StartTest(void); +void UnityMalloc_EndTest(void); +void UnityMalloc_MakeMallocFailAfterCount(int countdown); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/subprojects/unity/extras/memory/test/Makefile b/subprojects/unity/extras/memory/test/Makefile new file mode 100644 index 0000000000..790ab393ce --- /dev/null +++ b/subprojects/unity/extras/memory/test/Makefile @@ -0,0 +1,85 @@ +# ========================================================================= +# Unity - A Test Framework for C +# ThrowTheSwitch.org +# Copyright (c) 2007-24 Mike Karlesky, Mark VanderVoord, & Greg Williams +# SPDX-License-Identifier: MIT +# ========================================================================= + +CC = gcc +ifeq ($(shell uname -s), Darwin) +CC = clang +endif +#DEBUG = -O0 -g +CFLAGS += -std=c99 -pedantic -Wall -Wextra -Werror +CFLAGS += $(DEBUG) +DEFINES = -D UNITY_OUTPUT_CHAR=UnityOutputCharSpy_OutputChar +ifeq ($(OS),Windows_NT) + DEFINES += -D UNITY_OUTPUT_CHAR_HEADER_DECLARATION=UnityOutputCharSpy_OutputChar(int) +else + DEFINES += -D UNITY_OUTPUT_CHAR_HEADER_DECLARATION=UnityOutputCharSpy_OutputChar\(int\) +endif +SRC = ../src/unity_memory.c \ + ../../../src/unity.c \ + unity_memory_Test.c \ + unity_memory_TestRunner.c \ + unity_output_Spy.c \ + +INC_DIR = -I../src -I../../../src/ +BUILD_DIR = ../build +TARGET = ../build/memory_tests.exe + +all: default noStdlibMalloc 32bits + +default: $(BUILD_DIR) + $(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -D UNITY_SUPPORT_64 + @ echo "default build" + ./$(TARGET) + +32bits: $(BUILD_DIR) + $(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -m32 + @ echo "32bits build" + ./$(TARGET) + +noStdlibMalloc: $(BUILD_DIR) + $(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -D UNITY_EXCLUDE_STDLIB_MALLOC + @ echo "build with noStdlibMalloc" + ./$(TARGET) + +C89: CFLAGS += -D UNITY_EXCLUDE_STDINT_H # C89 did not have type 'long long', +C89: $(BUILD_DIR) + $(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -std=c89 && ./$(TARGET) + $(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -D UNITY_EXCLUDE_STDLIB_MALLOC -std=c89 + ./$(TARGET) + +$(BUILD_DIR): + mkdir -p $(BUILD_DIR) + +clean: + rm -f $(TARGET) $(BUILD_DIR)/*.gc* + +cov: $(BUILD_DIR) + cd $(BUILD_DIR) && \ + $(CC) $(DEFINES) $(foreach i, $(SRC), ../test/$(i)) $(INC_DIR) -o $(TARGET) -fprofile-arcs -ftest-coverage + rm -f $(BUILD_DIR)/*.gcda + ./$(TARGET) > /dev/null ; ./$(TARGET) -v > /dev/null + cd $(BUILD_DIR) && \ + gcov unity_memory.c | head -3 + grep '###' $(BUILD_DIR)/unity_memory.c.gcov -C2 || true # Show uncovered lines + +# These extended flags DO get included before any target build runs +CFLAGS += -Wbad-function-cast +CFLAGS += -Wcast-qual +CFLAGS += -Wconversion +CFLAGS += -Wformat=2 +CFLAGS += -Wmissing-prototypes +CFLAGS += -Wold-style-definition +CFLAGS += -Wpointer-arith +CFLAGS += -Wshadow +CFLAGS += -Wstrict-overflow=5 +CFLAGS += -Wstrict-prototypes +CFLAGS += -Wswitch-default +CFLAGS += -Wundef +CFLAGS += -Wno-error=undef # Warning only, this should not stop the build +CFLAGS += -Wunreachable-code +CFLAGS += -Wunused +CFLAGS += -fstrict-aliasing diff --git a/subprojects/unity/extras/memory/test/unity_memory_Test.c b/subprojects/unity/extras/memory/test/unity_memory_Test.c new file mode 100644 index 0000000000..b66e6deb6d --- /dev/null +++ b/subprojects/unity/extras/memory/test/unity_memory_Test.c @@ -0,0 +1,326 @@ +/* ========================================================================= + Unity - A Test Framework for C + ThrowTheSwitch.org + Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams + SPDX-License-Identifier: MIT +========================================================================= */ + +#include "unity.h" +#include "unity_memory.h" +#include "unity_output_Spy.h" +#include +#include + +/* This test module includes the following tests: */ + +void test_ForceMallocFail(void); +void test_ReallocSmallerIsUnchanged(void); +void test_ReallocSameIsUnchanged(void); +void test_ReallocLargerNeeded(void); +void test_ReallocNullPointerIsLikeMalloc(void); +void test_ReallocSizeZeroFreesMemAndReturnsNullPointer(void); +void test_CallocFillsWithZero(void); +void test_FreeNULLSafety(void); +void test_DetectsLeak(void); +void test_BufferOverrunFoundDuringFree(void); +void test_BufferOverrunFoundDuringRealloc(void); +void test_BufferGuardWriteFoundDuringFree(void); +void test_BufferGuardWriteFoundDuringRealloc(void); +void test_MallocPastBufferFails(void); +void test_CallocPastBufferFails(void); +void test_MallocThenReallocGrowsMemoryInPlace(void); +void test_ReallocFailDoesNotFreeMem(void); + +/* It makes use of the following features */ +void setUp(void); +void tearDown(void); + +/* Let's Go! */ +void setUp(void) +{ +#ifdef UNITY_EXCLUDE_STDLIB_MALLOC + UnityOutputCharSpy_Create(200); +#else + UnityOutputCharSpy_Create(1000); +#endif + UnityMalloc_StartTest(); +} + +void tearDown(void) +{ + UnityMalloc_EndTest(); + UnityOutputCharSpy_Destroy(); +} + +void test_ForceMallocFail(void) +{ + void* m; + void* mfails; + UnityMalloc_MakeMallocFailAfterCount(1); + m = malloc(10); + TEST_ASSERT_NOT_NULL(m); + mfails = malloc(10); + TEST_ASSERT_EQUAL_PTR(0, mfails); + free(m); +} + +void test_ReallocSmallerIsUnchanged(void) +{ + void* m1 = malloc(10); + void* m2 = realloc(m1, 5); + TEST_ASSERT_NOT_NULL(m1); + TEST_ASSERT_EQUAL_PTR(m1, m2); + free(m2); +} + +void test_ReallocSameIsUnchanged(void) +{ + void* m1 = malloc(10); + void* m2 = realloc(m1, 10); + TEST_ASSERT_NOT_NULL(m1); + TEST_ASSERT_EQUAL_PTR(m1, m2); + free(m2); +} + +void test_ReallocLargerNeeded(void) +{ + void* m2; + void* m1 = malloc(10); + TEST_ASSERT_NOT_NULL(m1); + strcpy((char*)m1, "123456789"); + m2 = realloc(m1, 15); + TEST_ASSERT_EQUAL_STRING("123456789", m2); + free(m2); +} + +void test_ReallocNullPointerIsLikeMalloc(void) +{ + void* m = realloc(0, 15); + TEST_ASSERT_NOT_NULL(m); + free(m); +} + +void test_ReallocSizeZeroFreesMemAndReturnsNullPointer(void) +{ + void* m1 = malloc(10); + void* m2 = realloc(m1, 0); + TEST_ASSERT_EQUAL_PTR(0, m2); +} + +void test_CallocFillsWithZero(void) +{ + void* m = calloc(3, sizeof(char)); + char* s = (char*)m; + TEST_ASSERT_NOT_NULL(m); + TEST_ASSERT_EQUAL_HEX8(0, s[0]); + TEST_ASSERT_EQUAL_HEX8(0, s[1]); + TEST_ASSERT_EQUAL_HEX8(0, s[2]); + free(m); +} + +void test_FreeNULLSafety(void) +{ + free(NULL); +} + +/*------------------------------------------------------------ */ + +#define EXPECT_ABORT_BEGIN \ + { \ + jmp_buf TestAbortFrame; \ + memcpy(TestAbortFrame, Unity.AbortFrame, sizeof(jmp_buf)); \ + if (TEST_PROTECT()) \ + { + +#define EXPECT_ABORT_END \ + } \ + memcpy(Unity.AbortFrame, TestAbortFrame, sizeof(jmp_buf)); \ + } + +/* This tricky set of defines lets us see if we are using the Spy, returns 1 if true */ +#ifdef __STDC_VERSION__ + +#ifdef UNITY_SUPPORT_VARIADIC_MACROS +#define USING_SPY_AS(a) EXPAND_AND_USE_2ND(ASSIGN_VALUE(a), 0) +#define ASSIGN_VALUE(a) VAL_##a +#define VAL_UnityOutputCharSpy_OutputChar 0, 1 +#define EXPAND_AND_USE_2ND(a, b) SECOND_PARAM(a, b, throwaway) +#define SECOND_PARAM(a, b, ...) b +#if USING_SPY_AS(UNITY_OUTPUT_CHAR) + #define USING_OUTPUT_SPY /* UNITY_OUTPUT_CHAR = UnityOutputCharSpy_OutputChar */ +#endif +#endif /* UNITY_SUPPORT_VARIADIC_MACROS */ + +#else /* __STDC_VERSION__ else */ + +#define UnityOutputCharSpy_OutputChar 42 +#if UNITY_OUTPUT_CHAR == UnityOutputCharSpy_OutputChar /* Works if no -Wundef -Werror */ + #define USING_OUTPUT_SPY +#endif +#undef UnityOutputCharSpy_OutputChar + +#endif /* __STDC_VERSION__ */ + +void test_DetectsLeak(void) +{ +#ifdef USING_OUTPUT_SPY + void* m = malloc(10); + TEST_ASSERT_NOT_NULL(m); + UnityOutputCharSpy_Enable(1); + EXPECT_ABORT_BEGIN + UnityMalloc_EndTest(); + EXPECT_ABORT_END + UnityOutputCharSpy_Enable(0); + Unity.CurrentTestFailed = 0; + TEST_ASSERT_NOT_NULL(strstr(UnityOutputCharSpy_Get(), "This test leaks!")); + free(m); +#else + TEST_IGNORE_MESSAGE("Enable USING_OUTPUT_SPY To Run This Test"); +#endif +} + +void test_BufferOverrunFoundDuringFree(void) +{ +#ifdef USING_OUTPUT_SPY + void* m = malloc(10); + char* s = (char*)m; + TEST_ASSERT_NOT_NULL(m); + s[10] = (char)0xFF; + UnityOutputCharSpy_Enable(1); + EXPECT_ABORT_BEGIN + free(m); + EXPECT_ABORT_END + UnityOutputCharSpy_Enable(0); + Unity.CurrentTestFailed = 0; + TEST_ASSERT_NOT_NULL(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during free()")); +#else + TEST_IGNORE_MESSAGE("Enable USING_OUTPUT_SPY To Run This Test"); +#endif +} + +void test_BufferOverrunFoundDuringRealloc(void) +{ +#ifdef USING_OUTPUT_SPY + void* m = malloc(10); + char* s = (char*)m; + TEST_ASSERT_NOT_NULL(m); + s[10] = (char)0xFF; + UnityOutputCharSpy_Enable(1); + EXPECT_ABORT_BEGIN + m = realloc(m, 100); + EXPECT_ABORT_END + UnityOutputCharSpy_Enable(0); + Unity.CurrentTestFailed = 0; + TEST_ASSERT_NOT_NULL(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during realloc()")); +#else + TEST_IGNORE_MESSAGE("Enable USING_OUTPUT_SPY To Run This Test"); +#endif +} + +void test_BufferGuardWriteFoundDuringFree(void) +{ +#ifdef USING_OUTPUT_SPY + void* m = malloc(10); + char* s = (char*)m; + TEST_ASSERT_NOT_NULL(m); + s[-1] = (char)0x00; /* Will not detect 0 */ + s[-2] = (char)0x01; + UnityOutputCharSpy_Enable(1); + EXPECT_ABORT_BEGIN + free(m); + EXPECT_ABORT_END + UnityOutputCharSpy_Enable(0); + Unity.CurrentTestFailed = 0; + TEST_ASSERT_NOT_NULL(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during free()")); +#else + TEST_IGNORE_MESSAGE("Enable USING_OUTPUT_SPY To Run This Test"); +#endif +} + +void test_BufferGuardWriteFoundDuringRealloc(void) +{ +#ifdef USING_OUTPUT_SPY + void* m = malloc(10); + char* s = (char*)m; + TEST_ASSERT_NOT_NULL(m); + s[-1] = (char)0x0A; + UnityOutputCharSpy_Enable(1); + EXPECT_ABORT_BEGIN + m = realloc(m, 100); + EXPECT_ABORT_END + UnityOutputCharSpy_Enable(0); + Unity.CurrentTestFailed = 0; + TEST_ASSERT_NOT_NULL(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during realloc()")); +#else + TEST_IGNORE_MESSAGE("Enable USING_OUTPUT_SPY To Run This Test"); +#endif +} + +/*------------------------------------------------------------ */ + +#define TEST_ASSERT_MEMORY_ALL_FREE_LIFO_ORDER(first_mem_ptr, ptr) \ + ptr = malloc(10); free(ptr); \ + TEST_ASSERT_EQUAL_PTR_MESSAGE(first_mem_ptr, ptr, "Memory was stranded, free in LIFO order"); + +void test_MallocPastBufferFails(void) +{ +#ifdef UNITY_EXCLUDE_STDLIB_MALLOC + void* m = malloc(UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 1); + void* n = malloc(UNITY_INTERNAL_HEAP_SIZE_BYTES/2); + free(m); + TEST_ASSERT_NOT_NULL(m); + TEST_ASSERT_NULL(n); + TEST_ASSERT_MEMORY_ALL_FREE_LIFO_ORDER(m, n); +#else + TEST_IGNORE_MESSAGE("Enable UNITY_EXCLUDE_STDLIB_MALLOC to Run This Test"); +#endif +} + +void test_CallocPastBufferFails(void) +{ +#ifdef UNITY_EXCLUDE_STDLIB_MALLOC + void* m = calloc(1, UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 1); + void* n = calloc(1, UNITY_INTERNAL_HEAP_SIZE_BYTES/2); + free(m); + TEST_ASSERT_NOT_NULL(m); + TEST_ASSERT_NULL(n); + TEST_ASSERT_MEMORY_ALL_FREE_LIFO_ORDER(m, n); +#else + TEST_IGNORE_MESSAGE("Enable UNITY_EXCLUDE_STDLIB_MALLOC to Run This Test"); +#endif +} + +void test_MallocThenReallocGrowsMemoryInPlace(void) +{ +#ifdef UNITY_EXCLUDE_STDLIB_MALLOC + void* m = malloc(UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 1); + void* n = realloc(m, UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 9); + free(n); + TEST_ASSERT_NOT_NULL(m); + TEST_ASSERT_EQUAL(m, n); + TEST_ASSERT_MEMORY_ALL_FREE_LIFO_ORDER(m, n); +#else + TEST_IGNORE_MESSAGE("Enable UNITY_EXCLUDE_STDLIB_MALLOC to Run This Test"); +#endif +} + +void test_ReallocFailDoesNotFreeMem(void) +{ +#ifdef UNITY_EXCLUDE_STDLIB_MALLOC + void* m = malloc(UNITY_INTERNAL_HEAP_SIZE_BYTES/2); + void* n1 = malloc(10); + void* out_of_mem = realloc(n1, UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 1); + void* n2 = malloc(10); + + free(n2); + if (out_of_mem == NULL) free(n1); + free(m); + + TEST_ASSERT_NOT_NULL(m); /* Got a real memory location */ + TEST_ASSERT_NULL(out_of_mem); /* The realloc should have failed */ + TEST_ASSERT_NOT_EQUAL(n2, n1); /* If n1 != n2 then realloc did not free n1 */ + TEST_ASSERT_MEMORY_ALL_FREE_LIFO_ORDER(m, n2); +#else + TEST_IGNORE_MESSAGE("Enable UNITY_EXCLUDE_STDLIB_MALLOC to Run This Test"); +#endif +} diff --git a/subprojects/unity/extras/memory/test/unity_memory_TestRunner.c b/subprojects/unity/extras/memory/test/unity_memory_TestRunner.c new file mode 100644 index 0000000000..0a8ed3daa8 --- /dev/null +++ b/subprojects/unity/extras/memory/test/unity_memory_TestRunner.c @@ -0,0 +1,50 @@ +/* ========================================================================= + Unity - A Test Framework for C + ThrowTheSwitch.org + Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams + SPDX-License-Identifier: MIT +========================================================================= */ + +#include "unity.h" +#include "unity_memory.h" + +extern void test_ForceMallocFail(void); +extern void test_ReallocSmallerIsUnchanged(void); +extern void test_ReallocSameIsUnchanged(void); +extern void test_ReallocLargerNeeded(void); +extern void test_ReallocNullPointerIsLikeMalloc(void); +extern void test_ReallocSizeZeroFreesMemAndReturnsNullPointer(void); +extern void test_CallocFillsWithZero(void); +extern void test_FreeNULLSafety(void); +extern void test_DetectsLeak(void); +extern void test_BufferOverrunFoundDuringFree(void); +extern void test_BufferOverrunFoundDuringRealloc(void); +extern void test_BufferGuardWriteFoundDuringFree(void); +extern void test_BufferGuardWriteFoundDuringRealloc(void); +extern void test_MallocPastBufferFails(void); +extern void test_CallocPastBufferFails(void); +extern void test_MallocThenReallocGrowsMemoryInPlace(void); +extern void test_ReallocFailDoesNotFreeMem(void); + +int main(void) +{ + UnityBegin("unity_memory_Test.c"); + RUN_TEST(test_ForceMallocFail); + RUN_TEST(test_ReallocSmallerIsUnchanged); + RUN_TEST(test_ReallocSameIsUnchanged); + RUN_TEST(test_ReallocLargerNeeded); + RUN_TEST(test_ReallocNullPointerIsLikeMalloc); + RUN_TEST(test_ReallocSizeZeroFreesMemAndReturnsNullPointer); + RUN_TEST(test_CallocFillsWithZero); + RUN_TEST(test_FreeNULLSafety); + RUN_TEST(test_DetectsLeak); + RUN_TEST(test_BufferOverrunFoundDuringFree); + RUN_TEST(test_BufferOverrunFoundDuringRealloc); + RUN_TEST(test_BufferGuardWriteFoundDuringFree); + RUN_TEST(test_BufferGuardWriteFoundDuringRealloc); + RUN_TEST(test_MallocPastBufferFails); + RUN_TEST(test_CallocPastBufferFails); + RUN_TEST(test_MallocThenReallocGrowsMemoryInPlace); + RUN_TEST(test_ReallocFailDoesNotFreeMem); + return UnityEnd(); +} diff --git a/subprojects/unity/extras/memory/test/unity_output_Spy.c b/subprojects/unity/extras/memory/test/unity_output_Spy.c new file mode 100644 index 0000000000..044c5def22 --- /dev/null +++ b/subprojects/unity/extras/memory/test/unity_output_Spy.c @@ -0,0 +1,57 @@ +/* ========================================================================= + Unity - A Test Framework for C + ThrowTheSwitch.org + Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams + SPDX-License-Identifier: MIT +========================================================================= */ + +#include "unity.h" +#include "unity_output_Spy.h" + +#include +#include +#include + +static int size; +static int count; +static char* buffer; +static int spy_enable; + +void UnityOutputCharSpy_Create(int s) +{ + size = (s > 0) ? s : 0; + count = 0; + spy_enable = 0; + buffer = malloc((size_t)size); + TEST_ASSERT_NOT_NULL_MESSAGE(buffer, "Internal malloc failed in Spy Create():" __FILE__); + memset(buffer, 0, (size_t)size); +} + +void UnityOutputCharSpy_Destroy(void) +{ + size = 0; + free(buffer); +} + +void UnityOutputCharSpy_OutputChar(int c) +{ + if (spy_enable) + { + if (count < (size-1)) + buffer[count++] = (char)c; + } + else + { + putchar(c); + } +} + +const char * UnityOutputCharSpy_Get(void) +{ + return buffer; +} + +void UnityOutputCharSpy_Enable(int enable) +{ + spy_enable = enable; +} diff --git a/subprojects/unity/extras/memory/test/unity_output_Spy.h b/subprojects/unity/extras/memory/test/unity_output_Spy.h new file mode 100644 index 0000000000..3c2e9b97ef --- /dev/null +++ b/subprojects/unity/extras/memory/test/unity_output_Spy.h @@ -0,0 +1,17 @@ +/* ========================================================================= + Unity - A Test Framework for C + ThrowTheSwitch.org + Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams + SPDX-License-Identifier: MIT +========================================================================= */ + +#ifndef UNITY_OUTPUT_SPY_H +#define UNITY_OUTPUT_SPY_H + +void UnityOutputCharSpy_Create(int s); +void UnityOutputCharSpy_Destroy(void); +void UnityOutputCharSpy_OutputChar(int c); +const char * UnityOutputCharSpy_Get(void); +void UnityOutputCharSpy_Enable(int enable); + +#endif diff --git a/subprojects/unity/library.json b/subprojects/unity/library.json new file mode 100644 index 0000000000..839b5abd35 --- /dev/null +++ b/subprojects/unity/library.json @@ -0,0 +1,25 @@ +# ========================================================================= +# Unity - A Test Framework for C +# ThrowTheSwitch.org +# Copyright (c) 2007-24 Mike Karlesky, Mark VanderVoord, & Greg Williams +# SPDX-License-Identifier: MIT +# ========================================================================= + +{ + "name": "Unity", + "version": "2.6.0", + "keywords": "unit-testing, testing, tdd, testing-framework", + "description": "Simple Unit Testing for C", + "homepage": "http://www.throwtheswitch.org/unity", + "license": "MIT", + "repository": { + "type": "git", + "url": "https://github.com/ThrowTheSwitch/Unity.git" + }, + "frameworks": "*", + "platforms": "*", + "headers": "unity.h", + "build": { + "extraScript": "platformio-build.py" + } +} diff --git a/subprojects/unity/meson.build b/subprojects/unity/meson.build new file mode 100644 index 0000000000..6585129c9a --- /dev/null +++ b/subprojects/unity/meson.build @@ -0,0 +1,80 @@ +# +# build script written by : Michael Gene Brockus. +# github repo author: Mike Karlesky, Mark VanderVoord, Greg Williams. +# +# license: MIT +# +project('unity', 'c', + license: 'MIT', + + # Set project version to value extracted from unity.h header + version: run_command( + [ + 'auto/extract_version.py', + 'src/unity.h' + ], + check: true + ).stdout().strip(), + + meson_version: '>=0.47.0', + default_options: [ + 'werror=true', + 'c_std=c11' + ] +) + +build_fixture = get_option('extension_fixture') +build_memory = get_option('extension_memory') +support_double = get_option('support_double') + +unity_args = [] +unity_src = [] +unity_inc = [] + +subdir('src') + +if build_fixture + # Building the fixture extension implies building the memory + # extension. + build_memory = true + subdir('extras/fixture/src') +endif + +if build_memory + subdir('extras/memory/src') +endif + +if support_double + unity_args += '-DUNITY_INCLUDE_DOUBLE' +endif + +unity_lib = static_library(meson.project_name(), + sources: unity_src, + c_args: unity_args, + include_directories: unity_inc, + install: not meson.is_subproject(), +) + +unity_dep = declare_dependency( + link_with: unity_lib, + include_directories: unity_inc +) + +# Generate pkg-config file. +if not meson.is_subproject() + pkg = import('pkgconfig') + pkg.generate( + name: meson.project_name(), + version: meson.project_version(), + libraries: [ unity_lib ], + description: 'C Unit testing framework.' + ) +endif + +# Create a generator that can be used by consumers of our build system to generate +# test runners. +gen_test_runner = generator( + find_program('auto/generate_test_runner.rb'), + output: '@BASENAME@_Runner.c', + arguments: ['@INPUT@', '@OUTPUT@'] +) diff --git a/subprojects/unity/meson_options.txt b/subprojects/unity/meson_options.txt new file mode 100644 index 0000000000..8e66784b80 --- /dev/null +++ b/subprojects/unity/meson_options.txt @@ -0,0 +1,3 @@ +option('extension_fixture', type: 'boolean', value: 'false', description: 'Whether to enable the fixture extension.') +option('extension_memory', type: 'boolean', value: 'false', description: 'Whether to enable the memory extension.') +option('support_double', type: 'boolean', value: 'false', description: 'Whether to enable double precision floating point assertions.') diff --git a/subprojects/unity/platformio-build.py b/subprojects/unity/platformio-build.py new file mode 100644 index 0000000000..51251ddd6d --- /dev/null +++ b/subprojects/unity/platformio-build.py @@ -0,0 +1,24 @@ +# ========================================================================= +# Unity - A Test Framework for C +# ThrowTheSwitch.org +# Copyright (c) 2007-24 Mike Karlesky, Mark VanderVoord, & Greg Williams +# SPDX-License-Identifier: MIT +# ========================================================================= + +import os + +Import("env") + +env.Append(CPPDEFINES=["UNITY_INCLUDE_CONFIG_H"]) + +# import "unity_config.h" folder to the library builder +try: + Import("projenv") + + projenv.Append(CPPDEFINES=["UNITY_INCLUDE_CONFIG_H"]) + for p in projenv["CPPPATH"]: + p = projenv.subst(p) + if os.path.isfile(os.path.join(p, "unity_config.h")): + env.Prepend(CPPPATH=[p]) +except: + pass diff --git a/subprojects/unity/src/meson.build b/subprojects/unity/src/meson.build new file mode 100644 index 0000000000..5365227fcc --- /dev/null +++ b/subprojects/unity/src/meson.build @@ -0,0 +1,17 @@ +# +# build script written by : Michael Gene Brockus. +# github repo author: Mike Karlesky, Mark VanderVoord, Greg Williams. +# +# license: MIT +# + +unity_inc += include_directories('.') +unity_src += files('unity.c') + +if not meson.is_subproject() + install_headers( + 'unity.h', + 'unity_internals.h', + subdir: meson.project_name() + ) +endif diff --git a/subprojects/unity/src/unity.c b/subprojects/unity/src/unity.c new file mode 100644 index 0000000000..7fa2dc6306 --- /dev/null +++ b/subprojects/unity/src/unity.c @@ -0,0 +1,2501 @@ +/* ========================================================================= + Unity - A Test Framework for C + ThrowTheSwitch.org + Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams + SPDX-License-Identifier: MIT +========================================================================= */ + +#include "unity.h" + +#ifndef UNITY_PROGMEM +#define UNITY_PROGMEM +#endif + +/* If omitted from header, declare overrideable prototypes here so they're ready for use */ +#ifdef UNITY_OMIT_OUTPUT_CHAR_HEADER_DECLARATION +void UNITY_OUTPUT_CHAR(int); +#endif + +/* Helpful macros for us to use here in Assert functions */ +#define UNITY_FAIL_AND_BAIL do { Unity.CurrentTestFailed = 1; UNITY_OUTPUT_FLUSH(); TEST_ABORT(); } while (0) +#define UNITY_IGNORE_AND_BAIL do { Unity.CurrentTestIgnored = 1; UNITY_OUTPUT_FLUSH(); TEST_ABORT(); } while (0) +#define RETURN_IF_FAIL_OR_IGNORE do { if (Unity.CurrentTestFailed || Unity.CurrentTestIgnored) { TEST_ABORT(); } } while (0) + +struct UNITY_STORAGE_T Unity; + +#ifdef UNITY_OUTPUT_COLOR +const char UNITY_PROGMEM UnityStrOk[] = "\033[42mOK\033[0m"; +const char UNITY_PROGMEM UnityStrPass[] = "\033[42mPASS\033[0m"; +const char UNITY_PROGMEM UnityStrFail[] = "\033[41mFAIL\033[0m"; +const char UNITY_PROGMEM UnityStrIgnore[] = "\033[43mIGNORE\033[0m"; +#else +const char UNITY_PROGMEM UnityStrOk[] = "OK"; +const char UNITY_PROGMEM UnityStrPass[] = "PASS"; +const char UNITY_PROGMEM UnityStrFail[] = "FAIL"; +const char UNITY_PROGMEM UnityStrIgnore[] = "IGNORE"; +#endif +static const char UNITY_PROGMEM UnityStrNull[] = "NULL"; +static const char UNITY_PROGMEM UnityStrSpacer[] = ". "; +static const char UNITY_PROGMEM UnityStrExpected[] = " Expected "; +static const char UNITY_PROGMEM UnityStrWas[] = " Was "; +static const char UNITY_PROGMEM UnityStrGt[] = " to be greater than "; +static const char UNITY_PROGMEM UnityStrLt[] = " to be less than "; +static const char UNITY_PROGMEM UnityStrOrEqual[] = "or equal to "; +static const char UNITY_PROGMEM UnityStrNotEqual[] = " to be not equal to "; +static const char UNITY_PROGMEM UnityStrElement[] = " Element "; +static const char UNITY_PROGMEM UnityStrByte[] = " Byte "; +static const char UNITY_PROGMEM UnityStrMemory[] = " Memory Mismatch."; +static const char UNITY_PROGMEM UnityStrDelta[] = " Values Not Within Delta "; +static const char UNITY_PROGMEM UnityStrPointless[] = " You Asked Me To Compare Nothing, Which Was Pointless."; +static const char UNITY_PROGMEM UnityStrNullPointerForExpected[] = " Expected pointer to be NULL"; +static const char UNITY_PROGMEM UnityStrNullPointerForActual[] = " Actual pointer was NULL"; +#ifndef UNITY_EXCLUDE_FLOAT +static const char UNITY_PROGMEM UnityStrNot[] = "Not "; +static const char UNITY_PROGMEM UnityStrInf[] = "Infinity"; +static const char UNITY_PROGMEM UnityStrNegInf[] = "Negative Infinity"; +static const char UNITY_PROGMEM UnityStrNaN[] = "NaN"; +static const char UNITY_PROGMEM UnityStrDet[] = "Determinate"; +static const char UNITY_PROGMEM UnityStrInvalidFloatTrait[] = "Invalid Float Trait"; +#endif +const char UNITY_PROGMEM UnityStrErrShorthand[] = "Unity Shorthand Support Disabled"; +const char UNITY_PROGMEM UnityStrErrFloat[] = "Unity Floating Point Disabled"; +const char UNITY_PROGMEM UnityStrErrDouble[] = "Unity Double Precision Disabled"; +const char UNITY_PROGMEM UnityStrErr64[] = "Unity 64-bit Support Disabled"; +static const char UNITY_PROGMEM UnityStrBreaker[] = "-----------------------"; +static const char UNITY_PROGMEM UnityStrResultsTests[] = " Tests "; +static const char UNITY_PROGMEM UnityStrResultsFailures[] = " Failures "; +static const char UNITY_PROGMEM UnityStrResultsIgnored[] = " Ignored "; +#ifndef UNITY_EXCLUDE_DETAILS +static const char UNITY_PROGMEM UnityStrDetail1Name[] = UNITY_DETAIL1_NAME " "; +static const char UNITY_PROGMEM UnityStrDetail2Name[] = " " UNITY_DETAIL2_NAME " "; +#endif +/*----------------------------------------------- + * Pretty Printers & Test Result Output Handlers + *-----------------------------------------------*/ + +/*-----------------------------------------------*/ +/* Local helper function to print characters. */ +static void UnityPrintChar(const char* pch) +{ + /* printable characters plus CR & LF are printed */ + if ((*pch <= 126) && (*pch >= 32)) + { + UNITY_OUTPUT_CHAR(*pch); + } + /* write escaped carriage returns */ + else if (*pch == 13) + { + UNITY_OUTPUT_CHAR('\\'); + UNITY_OUTPUT_CHAR('r'); + } + /* write escaped line feeds */ + else if (*pch == 10) + { + UNITY_OUTPUT_CHAR('\\'); + UNITY_OUTPUT_CHAR('n'); + } + /* unprintable characters are shown as codes */ + else + { + UNITY_OUTPUT_CHAR('\\'); + UNITY_OUTPUT_CHAR('x'); + UnityPrintNumberHex((UNITY_UINT)*pch, 2); + } +} + +/*-----------------------------------------------*/ +/* Local helper function to print ANSI escape strings e.g. "\033[42m". */ +#ifdef UNITY_OUTPUT_COLOR +static UNITY_UINT UnityPrintAnsiEscapeString(const char* string) +{ + const char* pch = string; + UNITY_UINT count = 0; + + while (*pch && (*pch != 'm')) + { + UNITY_OUTPUT_CHAR(*pch); + pch++; + count++; + } + UNITY_OUTPUT_CHAR('m'); + count++; + + return count; +} +#endif + +/*-----------------------------------------------*/ +void UnityPrint(const char* string) +{ + const char* pch = string; + + if (pch != NULL) + { + while (*pch) + { +#ifdef UNITY_OUTPUT_COLOR + /* print ANSI escape code */ + if ((*pch == 27) && (*(pch + 1) == '[')) + { + pch += UnityPrintAnsiEscapeString(pch); + continue; + } +#endif + UnityPrintChar(pch); + pch++; + } + } +} +/*-----------------------------------------------*/ +void UnityPrintLen(const char* string, const UNITY_UINT32 length) +{ + const char* pch = string; + + if (pch != NULL) + { + while (*pch && ((UNITY_UINT32)(pch - string) < length)) + { + /* printable characters plus CR & LF are printed */ + if ((*pch <= 126) && (*pch >= 32)) + { + UNITY_OUTPUT_CHAR(*pch); + } + /* write escaped carriage returns */ + else if (*pch == 13) + { + UNITY_OUTPUT_CHAR('\\'); + UNITY_OUTPUT_CHAR('r'); + } + /* write escaped line feeds */ + else if (*pch == 10) + { + UNITY_OUTPUT_CHAR('\\'); + UNITY_OUTPUT_CHAR('n'); + } + /* unprintable characters are shown as codes */ + else + { + UNITY_OUTPUT_CHAR('\\'); + UNITY_OUTPUT_CHAR('x'); + UnityPrintNumberHex((UNITY_UINT)*pch, 2); + } + pch++; + } + } +} + +/*-----------------------------------------------*/ +void UnityPrintNumberByStyle(const UNITY_INT number, const UNITY_DISPLAY_STYLE_T style) +{ + if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) + { + if (style == UNITY_DISPLAY_STYLE_CHAR) + { + /* printable characters plus CR & LF are printed */ + UNITY_OUTPUT_CHAR('\''); + if ((number <= 126) && (number >= 32)) + { + UNITY_OUTPUT_CHAR((int)number); + } + /* write escaped carriage returns */ + else if (number == 13) + { + UNITY_OUTPUT_CHAR('\\'); + UNITY_OUTPUT_CHAR('r'); + } + /* write escaped line feeds */ + else if (number == 10) + { + UNITY_OUTPUT_CHAR('\\'); + UNITY_OUTPUT_CHAR('n'); + } + /* unprintable characters are shown as codes */ + else + { + UNITY_OUTPUT_CHAR('\\'); + UNITY_OUTPUT_CHAR('x'); + UnityPrintNumberHex((UNITY_UINT)number, 2); + } + UNITY_OUTPUT_CHAR('\''); + } + else + { + UnityPrintNumber(number); + } + } + else if ((style & UNITY_DISPLAY_RANGE_UINT) == UNITY_DISPLAY_RANGE_UINT) + { + UnityPrintNumberUnsigned((UNITY_UINT)number); + } + else + { + UNITY_OUTPUT_CHAR('0'); + UNITY_OUTPUT_CHAR('x'); + UnityPrintNumberHex((UNITY_UINT)number, (char)((style & 0xF) * 2)); + } +} + +/*-----------------------------------------------*/ +void UnityPrintNumber(const UNITY_INT number_to_print) +{ + UNITY_UINT number = (UNITY_UINT)number_to_print; + + if (number_to_print < 0) + { + /* A negative number, including MIN negative */ + UNITY_OUTPUT_CHAR('-'); + number = (~number) + 1; + } + UnityPrintNumberUnsigned(number); +} + +/*----------------------------------------------- + * basically do an itoa using as little ram as possible */ +void UnityPrintNumberUnsigned(const UNITY_UINT number) +{ + UNITY_UINT divisor = 1; + + /* figure out initial divisor */ + while (number / divisor > 9) + { + divisor *= 10; + } + + /* now mod and print, then divide divisor */ + do + { + UNITY_OUTPUT_CHAR((char)('0' + (number / divisor % 10))); + divisor /= 10; + } while (divisor > 0); +} + +/*-----------------------------------------------*/ +void UnityPrintNumberHex(const UNITY_UINT number, const char nibbles_to_print) +{ + int nibble; + char nibbles = nibbles_to_print; + + if ((unsigned)nibbles > UNITY_MAX_NIBBLES) + { + nibbles = UNITY_MAX_NIBBLES; + } + + while (nibbles > 0) + { + nibbles--; + nibble = (int)(number >> (nibbles * 4)) & 0x0F; + if (nibble <= 9) + { + UNITY_OUTPUT_CHAR((char)('0' + nibble)); + } + else + { + UNITY_OUTPUT_CHAR((char)('A' - 10 + nibble)); + } + } +} + +/*-----------------------------------------------*/ +void UnityPrintMask(const UNITY_UINT mask, const UNITY_UINT number) +{ + UNITY_UINT current_bit = (UNITY_UINT)1 << (UNITY_INT_WIDTH - 1); + UNITY_INT32 i; + + for (i = 0; i < UNITY_INT_WIDTH; i++) + { + if (current_bit & mask) + { + if (current_bit & number) + { + UNITY_OUTPUT_CHAR('1'); + } + else + { + UNITY_OUTPUT_CHAR('0'); + } + } + else + { + UNITY_OUTPUT_CHAR('X'); + } + current_bit = current_bit >> 1; + } +} + +/*-----------------------------------------------*/ +#ifndef UNITY_EXCLUDE_FLOAT_PRINT +/* + * This function prints a floating-point value in a format similar to + * printf("%.7g") on a single-precision machine or printf("%.9g") on a + * double-precision machine. The 7th digit won't always be totally correct + * in single-precision operation (for that level of accuracy, a more + * complicated algorithm would be needed). + */ +void UnityPrintFloat(const UNITY_DOUBLE input_number) +{ +#ifdef UNITY_INCLUDE_DOUBLE + static const int sig_digits = 9; + static const UNITY_INT32 min_scaled = 100000000; + static const UNITY_INT32 max_scaled = 1000000000; +#else + static const int sig_digits = 7; + static const UNITY_INT32 min_scaled = 1000000; + static const UNITY_INT32 max_scaled = 10000000; +#endif + + UNITY_DOUBLE number = input_number; + + /* print minus sign (does not handle negative zero) */ + if (number < 0.0f) + { + UNITY_OUTPUT_CHAR('-'); + number = -number; + } + + /* handle zero, NaN, and +/- infinity */ + if (number == 0.0f) + { + UnityPrint("0"); + } + else if (UNITY_IS_NAN(number)) + { + UnityPrint("nan"); + } + else if (UNITY_IS_INF(number)) + { + UnityPrint("inf"); + } + else + { + UNITY_INT32 n_int = 0; + UNITY_INT32 n; + int exponent = 0; + int decimals; + int digits; + char buf[16] = {0}; + + /* + * Scale up or down by powers of 10. To minimize rounding error, + * start with a factor/divisor of 10^10, which is the largest + * power of 10 that can be represented exactly. Finally, compute + * (exactly) the remaining power of 10 and perform one more + * multiplication or division. + */ + if (number < 1.0f) + { + UNITY_DOUBLE factor = 1.0f; + + while (number < (UNITY_DOUBLE)max_scaled / 1e10f) { number *= 1e10f; exponent -= 10; } + while (number * factor < (UNITY_DOUBLE)min_scaled) { factor *= 10.0f; exponent--; } + + number *= factor; + } + else if (number > (UNITY_DOUBLE)max_scaled) + { + UNITY_DOUBLE divisor = 1.0f; + + while (number > (UNITY_DOUBLE)min_scaled * 1e10f) { number /= 1e10f; exponent += 10; } + while (number / divisor > (UNITY_DOUBLE)max_scaled) { divisor *= 10.0f; exponent++; } + + number /= divisor; + } + else + { + /* + * In this range, we can split off the integer part before + * doing any multiplications. This reduces rounding error by + * freeing up significant bits in the fractional part. + */ + UNITY_DOUBLE factor = 1.0f; + n_int = (UNITY_INT32)number; + number -= (UNITY_DOUBLE)n_int; + + while (n_int < min_scaled) { n_int *= 10; factor *= 10.0f; exponent--; } + + number *= factor; + } + + /* round to nearest integer */ + n = ((UNITY_INT32)(number + number) + 1) / 2; + +#ifndef UNITY_ROUND_TIES_AWAY_FROM_ZERO + /* round to even if exactly between two integers */ + if ((n & 1) && (((UNITY_DOUBLE)n - number) == 0.5f)) + n--; +#endif + + n += n_int; + + if (n >= max_scaled) + { + n = min_scaled; + exponent++; + } + + /* determine where to place decimal point */ + decimals = ((exponent <= 0) && (exponent >= -(sig_digits + 3))) ? (-exponent) : (sig_digits - 1); + exponent += decimals; + + /* truncate trailing zeroes after decimal point */ + while ((decimals > 0) && ((n % 10) == 0)) + { + n /= 10; + decimals--; + } + + /* build up buffer in reverse order */ + digits = 0; + while ((n != 0) || (digits <= decimals)) + { + buf[digits++] = (char)('0' + n % 10); + n /= 10; + } + + /* print out buffer (backwards) */ + 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 */ + +/*-----------------------------------------------*/ +static void UnityTestResultsBegin(const char* file, const UNITY_LINE_TYPE line) +{ +#ifdef UNITY_OUTPUT_FOR_ECLIPSE + UNITY_OUTPUT_CHAR('('); + UnityPrint(file); + UNITY_OUTPUT_CHAR(':'); + UnityPrintNumber((UNITY_INT)line); + UNITY_OUTPUT_CHAR(')'); + UNITY_OUTPUT_CHAR(' '); + UnityPrint(Unity.CurrentTestName); + UNITY_OUTPUT_CHAR(':'); +#else +#ifdef UNITY_OUTPUT_FOR_IAR_WORKBENCH + UnityPrint("'); + UnityPrint(Unity.CurrentTestName); + UnityPrint(" "); +#else +#ifdef UNITY_OUTPUT_FOR_QT_CREATOR + UnityPrint("file://"); + UnityPrint(file); + UNITY_OUTPUT_CHAR(':'); + UnityPrintNumber((UNITY_INT)line); + UNITY_OUTPUT_CHAR(' '); + UnityPrint(Unity.CurrentTestName); + UNITY_OUTPUT_CHAR(':'); +#else + UnityPrint(file); + UNITY_OUTPUT_CHAR(':'); + UnityPrintNumber((UNITY_INT)line); + UNITY_OUTPUT_CHAR(':'); + UnityPrint(Unity.CurrentTestName); + UNITY_OUTPUT_CHAR(':'); +#endif +#endif +#endif +} + +/*-----------------------------------------------*/ +static void UnityTestResultsFailBegin(const UNITY_LINE_TYPE line) +{ + UnityTestResultsBegin(Unity.TestFile, line); + UnityPrint(UnityStrFail); + UNITY_OUTPUT_CHAR(':'); +} + +/*-----------------------------------------------*/ +void UnityConcludeTest(void) +{ + if (Unity.CurrentTestIgnored) + { + Unity.TestIgnores++; + } + else if (!Unity.CurrentTestFailed) + { + UnityTestResultsBegin(Unity.TestFile, Unity.CurrentTestLineNumber); + UnityPrint(UnityStrPass); + } + else + { + Unity.TestFailures++; + } + + Unity.CurrentTestFailed = 0; + Unity.CurrentTestIgnored = 0; + UNITY_PRINT_EXEC_TIME(); + UNITY_PRINT_EOL(); + UNITY_FLUSH_CALL(); +} + +/*-----------------------------------------------*/ +static void UnityAddMsgIfSpecified(const char* msg) +{ +#ifdef UNITY_PRINT_TEST_CONTEXT + UnityPrint(UnityStrSpacer); + UNITY_PRINT_TEST_CONTEXT(); +#endif +#ifndef UNITY_EXCLUDE_DETAILS + if (Unity.CurrentDetail1) + { + UnityPrint(UnityStrSpacer); + UnityPrint(UnityStrDetail1Name); + UnityPrint(Unity.CurrentDetail1); + if (Unity.CurrentDetail2) + { + UnityPrint(UnityStrDetail2Name); + UnityPrint(Unity.CurrentDetail2); + } + } +#endif + if (msg) + { + UnityPrint(UnityStrSpacer); + UnityPrint(msg); + } +} + +/*-----------------------------------------------*/ +static void UnityPrintExpectedAndActualStrings(const char* expected, const char* actual) +{ + UnityPrint(UnityStrExpected); + if (expected != NULL) + { + UNITY_OUTPUT_CHAR('\''); + UnityPrint(expected); + UNITY_OUTPUT_CHAR('\''); + } + else + { + UnityPrint(UnityStrNull); + } + UnityPrint(UnityStrWas); + if (actual != NULL) + { + UNITY_OUTPUT_CHAR('\''); + UnityPrint(actual); + UNITY_OUTPUT_CHAR('\''); + } + else + { + UnityPrint(UnityStrNull); + } +} + +/*-----------------------------------------------*/ +static void UnityPrintExpectedAndActualStringsLen(const char* expected, + const char* actual, + const UNITY_UINT32 length) +{ + UnityPrint(UnityStrExpected); + if (expected != NULL) + { + UNITY_OUTPUT_CHAR('\''); + UnityPrintLen(expected, length); + UNITY_OUTPUT_CHAR('\''); + } + else + { + UnityPrint(UnityStrNull); + } + UnityPrint(UnityStrWas); + if (actual != NULL) + { + UNITY_OUTPUT_CHAR('\''); + UnityPrintLen(actual, length); + UNITY_OUTPUT_CHAR('\''); + } + else + { + UnityPrint(UnityStrNull); + } +} + +/*----------------------------------------------- + * Assertion & Control Helpers + *-----------------------------------------------*/ + +/*-----------------------------------------------*/ +static int UnityIsOneArrayNull(UNITY_INTERNAL_PTR expected, + UNITY_INTERNAL_PTR actual, + const UNITY_LINE_TYPE lineNumber, + const char* msg) +{ + /* Both are NULL or same pointer */ + if (expected == actual) { return 0; } + + /* print and return true if just expected is NULL */ + if (expected == NULL) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrNullPointerForExpected); + UnityAddMsgIfSpecified(msg); + return 1; + } + + /* print and return true if just actual is NULL */ + if (actual == NULL) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrNullPointerForActual); + UnityAddMsgIfSpecified(msg); + return 1; + } + + return 0; /* return false if neither is NULL */ +} + +/*----------------------------------------------- + * Assertion Functions + *-----------------------------------------------*/ + +/*-----------------------------------------------*/ +void UnityAssertBits(const UNITY_INT mask, + const UNITY_INT expected, + const UNITY_INT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber) +{ + RETURN_IF_FAIL_OR_IGNORE; + + if ((mask & expected) != (mask & actual)) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrExpected); + UnityPrintMask((UNITY_UINT)mask, (UNITY_UINT)expected); + UnityPrint(UnityStrWas); + UnityPrintMask((UNITY_UINT)mask, (UNITY_UINT)actual); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +/*-----------------------------------------------*/ +void UnityAssertEqualNumber(const UNITY_INT expected, + const UNITY_INT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_DISPLAY_STYLE_T style) +{ + RETURN_IF_FAIL_OR_IGNORE; + + if (expected != actual) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrExpected); + UnityPrintNumberByStyle(expected, style); + UnityPrint(UnityStrWas); + UnityPrintNumberByStyle(actual, style); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +/*-----------------------------------------------*/ +void UnityAssertGreaterOrLessOrEqualNumber(const UNITY_INT threshold, + const UNITY_INT actual, + const UNITY_COMPARISON_T compare, + const char *msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_DISPLAY_STYLE_T style) +{ + int failed = 0; + RETURN_IF_FAIL_OR_IGNORE; + + if ((threshold == actual) && (compare & UNITY_EQUAL_TO)) { return; } + if ((threshold == actual)) { failed = 1; } + + if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) + { + if ((actual > threshold) && (compare & UNITY_SMALLER_THAN)) { failed = 1; } + if ((actual < threshold) && (compare & UNITY_GREATER_THAN)) { failed = 1; } + } + else /* UINT or HEX */ + { + if (((UNITY_UINT)actual > (UNITY_UINT)threshold) && (compare & UNITY_SMALLER_THAN)) { failed = 1; } + if (((UNITY_UINT)actual < (UNITY_UINT)threshold) && (compare & UNITY_GREATER_THAN)) { failed = 1; } + } + + if (failed) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrExpected); + UnityPrintNumberByStyle(actual, style); + if (compare & UNITY_GREATER_THAN) { UnityPrint(UnityStrGt); } + if (compare & UNITY_SMALLER_THAN) { UnityPrint(UnityStrLt); } + if (compare & UNITY_EQUAL_TO) { UnityPrint(UnityStrOrEqual); } + if (compare == UNITY_NOT_EQUAL) { UnityPrint(UnityStrNotEqual); } + UnityPrintNumberByStyle(threshold, style); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +#define UnityPrintPointlessAndBail() \ +do { \ + UnityTestResultsFailBegin(lineNumber); \ + UnityPrint(UnityStrPointless); \ + UnityAddMsgIfSpecified(msg); \ + UNITY_FAIL_AND_BAIL; \ +} while (0) + +/*-----------------------------------------------*/ +void UnityAssertEqualIntArray(UNITY_INTERNAL_PTR expected, + UNITY_INTERNAL_PTR actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_DISPLAY_STYLE_T style, + const UNITY_FLAGS_T flags) +{ + UNITY_UINT32 elements = num_elements; + unsigned int length = style & 0xF; + unsigned int increment = 0; + + RETURN_IF_FAIL_OR_IGNORE; + + if (num_elements == 0) + { +#ifdef UNITY_COMPARE_PTRS_ON_ZERO_ARRAY + UNITY_TEST_ASSERT_EQUAL_PTR(expected, actual, lineNumber, msg); +#else + UnityPrintPointlessAndBail(); +#endif + } + + if (expected == actual) + { + return; /* Both are NULL or same pointer */ + } + + if (UnityIsOneArrayNull(expected, actual, lineNumber, msg)) + { + UNITY_FAIL_AND_BAIL; + } + + while ((elements > 0) && (elements--)) + { + UNITY_INT expect_val; + UNITY_INT actual_val; + + switch (length) + { + case 1: + expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT8*)expected; + actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT8*)actual; + if (style & (UNITY_DISPLAY_RANGE_UINT | UNITY_DISPLAY_RANGE_HEX)) + { + expect_val &= 0x000000FF; + actual_val &= 0x000000FF; + } + increment = sizeof(UNITY_INT8); + break; + + case 2: + expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT16*)expected; + actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT16*)actual; + if (style & (UNITY_DISPLAY_RANGE_UINT | UNITY_DISPLAY_RANGE_HEX)) + { + expect_val &= 0x0000FFFF; + actual_val &= 0x0000FFFF; + } + increment = sizeof(UNITY_INT16); + break; + +#ifdef UNITY_SUPPORT_64 + case 8: + expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT64*)expected; + actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT64*)actual; + increment = sizeof(UNITY_INT64); + break; +#endif + + default: /* default is length 4 bytes */ + case 4: + expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT32*)expected; + actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT32*)actual; +#ifdef UNITY_SUPPORT_64 + if (style & (UNITY_DISPLAY_RANGE_UINT | UNITY_DISPLAY_RANGE_HEX)) + { + expect_val &= 0x00000000FFFFFFFF; + actual_val &= 0x00000000FFFFFFFF; + } +#endif + increment = sizeof(UNITY_INT32); + length = 4; + break; + } + + if (expect_val != actual_val) + { + if ((style & UNITY_DISPLAY_RANGE_UINT) && (length < (UNITY_INT_WIDTH / 8))) + { /* For UINT, remove sign extension (padding 1's) from signed type casts above */ + UNITY_INT mask = 1; + mask = (mask << 8 * length) - 1; + expect_val &= mask; + actual_val &= mask; + } + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrElement); + UnityPrintNumberUnsigned(num_elements - elements - 1); + UnityPrint(UnityStrExpected); + UnityPrintNumberByStyle(expect_val, style); + UnityPrint(UnityStrWas); + UnityPrintNumberByStyle(actual_val, style); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } + /* Walk through array by incrementing the pointers */ + if (flags == UNITY_ARRAY_TO_ARRAY) + { + expected = (UNITY_INTERNAL_PTR)((const char*)expected + increment); + } + actual = (UNITY_INTERNAL_PTR)((const char*)actual + increment); + } +} + +/*-----------------------------------------------*/ +#ifndef UNITY_EXCLUDE_FLOAT +/* Wrap this define in a function with variable types as float or double */ +#define UNITY_FLOAT_OR_DOUBLE_WITHIN(delta, expected, actual, diff) \ + if (UNITY_IS_INF(expected) && UNITY_IS_INF(actual) && (((expected) < 0) == ((actual) < 0))) return 1; \ + if (UNITY_NAN_CHECK) return 1; \ + (diff) = (actual) - (expected); \ + if ((diff) < 0) (diff) = -(diff); \ + if ((delta) < 0) (delta) = -(delta); \ + return !(UNITY_IS_NAN(diff) || UNITY_IS_INF(diff) || ((diff) > (delta))) + /* This first part of this condition will catch any NaN or Infinite values */ +#ifndef UNITY_NAN_NOT_EQUAL_NAN + #define UNITY_NAN_CHECK UNITY_IS_NAN(expected) && UNITY_IS_NAN(actual) +#else + #define UNITY_NAN_CHECK 0 +#endif + +#ifndef UNITY_EXCLUDE_FLOAT_PRINT + #define UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT(expected, actual) \ + do { \ + UnityPrint(UnityStrExpected); \ + UnityPrintFloat(expected); \ + UnityPrint(UnityStrWas); \ + UnityPrintFloat(actual); \ + } while (0) +#else + #define UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT(expected, actual) \ + UnityPrint(UnityStrDelta) +#endif /* UNITY_EXCLUDE_FLOAT_PRINT */ + +/*-----------------------------------------------*/ +static int UnityFloatsWithin(UNITY_FLOAT delta, UNITY_FLOAT expected, UNITY_FLOAT actual) +{ + UNITY_FLOAT diff; + UNITY_FLOAT_OR_DOUBLE_WITHIN(delta, expected, actual, diff); +} + +/*-----------------------------------------------*/ +void UnityAssertWithinFloatArray(const UNITY_FLOAT delta, + UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* expected, + UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLAGS_T flags) +{ + UNITY_UINT32 elements = num_elements; + UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* ptr_expected = expected; + UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* ptr_actual = actual; + UNITY_FLOAT in_delta = delta; + UNITY_FLOAT current_element_delta = delta; + + RETURN_IF_FAIL_OR_IGNORE; + + if (elements == 0) + { +#ifdef UNITY_COMPARE_PTRS_ON_ZERO_ARRAY + UNITY_TEST_ASSERT_EQUAL_PTR(expected, actual, lineNumber, msg); +#else + UnityPrintPointlessAndBail(); +#endif + } + + if (UNITY_IS_INF(in_delta)) + { + return; /* Arrays will be force equal with infinite delta */ + } + + if (UNITY_IS_NAN(in_delta)) + { + /* Delta must be correct number */ + UnityPrintPointlessAndBail(); + } + + if (expected == actual) + { + return; /* Both are NULL or same pointer */ + } + + if (UnityIsOneArrayNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg)) + { + UNITY_FAIL_AND_BAIL; + } + + /* fix delta sign if need */ + if (in_delta < 0) + { + in_delta = -in_delta; + } + + while (elements--) + { + current_element_delta = *ptr_expected * UNITY_FLOAT_PRECISION; + + if (current_element_delta < 0) + { + /* fix delta sign for correct calculations */ + current_element_delta = -current_element_delta; + } + + if (!UnityFloatsWithin(in_delta + current_element_delta, *ptr_expected, *ptr_actual)) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrElement); + UnityPrintNumberUnsigned(num_elements - elements - 1); + UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT((UNITY_DOUBLE)*ptr_expected, (UNITY_DOUBLE)*ptr_actual); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } + if (flags == UNITY_ARRAY_TO_ARRAY) + { + ptr_expected++; + } + ptr_actual++; + } +} + +/*-----------------------------------------------*/ +void UnityAssertFloatsWithin(const UNITY_FLOAT delta, + const UNITY_FLOAT expected, + const UNITY_FLOAT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber) +{ + RETURN_IF_FAIL_OR_IGNORE; + + + if (!UnityFloatsWithin(delta, expected, actual)) + { + UnityTestResultsFailBegin(lineNumber); + UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT((UNITY_DOUBLE)expected, (UNITY_DOUBLE)actual); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +/*-----------------------------------------------*/ +void UnityAssertFloatsNotWithin(const UNITY_FLOAT delta, + const UNITY_FLOAT expected, + const UNITY_FLOAT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber) +{ + RETURN_IF_FAIL_OR_IGNORE; + + if (UnityFloatsWithin(delta, expected, actual)) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrExpected); + UnityPrintFloat((UNITY_DOUBLE)expected); + UnityPrint(UnityStrNotEqual); + UnityPrintFloat((UNITY_DOUBLE)actual); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +/*-----------------------------------------------*/ +void UnityAssertGreaterOrLessFloat(const UNITY_FLOAT threshold, + const UNITY_FLOAT actual, + const UNITY_COMPARISON_T compare, + const char* msg, + const UNITY_LINE_TYPE lineNumber) +{ + int failed; + + RETURN_IF_FAIL_OR_IGNORE; + + failed = 0; + + /* Checking for "not success" rather than failure to get the right result for NaN */ + if (!(actual < threshold) && (compare & UNITY_SMALLER_THAN)) { failed = 1; } + if (!(actual > threshold) && (compare & UNITY_GREATER_THAN)) { failed = 1; } + + if ((compare & UNITY_EQUAL_TO) && UnityFloatsWithin(threshold * UNITY_FLOAT_PRECISION, threshold, actual)) { failed = 0; } + + if (failed) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrExpected); + UnityPrintFloat(actual); + if (compare & UNITY_GREATER_THAN) { UnityPrint(UnityStrGt); } + if (compare & UNITY_SMALLER_THAN) { UnityPrint(UnityStrLt); } + if (compare & UNITY_EQUAL_TO) { UnityPrint(UnityStrOrEqual); } + UnityPrintFloat(threshold); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +/*-----------------------------------------------*/ +void UnityAssertFloatSpecial(const UNITY_FLOAT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLOAT_TRAIT_T style) +{ + const char* trait_names[] = {UnityStrInf, UnityStrNegInf, UnityStrNaN, UnityStrDet}; + UNITY_INT should_be_trait = ((UNITY_INT)style & 1); + UNITY_INT is_trait = !should_be_trait; + UNITY_INT trait_index = (UNITY_INT)(style >> 1); + + RETURN_IF_FAIL_OR_IGNORE; + + switch (style) + { + case UNITY_FLOAT_IS_INF: + case UNITY_FLOAT_IS_NOT_INF: + is_trait = UNITY_IS_INF(actual) && (actual > 0); + break; + case UNITY_FLOAT_IS_NEG_INF: + case UNITY_FLOAT_IS_NOT_NEG_INF: + is_trait = UNITY_IS_INF(actual) && (actual < 0); + break; + + case UNITY_FLOAT_IS_NAN: + case UNITY_FLOAT_IS_NOT_NAN: + is_trait = UNITY_IS_NAN(actual) ? 1 : 0; + break; + + case UNITY_FLOAT_IS_DET: /* A determinate number is non infinite and not NaN. */ + case UNITY_FLOAT_IS_NOT_DET: + is_trait = !UNITY_IS_INF(actual) && !UNITY_IS_NAN(actual); + break; + + case UNITY_FLOAT_INVALID_TRAIT: /* Supress warning */ + default: /* including UNITY_FLOAT_INVALID_TRAIT */ + trait_index = 0; + trait_names[0] = UnityStrInvalidFloatTrait; + break; + } + + if (is_trait != should_be_trait) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrExpected); + if (!should_be_trait) + { + UnityPrint(UnityStrNot); + } + UnityPrint(trait_names[trait_index]); + UnityPrint(UnityStrWas); +#ifndef UNITY_EXCLUDE_FLOAT_PRINT + UnityPrintFloat((UNITY_DOUBLE)actual); +#else + if (should_be_trait) + { + UnityPrint(UnityStrNot); + } + UnityPrint(trait_names[trait_index]); +#endif + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +#endif /* not UNITY_EXCLUDE_FLOAT */ + +/*-----------------------------------------------*/ +#ifndef UNITY_EXCLUDE_DOUBLE +static int UnityDoublesWithin(UNITY_DOUBLE delta, UNITY_DOUBLE expected, UNITY_DOUBLE actual) +{ + UNITY_DOUBLE diff; + UNITY_FLOAT_OR_DOUBLE_WITHIN(delta, expected, actual, diff); +} + +/*-----------------------------------------------*/ +void UnityAssertWithinDoubleArray(const UNITY_DOUBLE delta, + UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* expected, + UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLAGS_T flags) +{ + UNITY_UINT32 elements = num_elements; + UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* ptr_expected = expected; + UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* ptr_actual = actual; + UNITY_DOUBLE in_delta = delta; + UNITY_DOUBLE current_element_delta = delta; + + RETURN_IF_FAIL_OR_IGNORE; + + if (elements == 0) + { +#ifdef UNITY_COMPARE_PTRS_ON_ZERO_ARRAY + UNITY_TEST_ASSERT_EQUAL_PTR(expected, actual, lineNumber, msg); +#else + UnityPrintPointlessAndBail(); +#endif + } + + if (UNITY_IS_INF(in_delta)) + { + return; /* Arrays will be force equal with infinite delta */ + } + + if (UNITY_IS_NAN(in_delta)) + { + /* Delta must be correct number */ + UnityPrintPointlessAndBail(); + } + + if (expected == actual) + { + return; /* Both are NULL or same pointer */ + } + + if (UnityIsOneArrayNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg)) + { + UNITY_FAIL_AND_BAIL; + } + + /* fix delta sign if need */ + if (in_delta < 0) + { + in_delta = -in_delta; + } + + while (elements--) + { + current_element_delta = *ptr_expected * UNITY_DOUBLE_PRECISION; + + if (current_element_delta < 0) + { + /* fix delta sign for correct calculations */ + current_element_delta = -current_element_delta; + } + + if (!UnityDoublesWithin(in_delta + current_element_delta, *ptr_expected, *ptr_actual)) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrElement); + UnityPrintNumberUnsigned(num_elements - elements - 1); + UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT(*ptr_expected, *ptr_actual); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } + if (flags == UNITY_ARRAY_TO_ARRAY) + { + ptr_expected++; + } + ptr_actual++; + } +} + +/*-----------------------------------------------*/ +void UnityAssertDoublesWithin(const UNITY_DOUBLE delta, + const UNITY_DOUBLE expected, + const UNITY_DOUBLE actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber) +{ + RETURN_IF_FAIL_OR_IGNORE; + + if (!UnityDoublesWithin(delta, expected, actual)) + { + UnityTestResultsFailBegin(lineNumber); + UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT(expected, actual); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +/*-----------------------------------------------*/ +void UnityAssertDoublesNotWithin(const UNITY_DOUBLE delta, + const UNITY_DOUBLE expected, + const UNITY_DOUBLE actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber) +{ + RETURN_IF_FAIL_OR_IGNORE; + + if (UnityDoublesWithin(delta, expected, actual)) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrExpected); + UnityPrintFloat((UNITY_DOUBLE)expected); + UnityPrint(UnityStrNotEqual); + UnityPrintFloat((UNITY_DOUBLE)actual); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +/*-----------------------------------------------*/ +void UnityAssertGreaterOrLessDouble(const UNITY_DOUBLE threshold, + const UNITY_DOUBLE actual, + const UNITY_COMPARISON_T compare, + const char* msg, + const UNITY_LINE_TYPE lineNumber) +{ + int failed; + + RETURN_IF_FAIL_OR_IGNORE; + + failed = 0; + + /* Checking for "not success" rather than failure to get the right result for NaN */ + if (!(actual < threshold) && (compare & UNITY_SMALLER_THAN)) { failed = 1; } + if (!(actual > threshold) && (compare & UNITY_GREATER_THAN)) { failed = 1; } + + if ((compare & UNITY_EQUAL_TO) && UnityDoublesWithin(threshold * UNITY_DOUBLE_PRECISION, threshold, actual)) { failed = 0; } + + if (failed) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrExpected); + UnityPrintFloat(actual); + if (compare & UNITY_GREATER_THAN) { UnityPrint(UnityStrGt); } + if (compare & UNITY_SMALLER_THAN) { UnityPrint(UnityStrLt); } + if (compare & UNITY_EQUAL_TO) { UnityPrint(UnityStrOrEqual); } + UnityPrintFloat(threshold); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +/*-----------------------------------------------*/ +void UnityAssertDoubleSpecial(const UNITY_DOUBLE actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLOAT_TRAIT_T style) +{ + const char* trait_names[] = {UnityStrInf, UnityStrNegInf, UnityStrNaN, UnityStrDet}; + UNITY_INT should_be_trait = ((UNITY_INT)style & 1); + UNITY_INT is_trait = !should_be_trait; + UNITY_INT trait_index = (UNITY_INT)(style >> 1); + + RETURN_IF_FAIL_OR_IGNORE; + + switch (style) + { + case UNITY_FLOAT_IS_INF: + case UNITY_FLOAT_IS_NOT_INF: + is_trait = UNITY_IS_INF(actual) && (actual > 0); + break; + case UNITY_FLOAT_IS_NEG_INF: + case UNITY_FLOAT_IS_NOT_NEG_INF: + is_trait = UNITY_IS_INF(actual) && (actual < 0); + break; + + case UNITY_FLOAT_IS_NAN: + case UNITY_FLOAT_IS_NOT_NAN: + is_trait = UNITY_IS_NAN(actual) ? 1 : 0; + break; + + case UNITY_FLOAT_IS_DET: /* A determinate number is non infinite and not NaN. */ + case UNITY_FLOAT_IS_NOT_DET: + is_trait = !UNITY_IS_INF(actual) && !UNITY_IS_NAN(actual); + break; + + case UNITY_FLOAT_INVALID_TRAIT: /* Supress warning */ + default: /* including UNITY_FLOAT_INVALID_TRAIT */ + trait_index = 0; + trait_names[0] = UnityStrInvalidFloatTrait; + break; + } + + if (is_trait != should_be_trait) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrExpected); + if (!should_be_trait) + { + UnityPrint(UnityStrNot); + } + UnityPrint(trait_names[trait_index]); + UnityPrint(UnityStrWas); +#ifndef UNITY_EXCLUDE_FLOAT_PRINT + UnityPrintFloat(actual); +#else + if (should_be_trait) + { + UnityPrint(UnityStrNot); + } + UnityPrint(trait_names[trait_index]); +#endif + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +#endif /* not UNITY_EXCLUDE_DOUBLE */ + +/*-----------------------------------------------*/ +void UnityAssertNumbersWithin(const UNITY_UINT delta, + const UNITY_INT expected, + const UNITY_INT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_DISPLAY_STYLE_T style) +{ + RETURN_IF_FAIL_OR_IGNORE; + + if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) + { + if (actual > expected) + { + Unity.CurrentTestFailed = (((UNITY_UINT)actual - (UNITY_UINT)expected) > delta); + } + else + { + Unity.CurrentTestFailed = (((UNITY_UINT)expected - (UNITY_UINT)actual) > delta); + } + } + else + { + if ((UNITY_UINT)actual > (UNITY_UINT)expected) + { + Unity.CurrentTestFailed = (((UNITY_UINT)actual - (UNITY_UINT)expected) > delta); + } + else + { + Unity.CurrentTestFailed = (((UNITY_UINT)expected - (UNITY_UINT)actual) > delta); + } + } + + if (Unity.CurrentTestFailed) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrDelta); + UnityPrintNumberByStyle((UNITY_INT)delta, style); + UnityPrint(UnityStrExpected); + UnityPrintNumberByStyle(expected, style); + UnityPrint(UnityStrWas); + UnityPrintNumberByStyle(actual, style); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +/*-----------------------------------------------*/ +void UnityAssertNumbersArrayWithin(const UNITY_UINT delta, + UNITY_INTERNAL_PTR expected, + UNITY_INTERNAL_PTR actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_DISPLAY_STYLE_T style, + const UNITY_FLAGS_T flags) +{ + UNITY_UINT32 elements = num_elements; + unsigned int length = style & 0xF; + unsigned int increment = 0; + + RETURN_IF_FAIL_OR_IGNORE; + + if (num_elements == 0) + { +#ifdef UNITY_COMPARE_PTRS_ON_ZERO_ARRAY + UNITY_TEST_ASSERT_EQUAL_PTR(expected, actual, lineNumber, msg); +#else + UnityPrintPointlessAndBail(); +#endif + } + + if (expected == actual) + { + return; /* Both are NULL or same pointer */ + } + + if (UnityIsOneArrayNull(expected, actual, lineNumber, msg)) + { + UNITY_FAIL_AND_BAIL; + } + + while ((elements > 0) && (elements--)) + { + UNITY_INT expect_val; + UNITY_INT actual_val; + + switch (length) + { + case 1: + /* fixing problems with signed overflow on unsigned numbers */ + if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) + { + expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT8*)expected; + actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT8*)actual; + increment = sizeof(UNITY_INT8); + } + else + { + expect_val = (UNITY_INT)*(UNITY_PTR_ATTRIBUTE const UNITY_UINT8*)expected; + actual_val = (UNITY_INT)*(UNITY_PTR_ATTRIBUTE const UNITY_UINT8*)actual; + increment = sizeof(UNITY_UINT8); + } + break; + + case 2: + /* fixing problems with signed overflow on unsigned numbers */ + if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) + { + expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT16*)expected; + actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT16*)actual; + increment = sizeof(UNITY_INT16); + } + else + { + expect_val = (UNITY_INT)*(UNITY_PTR_ATTRIBUTE const UNITY_UINT16*)expected; + actual_val = (UNITY_INT)*(UNITY_PTR_ATTRIBUTE const UNITY_UINT16*)actual; + increment = sizeof(UNITY_UINT16); + } + break; + +#ifdef UNITY_SUPPORT_64 + case 8: + /* fixing problems with signed overflow on unsigned numbers */ + if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) + { + expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT64*)expected; + actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT64*)actual; + increment = sizeof(UNITY_INT64); + } + else + { + expect_val = (UNITY_INT)*(UNITY_PTR_ATTRIBUTE const UNITY_UINT64*)expected; + actual_val = (UNITY_INT)*(UNITY_PTR_ATTRIBUTE const UNITY_UINT64*)actual; + increment = sizeof(UNITY_UINT64); + } + break; +#endif + + default: /* default is length 4 bytes */ + case 4: + /* fixing problems with signed overflow on unsigned numbers */ + if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) + { + expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT32*)expected; + actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT32*)actual; + increment = sizeof(UNITY_INT32); + } + else + { + expect_val = (UNITY_INT)*(UNITY_PTR_ATTRIBUTE const UNITY_UINT32*)expected; + actual_val = (UNITY_INT)*(UNITY_PTR_ATTRIBUTE const UNITY_UINT32*)actual; + increment = sizeof(UNITY_UINT32); + } + length = 4; + break; + } + + if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) + { + if (actual_val > expect_val) + { + Unity.CurrentTestFailed = (((UNITY_UINT)actual_val - (UNITY_UINT)expect_val) > delta); + } + else + { + Unity.CurrentTestFailed = (((UNITY_UINT)expect_val - (UNITY_UINT)actual_val) > delta); + } + } + else + { + if ((UNITY_UINT)actual_val > (UNITY_UINT)expect_val) + { + Unity.CurrentTestFailed = (((UNITY_UINT)actual_val - (UNITY_UINT)expect_val) > delta); + } + else + { + Unity.CurrentTestFailed = (((UNITY_UINT)expect_val - (UNITY_UINT)actual_val) > delta); + } + } + + if (Unity.CurrentTestFailed) + { + if ((style & UNITY_DISPLAY_RANGE_UINT) && (length < (UNITY_INT_WIDTH / 8))) + { /* For UINT, remove sign extension (padding 1's) from signed type casts above */ + UNITY_INT mask = 1; + mask = (mask << 8 * length) - 1; + expect_val &= mask; + actual_val &= mask; + } + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrDelta); + UnityPrintNumberByStyle((UNITY_INT)delta, style); + UnityPrint(UnityStrElement); + UnityPrintNumberUnsigned(num_elements - elements - 1); + UnityPrint(UnityStrExpected); + UnityPrintNumberByStyle(expect_val, style); + UnityPrint(UnityStrWas); + UnityPrintNumberByStyle(actual_val, style); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } + /* Walk through array by incrementing the pointers */ + if (flags == UNITY_ARRAY_TO_ARRAY) + { + expected = (UNITY_INTERNAL_PTR)((const char*)expected + increment); + } + actual = (UNITY_INTERNAL_PTR)((const char*)actual + increment); + } +} + +/*-----------------------------------------------*/ +void UnityAssertEqualString(const char* expected, + const char* actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber) +{ + UNITY_UINT32 i; + + RETURN_IF_FAIL_OR_IGNORE; + + /* if both pointers not null compare the strings */ + if (expected && actual) + { + for (i = 0; expected[i] || actual[i]; i++) + { + if (expected[i] != actual[i]) + { + Unity.CurrentTestFailed = 1; + break; + } + } + } + else + { /* fail if either null but not if both */ + if (expected || actual) + { + Unity.CurrentTestFailed = 1; + } + } + + if (Unity.CurrentTestFailed) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrintExpectedAndActualStrings(expected, actual); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +/*-----------------------------------------------*/ +void UnityAssertEqualStringLen(const char* expected, + const char* actual, + const UNITY_UINT32 length, + const char* msg, + const UNITY_LINE_TYPE lineNumber) +{ + UNITY_UINT32 i; + + RETURN_IF_FAIL_OR_IGNORE; + + /* if both pointers not null compare the strings */ + if (expected && actual) + { + for (i = 0; (i < length) && (expected[i] || actual[i]); i++) + { + if (expected[i] != actual[i]) + { + Unity.CurrentTestFailed = 1; + break; + } + } + } + else + { /* fail if either null but not if both */ + if (expected || actual) + { + Unity.CurrentTestFailed = 1; + } + } + + if (Unity.CurrentTestFailed) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrintExpectedAndActualStringsLen(expected, actual, length); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +/*-----------------------------------------------*/ +void UnityAssertEqualStringArray(UNITY_INTERNAL_PTR expected, + const char** actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLAGS_T flags) +{ + UNITY_UINT32 i = 0; + UNITY_UINT32 j = 0; + const char* expd = NULL; + const char* act = NULL; + + RETURN_IF_FAIL_OR_IGNORE; + + /* if no elements, it's an error */ + if (num_elements == 0) + { +#ifdef UNITY_COMPARE_PTRS_ON_ZERO_ARRAY + UNITY_TEST_ASSERT_EQUAL_PTR(expected, actual, lineNumber, msg); +#else + UnityPrintPointlessAndBail(); +#endif + } + + if ((const void*)expected == (const void*)actual) + { + return; /* Both are NULL or same pointer */ + } + + if (UnityIsOneArrayNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg)) + { + UNITY_FAIL_AND_BAIL; + } + + if (flags != UNITY_ARRAY_TO_ARRAY) + { + expd = (const char*)expected; + } + + do + { + act = actual[j]; + if (flags == UNITY_ARRAY_TO_ARRAY) + { + expd = ((const char* const*)expected)[j]; + } + + /* if both pointers not null compare the strings */ + if (expd && act) + { + for (i = 0; expd[i] || act[i]; i++) + { + if (expd[i] != act[i]) + { + Unity.CurrentTestFailed = 1; + break; + } + } + } + else + { /* handle case of one pointers being null (if both null, test should pass) */ + if (expd != act) + { + Unity.CurrentTestFailed = 1; + } + } + + if (Unity.CurrentTestFailed) + { + UnityTestResultsFailBegin(lineNumber); + if (num_elements > 1) + { + UnityPrint(UnityStrElement); + UnityPrintNumberUnsigned(j); + } + UnityPrintExpectedAndActualStrings(expd, act); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } + } while (++j < num_elements); +} + +/*-----------------------------------------------*/ +void UnityAssertEqualMemory(UNITY_INTERNAL_PTR expected, + UNITY_INTERNAL_PTR actual, + const UNITY_UINT32 length, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLAGS_T flags) +{ + UNITY_PTR_ATTRIBUTE const unsigned char* ptr_exp = (UNITY_PTR_ATTRIBUTE const unsigned char*)expected; + UNITY_PTR_ATTRIBUTE const unsigned char* ptr_act = (UNITY_PTR_ATTRIBUTE const unsigned char*)actual; + UNITY_UINT32 elements = num_elements; + UNITY_UINT32 bytes; + + RETURN_IF_FAIL_OR_IGNORE; + + if (elements == 0) + { +#ifdef UNITY_COMPARE_PTRS_ON_ZERO_ARRAY + UNITY_TEST_ASSERT_EQUAL_PTR(expected, actual, lineNumber, msg); +#else + UnityPrintPointlessAndBail(); +#endif + } + if (length == 0) + { + UnityPrintPointlessAndBail(); + } + + if (expected == actual) + { + return; /* Both are NULL or same pointer */ + } + + if (UnityIsOneArrayNull(expected, actual, lineNumber, msg)) + { + UNITY_FAIL_AND_BAIL; + } + + while (elements--) + { + bytes = length; + while (bytes--) + { + if (*ptr_exp != *ptr_act) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrMemory); + if (num_elements > 1) + { + UnityPrint(UnityStrElement); + UnityPrintNumberUnsigned(num_elements - elements - 1); + } + UnityPrint(UnityStrByte); + UnityPrintNumberUnsigned(length - bytes - 1); + UnityPrint(UnityStrExpected); + UnityPrintNumberByStyle(*ptr_exp, UNITY_DISPLAY_STYLE_HEX8); + UnityPrint(UnityStrWas); + UnityPrintNumberByStyle(*ptr_act, UNITY_DISPLAY_STYLE_HEX8); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } + ptr_exp++; + ptr_act++; + } + if (flags == UNITY_ARRAY_TO_VAL) + { + ptr_exp = (UNITY_PTR_ATTRIBUTE const unsigned char*)expected; + } + } +} + +/*-----------------------------------------------*/ + +static union +{ + UNITY_INT8 i8; + UNITY_INT16 i16; + UNITY_INT32 i32; +#ifdef UNITY_SUPPORT_64 + UNITY_INT64 i64; +#endif +#ifndef UNITY_EXCLUDE_FLOAT + float f; +#endif +#ifndef UNITY_EXCLUDE_DOUBLE + double d; +#endif +} UnityQuickCompare; + +UNITY_INTERNAL_PTR UnityNumToPtr(const UNITY_INT num, const UNITY_UINT8 size) +{ + switch(size) + { + case 1: + UnityQuickCompare.i8 = (UNITY_INT8)num; + return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.i8); + + case 2: + UnityQuickCompare.i16 = (UNITY_INT16)num; + return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.i16); + +#ifdef UNITY_SUPPORT_64 + case 8: + UnityQuickCompare.i64 = (UNITY_INT64)num; + return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.i64); +#endif + + default: /* 4 bytes */ + UnityQuickCompare.i32 = (UNITY_INT32)num; + return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.i32); + } +} + +#ifndef UNITY_EXCLUDE_FLOAT +/*-----------------------------------------------*/ +UNITY_INTERNAL_PTR UnityFloatToPtr(const float num) +{ + UnityQuickCompare.f = num; + return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.f); +} +#endif + +#ifndef UNITY_EXCLUDE_DOUBLE +/*-----------------------------------------------*/ +UNITY_INTERNAL_PTR UnityDoubleToPtr(const double num) +{ + UnityQuickCompare.d = num; + return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.d); +} +#endif + +#ifdef UNITY_INCLUDE_PRINT_FORMATTED + +/*----------------------------------------------- + * printf length modifier helpers + *-----------------------------------------------*/ + +enum UnityLengthModifier { + UNITY_LENGTH_MODIFIER_NONE, + UNITY_LENGTH_MODIFIER_LONG_LONG, + UNITY_LENGTH_MODIFIER_LONG, +}; + +#define UNITY_EXTRACT_ARG(NUMBER_T, NUMBER, LENGTH_MOD, VA, ARG_T) \ +do { \ + switch (LENGTH_MOD) \ + { \ + case UNITY_LENGTH_MODIFIER_LONG_LONG: \ + { \ + NUMBER = (NUMBER_T)va_arg(VA, long long ARG_T); \ + break; \ + } \ + case UNITY_LENGTH_MODIFIER_LONG: \ + { \ + NUMBER = (NUMBER_T)va_arg(VA, long ARG_T); \ + break; \ + } \ + case UNITY_LENGTH_MODIFIER_NONE: \ + default: \ + { \ + NUMBER = (NUMBER_T)va_arg(VA, ARG_T); \ + break; \ + } \ + } \ +} while (0) + +static enum UnityLengthModifier UnityLengthModifierGet(const char *pch, int *length) +{ + enum UnityLengthModifier length_mod; + switch (pch[0]) + { + case 'l': + { + if (pch[1] == 'l') + { + *length = 2; + length_mod = UNITY_LENGTH_MODIFIER_LONG_LONG; + } + else + { + *length = 1; + length_mod = UNITY_LENGTH_MODIFIER_LONG; + } + break; + } + case 'h': + { + // short and char are converted to int + length_mod = UNITY_LENGTH_MODIFIER_NONE; + if (pch[1] == 'h') + { + *length = 2; + } + else + { + *length = 1; + } + break; + } + case 'j': + case 'z': + case 't': + case 'L': + { + // Not supported, but should gobble up the length specifier anyway + length_mod = UNITY_LENGTH_MODIFIER_NONE; + *length = 1; + break; + } + default: + { + length_mod = UNITY_LENGTH_MODIFIER_NONE; + *length = 0; + } + } + return length_mod; +} + +/*----------------------------------------------- + * printf helper function + *-----------------------------------------------*/ +static void UnityPrintFVA(const char* format, va_list va) +{ + const char* pch = format; + if (pch != NULL) + { + while (*pch) + { + /* format identification character */ + if (*pch == '%') + { + pch++; + + if (pch != NULL) + { + int length_mod_size; + enum UnityLengthModifier length_mod = UnityLengthModifierGet(pch, &length_mod_size); + pch += length_mod_size; + + switch (*pch) + { + case 'd': + case 'i': + { + UNITY_INT number; + UNITY_EXTRACT_ARG(UNITY_INT, number, length_mod, va, int); + UnityPrintNumber((UNITY_INT)number); + break; + } +#ifndef UNITY_EXCLUDE_FLOAT_PRINT + case 'f': + case 'g': + { + const double number = va_arg(va, double); + UnityPrintFloat((UNITY_DOUBLE)number); + break; + } +#endif + case 'u': + { + UNITY_UINT number; + UNITY_EXTRACT_ARG(UNITY_UINT, number, length_mod, va, unsigned int); + UnityPrintNumberUnsigned(number); + break; + } + case 'b': + { + UNITY_UINT number; + UNITY_EXTRACT_ARG(UNITY_UINT, number, length_mod, va, unsigned int); + const UNITY_UINT mask = (UNITY_UINT)0 - (UNITY_UINT)1; + UNITY_OUTPUT_CHAR('0'); + UNITY_OUTPUT_CHAR('b'); + UnityPrintMask(mask, number); + break; + } + case 'x': + case 'X': + { + UNITY_UINT number; + UNITY_EXTRACT_ARG(UNITY_UINT, number, length_mod, va, unsigned int); + UNITY_OUTPUT_CHAR('0'); + UNITY_OUTPUT_CHAR('x'); + UnityPrintNumberHex(number, UNITY_MAX_NIBBLES); + break; + } + case 'p': + { + UNITY_UINT number; + char nibbles_to_print = 8; + if (UNITY_POINTER_WIDTH == 64) + { + length_mod = UNITY_LENGTH_MODIFIER_LONG_LONG; + nibbles_to_print = 16; + } + UNITY_EXTRACT_ARG(UNITY_UINT, number, length_mod, va, unsigned int); + UNITY_OUTPUT_CHAR('0'); + UNITY_OUTPUT_CHAR('x'); + UnityPrintNumberHex((UNITY_UINT)number, nibbles_to_print); + break; + } + case 'c': + { + const int ch = va_arg(va, int); + UnityPrintChar((const char *)&ch); + break; + } + case 's': + { + const char * string = va_arg(va, const char *); + UnityPrint(string); + break; + } + case '%': + { + UnityPrintChar(pch); + break; + } + default: + { + /* print the unknown format character */ + UNITY_OUTPUT_CHAR('%'); + UnityPrintChar(pch); + break; + } + } + } + } +#ifdef UNITY_OUTPUT_COLOR + /* print ANSI escape code */ + else if ((*pch == 27) && (*(pch + 1) == '[')) + { + pch += UnityPrintAnsiEscapeString(pch); + continue; + } +#endif + else if (*pch == '\n') + { + UNITY_PRINT_EOL(); + } + else + { + UnityPrintChar(pch); + } + + pch++; + } + } +} + +void UnityPrintF(const UNITY_LINE_TYPE line, const char* format, ...) +{ + UnityTestResultsBegin(Unity.TestFile, line); + UnityPrint("INFO"); + if(format != NULL) + { + UnityPrint(": "); + va_list va; + va_start(va, format); + UnityPrintFVA(format, va); + va_end(va); + } + UNITY_PRINT_EOL(); +} +#endif /* ! UNITY_INCLUDE_PRINT_FORMATTED */ + + +/*----------------------------------------------- + * Control Functions + *-----------------------------------------------*/ + +/*-----------------------------------------------*/ +void UnityFail(const char* msg, const UNITY_LINE_TYPE line) +{ + RETURN_IF_FAIL_OR_IGNORE; + + UnityTestResultsBegin(Unity.TestFile, line); + UnityPrint(UnityStrFail); + if (msg != NULL) + { + UNITY_OUTPUT_CHAR(':'); + +#ifdef UNITY_PRINT_TEST_CONTEXT + UNITY_PRINT_TEST_CONTEXT(); +#endif +#ifndef UNITY_EXCLUDE_DETAILS + if (Unity.CurrentDetail1) + { + UnityPrint(UnityStrDetail1Name); + UnityPrint(Unity.CurrentDetail1); + if (Unity.CurrentDetail2) + { + UnityPrint(UnityStrDetail2Name); + UnityPrint(Unity.CurrentDetail2); + } + UnityPrint(UnityStrSpacer); + } +#endif + if (msg[0] != ' ') + { + UNITY_OUTPUT_CHAR(' '); + } + UnityPrint(msg); + } + + UNITY_FAIL_AND_BAIL; +} + +/*-----------------------------------------------*/ +void UnityIgnore(const char* msg, const UNITY_LINE_TYPE line) +{ + RETURN_IF_FAIL_OR_IGNORE; + + UnityTestResultsBegin(Unity.TestFile, line); + UnityPrint(UnityStrIgnore); + if (msg != NULL) + { + UNITY_OUTPUT_CHAR(':'); + UNITY_OUTPUT_CHAR(' '); + UnityPrint(msg); + } + UNITY_IGNORE_AND_BAIL; +} + +/*-----------------------------------------------*/ +void UnityMessage(const char* msg, const UNITY_LINE_TYPE line) +{ + UnityTestResultsBegin(Unity.TestFile, line); + UnityPrint("INFO"); + if (msg != NULL) + { + UNITY_OUTPUT_CHAR(':'); + UNITY_OUTPUT_CHAR(' '); + UnityPrint(msg); + } + UNITY_PRINT_EOL(); +} + +/*-----------------------------------------------*/ +/* If we have not defined our own test runner, then include our default test runner to make life easier */ +#ifndef UNITY_SKIP_DEFAULT_RUNNER +void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int FuncLineNum) +{ + Unity.CurrentTestName = FuncName; + Unity.CurrentTestLineNumber = (UNITY_LINE_TYPE)FuncLineNum; + Unity.NumberOfTests++; + UNITY_CLR_DETAILS(); + UNITY_EXEC_TIME_START(); + if (TEST_PROTECT()) + { + setUp(); + Func(); + } + if (TEST_PROTECT()) + { + tearDown(); + } + UNITY_EXEC_TIME_STOP(); + UnityConcludeTest(); +} +#endif + +/*-----------------------------------------------*/ +void UnitySetTestFile(const char* filename) +{ + Unity.TestFile = filename; +} + +/*-----------------------------------------------*/ +void UnityBegin(const char* filename) +{ + Unity.TestFile = filename; + Unity.CurrentTestName = NULL; + Unity.CurrentTestLineNumber = 0; + Unity.NumberOfTests = 0; + Unity.TestFailures = 0; + Unity.TestIgnores = 0; + Unity.CurrentTestFailed = 0; + Unity.CurrentTestIgnored = 0; + + UNITY_CLR_DETAILS(); + UNITY_OUTPUT_START(); +} + +/*-----------------------------------------------*/ +int UnityEnd(void) +{ + UNITY_PRINT_EOL(); + UnityPrint(UnityStrBreaker); + UNITY_PRINT_EOL(); + UnityPrintNumber((UNITY_INT)(Unity.NumberOfTests)); + UnityPrint(UnityStrResultsTests); + UnityPrintNumber((UNITY_INT)(Unity.TestFailures)); + UnityPrint(UnityStrResultsFailures); + UnityPrintNumber((UNITY_INT)(Unity.TestIgnores)); + UnityPrint(UnityStrResultsIgnored); + UNITY_PRINT_EOL(); + if (Unity.TestFailures == 0U) + { + UnityPrint(UnityStrOk); + } + else + { + UnityPrint(UnityStrFail); +#ifdef UNITY_DIFFERENTIATE_FINAL_FAIL + UNITY_OUTPUT_CHAR('E'); UNITY_OUTPUT_CHAR('D'); +#endif + } + UNITY_PRINT_EOL(); + UNITY_FLUSH_CALL(); + UNITY_OUTPUT_COMPLETE(); + return (int)(Unity.TestFailures); +} + +/*----------------------------------------------- + * Command Line Argument Support + *-----------------------------------------------*/ +#ifdef UNITY_USE_COMMAND_LINE_ARGS + +char* UnityOptionIncludeNamed = NULL; +char* UnityOptionExcludeNamed = NULL; +int UnityVerbosity = 1; +int UnityStrictMatch = 0; + +/*-----------------------------------------------*/ +int UnityParseOptions(int argc, char** argv) +{ + int i; + UnityOptionIncludeNamed = NULL; + UnityOptionExcludeNamed = NULL; + UnityStrictMatch = 0; + + for (i = 1; i < argc; i++) + { + if (argv[i][0] == '-') + { + switch (argv[i][1]) + { + case 'l': /* list tests */ + return -1; + case 'n': /* include tests with name including this string */ + case 'f': /* an alias for -n */ + UnityStrictMatch = (argv[i][1] == 'n'); /* strictly match this string if -n */ + if (argv[i][2] == '=') + { + UnityOptionIncludeNamed = &argv[i][3]; + } + else if (++i < argc) + { + UnityOptionIncludeNamed = argv[i]; + } + else + { + UnityPrint("ERROR: No Test String to Include Matches For"); + UNITY_PRINT_EOL(); + return 1; + } + break; + case 'q': /* quiet */ + UnityVerbosity = 0; + break; + case 'v': /* verbose */ + UnityVerbosity = 2; + break; + case 'x': /* exclude tests with name including this string */ + if (argv[i][2] == '=') + { + UnityOptionExcludeNamed = &argv[i][3]; + } + else if (++i < argc) + { + UnityOptionExcludeNamed = argv[i]; + } + else + { + UnityPrint("ERROR: No Test String to Exclude Matches For"); + UNITY_PRINT_EOL(); + return 1; + } + break; + default: + UnityPrint("ERROR: Unknown Option "); + UNITY_OUTPUT_CHAR(argv[i][1]); + UNITY_PRINT_EOL(); + /* Now display help */ + /* FALLTHRU */ + case 'h': + UnityPrint("Options: "); UNITY_PRINT_EOL(); + UnityPrint("-l List all tests and exit"); UNITY_PRINT_EOL(); + UnityPrint("-f NAME Filter to run only tests whose name includes NAME"); UNITY_PRINT_EOL(); + UnityPrint("-n NAME Run only the test named NAME"); UNITY_PRINT_EOL(); + UnityPrint("-h show this Help menu"); UNITY_PRINT_EOL(); + UnityPrint("-q Quiet/decrease verbosity"); UNITY_PRINT_EOL(); + UnityPrint("-v increase Verbosity"); UNITY_PRINT_EOL(); + UnityPrint("-x NAME eXclude tests whose name includes NAME"); UNITY_PRINT_EOL(); + UNITY_OUTPUT_FLUSH(); + return 1; + } + } + } + + return 0; +} + +/*-----------------------------------------------*/ +static int IsStringInBiggerString(const char* longstring, const char* shortstring) +{ + const char* lptr = longstring; + const char* sptr = shortstring; + const char* lnext = lptr; + + if (*sptr == '*') + { + return UnityStrictMatch ? 0 : 1; + } + + while (*lptr) + { + lnext = lptr + 1; + + /* If they current bytes match, go on to the next bytes */ + while (*lptr && *sptr && (*lptr == *sptr)) + { + lptr++; + sptr++; + + switch (*sptr) + { + case '*': /* we encountered a wild-card */ + return UnityStrictMatch ? 0 : 1; + + case ',': /* we encountered the end of match string */ + case '"': + case '\'': + case 0: + return (!UnityStrictMatch || (*lptr == 0)) ? 1 : 0; + + case ':': /* we encountered the end of a partial match */ + return 2; + + default: + break; + } + } + + // If we didn't match and we're on strict matching, we already know we failed + if (UnityStrictMatch) + { + return 0; + } + + /* Otherwise we start in the long pointer 1 character further and try again */ + lptr = lnext; + sptr = shortstring; + } + + return 0; +} + +/*-----------------------------------------------*/ +static int UnityStringArgumentMatches(const char* str) +{ + int retval; + const char* ptr1; + const char* ptr2; + const char* ptrf; + + /* Go through the options and get the substrings for matching one at a time */ + ptr1 = str; + while (ptr1[0] != 0) + { + if ((ptr1[0] == '"') || (ptr1[0] == '\'')) + { + ptr1++; + } + + /* look for the start of the next partial */ + ptr2 = ptr1; + ptrf = 0; + do + { + ptr2++; + if ((ptr2[0] == ':') && (ptr2[1] != 0) && (ptr2[0] != '\'') && (ptr2[0] != '"') && (ptr2[0] != ',')) + { + ptrf = &ptr2[1]; + } + } while ((ptr2[0] != 0) && (ptr2[0] != '\'') && (ptr2[0] != '"') && (ptr2[0] != ',')); + + while ((ptr2[0] != 0) && ((ptr2[0] == ':') || (ptr2[0] == '\'') || (ptr2[0] == '"') || (ptr2[0] == ','))) + { + ptr2++; + } + + /* done if complete filename match */ + retval = IsStringInBiggerString(Unity.TestFile, ptr1); + if (retval == 1) + { + return retval; + } + + /* done if testname match after filename partial match */ + if ((retval == 2) && (ptrf != 0)) + { + if (IsStringInBiggerString(Unity.CurrentTestName, ptrf)) + { + return 1; + } + } + + /* done if complete testname match */ + if (IsStringInBiggerString(Unity.CurrentTestName, ptr1) == 1) + { + return 1; + } + + ptr1 = ptr2; + } + + /* we couldn't find a match for any substrings */ + return 0; +} + +/*-----------------------------------------------*/ +int UnityTestMatches(void) +{ + /* Check if this test name matches the included test pattern */ + int retval; + if (UnityOptionIncludeNamed) + { + retval = UnityStringArgumentMatches(UnityOptionIncludeNamed); + } + else + { + retval = 1; + } + + /* Check if this test name matches the excluded test pattern */ + if (UnityOptionExcludeNamed) + { + if (UnityStringArgumentMatches(UnityOptionExcludeNamed)) + { + retval = 0; + } + } + + return retval; +} + +#endif /* UNITY_USE_COMMAND_LINE_ARGS */ +/*-----------------------------------------------*/ diff --git a/subprojects/unity/src/unity.h b/subprojects/unity/src/unity.h new file mode 100644 index 0000000000..9e2a97b791 --- /dev/null +++ b/subprojects/unity/src/unity.h @@ -0,0 +1,698 @@ +/* ========================================================================= + Unity - A Test Framework for C + ThrowTheSwitch.org + Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams + SPDX-License-Identifier: MIT +========================================================================= */ + +#ifndef UNITY_FRAMEWORK_H +#define UNITY_FRAMEWORK_H +#define UNITY + +#define UNITY_VERSION_MAJOR 2 +#define UNITY_VERSION_MINOR 6 +#define UNITY_VERSION_BUILD 1 +#define UNITY_VERSION ((UNITY_VERSION_MAJOR << 16) | (UNITY_VERSION_MINOR << 8) | UNITY_VERSION_BUILD) + +#ifdef __cplusplus +extern "C" +{ +#endif + +#include "unity_internals.h" + +/*------------------------------------------------------- + * Test Setup / Teardown + *-------------------------------------------------------*/ + +/* These functions are intended to be called before and after each test. + * If using unity directly, these will need to be provided for each test + * executable built. If you are using the test runner generator and/or + * Ceedling, these are optional. */ +void setUp(void); +void tearDown(void); + +/* These functions are intended to be called at the beginning and end of an + * entire test suite. suiteTearDown() is passed the number of tests that + * failed, and its return value becomes the exit code of main(). If using + * Unity directly, you're in charge of calling these if they are desired. + * If using Ceedling or the test runner generator, these will be called + * automatically if they exist. */ +void suiteSetUp(void); +int suiteTearDown(int num_failures); + +/*------------------------------------------------------- + * Test Reset and Verify + *-------------------------------------------------------*/ + +/* These functions are intended to be called before during tests in order + * to support complex test loops, etc. Both are NOT built into Unity. Instead + * the test runner generator will create them. resetTest will run teardown and + * setup again, verifying any end-of-test needs between. verifyTest will only + * run the verification. */ +void resetTest(void); +void verifyTest(void); + +/*------------------------------------------------------- + * Configuration Options + *------------------------------------------------------- + * All options described below should be passed as a compiler flag to all files using Unity. If you must add #defines, place them BEFORE the #include above. + + * Integers/longs/pointers + * - Unity attempts to automatically discover your integer sizes + * - define UNITY_EXCLUDE_STDINT_H to stop attempting to look in + * - define UNITY_EXCLUDE_LIMITS_H to stop attempting to look in + * - If you cannot use the automatic methods above, you can force Unity by using these options: + * - define UNITY_SUPPORT_64 + * - set UNITY_INT_WIDTH + * - set UNITY_LONG_WIDTH + * - set UNITY_POINTER_WIDTH + + * Floats + * - define UNITY_EXCLUDE_FLOAT to disallow floating point comparisons + * - define UNITY_FLOAT_PRECISION to specify the precision to use when doing TEST_ASSERT_EQUAL_FLOAT + * - define UNITY_FLOAT_TYPE to specify doubles instead of single precision floats + * - define UNITY_INCLUDE_DOUBLE to allow double floating point comparisons + * - define UNITY_EXCLUDE_DOUBLE to disallow double floating point comparisons (default) + * - define UNITY_DOUBLE_PRECISION to specify the precision to use when doing TEST_ASSERT_EQUAL_DOUBLE + * - define UNITY_DOUBLE_TYPE to specify something other than double + * - define UNITY_EXCLUDE_FLOAT_PRINT to trim binary size, won't print floating point values in errors + + * Output + * - by default, Unity prints to standard out with putchar. define UNITY_OUTPUT_CHAR(a) with a different function if desired + * - define UNITY_DIFFERENTIATE_FINAL_FAIL to print FAILED (vs. FAIL) at test end summary - for automated search for failure + + * Optimization + * - by default, line numbers are stored in unsigned shorts. Define UNITY_LINE_TYPE with a different type if your files are huge + * - by default, test and failure counters are unsigned shorts. Define UNITY_COUNTER_TYPE with a different type if you want to save space or have more than 65535 Tests. + + * Test Cases + * - define UNITY_SUPPORT_TEST_CASES to include the TEST_CASE macro, though really it's mostly about the runner generator script + + * Parameterized Tests + * - you'll want to create a define of TEST_CASE(...), TEST_RANGE(...) and/or TEST_MATRIX(...) which basically evaluates to nothing + + * Tests with Arguments + * - you'll want to define UNITY_USE_COMMAND_LINE_ARGS if you have the test runner passing arguments to Unity + + *------------------------------------------------------- + * Basic Fail and Ignore + *-------------------------------------------------------*/ + +#define TEST_FAIL_MESSAGE(message) UNITY_TEST_FAIL(__LINE__, (message)) +#define TEST_FAIL() UNITY_TEST_FAIL(__LINE__, NULL) +#define TEST_IGNORE_MESSAGE(message) UNITY_TEST_IGNORE(__LINE__, (message)) +#define TEST_IGNORE() UNITY_TEST_IGNORE(__LINE__, NULL) +#define TEST_MESSAGE(message) UnityMessage((message), __LINE__) +#define TEST_ONLY() +#ifdef UNITY_INCLUDE_PRINT_FORMATTED +#define TEST_PRINTF(message, ...) UnityPrintF(__LINE__, (message), ##__VA_ARGS__) +#endif + +/* It is not necessary for you to call PASS. A PASS condition is assumed if nothing fails. + * This method allows you to abort a test immediately with a PASS state, ignoring the remainder of the test. */ +#define TEST_PASS() TEST_ABORT() +#define TEST_PASS_MESSAGE(message) do { UnityMessage((message), __LINE__); TEST_ABORT(); } while (0) + +/*------------------------------------------------------- + * Build Directives + *------------------------------------------------------- + + * These macros do nothing, but they are useful for additional build context. + * Tools (like Ceedling) can scan for these directives and make use of them for + * per-test-executable #include search paths and linking. */ + +/* Add source files to a test executable's compilation and linking. Ex: TEST_SOURCE_FILE("sandwiches.c") */ +#define TEST_SOURCE_FILE(a) + +/* Customize #include search paths for a test executable's compilation. Ex: TEST_INCLUDE_PATH("src/module_a/inc") */ +#define TEST_INCLUDE_PATH(a) + +/*------------------------------------------------------- + * Test Asserts (simple) + *-------------------------------------------------------*/ + +/* Boolean */ +#define TEST_ASSERT(condition) UNITY_TEST_ASSERT( (condition), __LINE__, " Expression Evaluated To FALSE") +#define TEST_ASSERT_TRUE(condition) UNITY_TEST_ASSERT( (condition), __LINE__, " Expected TRUE Was FALSE") +#define TEST_ASSERT_UNLESS(condition) UNITY_TEST_ASSERT( !(condition), __LINE__, " Expression Evaluated To TRUE") +#define TEST_ASSERT_FALSE(condition) UNITY_TEST_ASSERT( !(condition), __LINE__, " Expected FALSE Was TRUE") +#define TEST_ASSERT_NULL(pointer) UNITY_TEST_ASSERT_NULL( (pointer), __LINE__, " Expected NULL") +#define TEST_ASSERT_NOT_NULL(pointer) UNITY_TEST_ASSERT_NOT_NULL((pointer), __LINE__, " Expected Non-NULL") +#define TEST_ASSERT_EMPTY(pointer) UNITY_TEST_ASSERT_EMPTY( (pointer), __LINE__, " Expected Empty") +#define TEST_ASSERT_NOT_EMPTY(pointer) UNITY_TEST_ASSERT_NOT_EMPTY((pointer), __LINE__, " Expected Non-Empty") + +/* Integers (of all sizes) */ +#define TEST_ASSERT_EQUAL_INT(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_INT8(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT8((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_INT16(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT16((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_INT32(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT32((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_INT64(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT64((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_UINT(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT( (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_UINT8(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT8( (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_UINT16(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT16( (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_UINT32(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT32( (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_UINT64(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT64( (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_size_t(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_HEX(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_HEX8(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX8( (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_HEX16(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX16((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_HEX32(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_HEX64(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX64((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_CHAR(expected, actual) UNITY_TEST_ASSERT_EQUAL_CHAR((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_BITS(mask, expected, actual) UNITY_TEST_ASSERT_BITS((mask), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_BITS_HIGH(mask, actual) UNITY_TEST_ASSERT_BITS((mask), (UNITY_UINT)(-1), (actual), __LINE__, NULL) +#define TEST_ASSERT_BITS_LOW(mask, actual) UNITY_TEST_ASSERT_BITS((mask), (UNITY_UINT)(0), (actual), __LINE__, NULL) +#define TEST_ASSERT_BIT_HIGH(bit, actual) UNITY_TEST_ASSERT_BITS(((UNITY_UINT)1 << (bit)), (UNITY_UINT)(-1), (actual), __LINE__, NULL) +#define TEST_ASSERT_BIT_LOW(bit, actual) UNITY_TEST_ASSERT_BITS(((UNITY_UINT)1 << (bit)), (UNITY_UINT)(0), (actual), __LINE__, NULL) + +/* Integer Not Equal To (of all sizes) */ +#define TEST_ASSERT_NOT_EQUAL_INT(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_INT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_INT8(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_INT8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_INT16(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_INT16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_INT32(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_INT32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_INT64(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_INT64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_UINT(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_UINT8(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_UINT16(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_UINT32(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_UINT64(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_size_t(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_HEX8(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_HEX8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_HEX16(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_HEX16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_HEX32(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_HEX32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_HEX64(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_HEX64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_CHAR(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_CHAR((threshold), (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_INT64(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_INT64((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_UINT64(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_UINT64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_size_t(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_UINT((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_GREATER_THAN_HEX64(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_HEX64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_CHAR(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_CHAR((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_INT64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_INT64((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_UINT64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_UINT64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_size_t(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_UINT((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) +#define TEST_ASSERT_LESS_THAN_HEX64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_HEX64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_CHAR(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_CHAR((threshold), (actual), __LINE__, NULL) + +#define TEST_ASSERT_GREATER_OR_EQUAL(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_INT(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_INT8(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_INT16(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_INT32(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_INT64(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_UINT(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_UINT8(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_UINT16(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_UINT32(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_UINT64(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_size_t(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_HEX8(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_HEX16(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_HEX32(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_HEX64(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_CHAR(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_CHAR((threshold), (actual), __LINE__, NULL) + +#define TEST_ASSERT_LESS_OR_EQUAL(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_INT(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_INT8(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_INT16(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_INT32(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_INT64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_UINT(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_UINT8(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_UINT16(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_UINT32(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_UINT64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_size_t(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_HEX8(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_HEX16(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_HEX32(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_HEX64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_CHAR(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_CHAR((threshold), (actual), __LINE__, NULL) + +/* 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_INT8_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT8_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_INT16_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT16_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_INT32_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT32_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_INT64_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT64_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_UINT_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_UINT8_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT8_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_UINT16_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT16_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_UINT32_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT32_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_UINT64_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT64_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_size_t_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_HEX_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_HEX8_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX8_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_HEX16_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX16_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_HEX32_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_HEX64_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX64_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_CHAR_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_CHAR_WITHIN((delta), (expected), (actual), __LINE__, NULL) + +/* Integer Array Ranges (of all sizes) */ +#define TEST_ASSERT_INT_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_INT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_INT8_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_INT8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_INT16_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_INT16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_INT32_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_INT32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_INT64_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_INT64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_UINT_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_UINT8_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_UINT16_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_UINT32_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_UINT64_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_size_t_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_HEX_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_HEX8_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_HEX8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_HEX16_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_HEX16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_HEX32_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_HEX64_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_HEX64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_CHAR_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_CHAR_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) + + +/* Structs and Strings */ +#define TEST_ASSERT_EQUAL_PTR(expected, actual) UNITY_TEST_ASSERT_EQUAL_PTR((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_STRING(expected, actual) UNITY_TEST_ASSERT_EQUAL_STRING((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_STRING_LEN(expected, actual, len) UNITY_TEST_ASSERT_EQUAL_STRING_LEN((expected), (actual), (len), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_MEMORY(expected, actual, len) UNITY_TEST_ASSERT_EQUAL_MEMORY((expected), (actual), (len), __LINE__, NULL) + +/* Arrays */ +#define TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_INT8_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT8_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_INT16_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT16_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_INT32_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT32_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_INT64_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT64_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_UINT_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_UINT8_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT8_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_UINT16_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_UINT32_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT32_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_size_t_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_HEX_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_HEX16_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX16_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_HEX32_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_HEX64_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_PTR_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_PTR_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_CHAR_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_CHAR_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) + +/* 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_INT8(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_INT8((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_INT16(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_INT16((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_INT32(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_INT32((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_INT64(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_INT64((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_UINT(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_UINT8(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT8((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_UINT16(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT16((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_UINT32(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT32((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_UINT64(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT64((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_size_t(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_HEX(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_HEX32((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_HEX8(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_HEX8((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_HEX16(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_HEX16((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_HEX32(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_HEX32((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_HEX64(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_HEX64((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_PTR(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_PTR((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_STRING(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_STRING((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_MEMORY(expected, actual, len, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_MEMORY((expected), (actual), (len), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_CHAR(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_CHAR((expected), (actual), (num_elements), __LINE__, NULL) + +/* Floating Point (If Enabled) */ +#define TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_FLOAT_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_FLOAT_NOT_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_FLOAT_NOT_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_FLOAT(expected, actual) UNITY_TEST_ASSERT_EQUAL_FLOAT((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_FLOAT(expected, actual) UNITY_TEST_ASSERT_NOT_EQUAL_FLOAT((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_FLOAT_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_FLOAT_ARRAY_WITHIN((delta), (expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_FLOAT(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_FLOAT(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_FLOAT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_FLOAT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_FLOAT(threshold, actual) UNITY_TEST_ASSERT_LESS_THAN_FLOAT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_FLOAT(threshold, actual) UNITY_TEST_ASSERT_LESS_OR_EQUAL_FLOAT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_FLOAT_IS_INF(actual) UNITY_TEST_ASSERT_FLOAT_IS_INF((actual), __LINE__, NULL) +#define TEST_ASSERT_FLOAT_IS_NEG_INF(actual) UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF((actual), __LINE__, NULL) +#define TEST_ASSERT_FLOAT_IS_NAN(actual) UNITY_TEST_ASSERT_FLOAT_IS_NAN((actual), __LINE__, NULL) +#define TEST_ASSERT_FLOAT_IS_DETERMINATE(actual) UNITY_TEST_ASSERT_FLOAT_IS_DETERMINATE((actual), __LINE__, NULL) +#define TEST_ASSERT_FLOAT_IS_NOT_INF(actual) UNITY_TEST_ASSERT_FLOAT_IS_NOT_INF((actual), __LINE__, NULL) +#define TEST_ASSERT_FLOAT_IS_NOT_NEG_INF(actual) UNITY_TEST_ASSERT_FLOAT_IS_NOT_NEG_INF((actual), __LINE__, NULL) +#define TEST_ASSERT_FLOAT_IS_NOT_NAN(actual) UNITY_TEST_ASSERT_FLOAT_IS_NOT_NAN((actual), __LINE__, NULL) +#define TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(actual) UNITY_TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE((actual), __LINE__, NULL) + +/* Double (If Enabled) */ +#define TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_DOUBLE_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_DOUBLE_NOT_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_DOUBLE_NOT_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_DOUBLE(expected, actual) UNITY_TEST_ASSERT_EQUAL_DOUBLE((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_DOUBLE(expected, actual) UNITY_TEST_ASSERT_NOT_EQUAL_DOUBLE((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_DOUBLE_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_DOUBLE_ARRAY_WITHIN((delta), (expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_DOUBLE(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_DOUBLE(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_DOUBLE((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_DOUBLE(threshold, actual) UNITY_TEST_ASSERT_LESS_THAN_DOUBLE((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(threshold, actual) UNITY_TEST_ASSERT_LESS_OR_EQUAL_DOUBLE((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_DOUBLE_IS_INF(actual) UNITY_TEST_ASSERT_DOUBLE_IS_INF((actual), __LINE__, NULL) +#define TEST_ASSERT_DOUBLE_IS_NEG_INF(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF((actual), __LINE__, NULL) +#define TEST_ASSERT_DOUBLE_IS_NAN(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NAN((actual), __LINE__, NULL) +#define TEST_ASSERT_DOUBLE_IS_DETERMINATE(actual) UNITY_TEST_ASSERT_DOUBLE_IS_DETERMINATE((actual), __LINE__, NULL) +#define TEST_ASSERT_DOUBLE_IS_NOT_INF(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_INF((actual), __LINE__, NULL) +#define TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF((actual), __LINE__, NULL) +#define TEST_ASSERT_DOUBLE_IS_NOT_NAN(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NAN((actual), __LINE__, NULL) +#define TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE((actual), __LINE__, NULL) + +/* Shorthand */ +#ifdef UNITY_SHORTHAND_AS_OLD +#define TEST_ASSERT_EQUAL(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL(expected, actual) UNITY_TEST_ASSERT(((expected) != (actual)), __LINE__, " Expected Not-Equal") +#endif +#ifdef UNITY_SHORTHAND_AS_INT +#define TEST_ASSERT_EQUAL(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL(expected, actual) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand) +#endif +#ifdef UNITY_SHORTHAND_AS_MEM +#define TEST_ASSERT_EQUAL(expected, actual) UNITY_TEST_ASSERT_EQUAL_MEMORY((&expected), (&actual), sizeof(expected), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL(expected, actual) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand) +#endif +#ifdef UNITY_SHORTHAND_AS_RAW +#define TEST_ASSERT_EQUAL(expected, actual) UNITY_TEST_ASSERT(((expected) == (actual)), __LINE__, " Expected Equal") +#define TEST_ASSERT_NOT_EQUAL(expected, actual) UNITY_TEST_ASSERT(((expected) != (actual)), __LINE__, " Expected Not-Equal") +#endif +#ifdef UNITY_SHORTHAND_AS_NONE +#define TEST_ASSERT_EQUAL(expected, actual) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand) +#define TEST_ASSERT_NOT_EQUAL(expected, actual) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand) +#endif + +/*------------------------------------------------------- + * Test Asserts (with additional messages) + *-------------------------------------------------------*/ + +/* Boolean */ +#define TEST_ASSERT_MESSAGE(condition, message) UNITY_TEST_ASSERT( (condition), __LINE__, (message)) +#define TEST_ASSERT_TRUE_MESSAGE(condition, message) UNITY_TEST_ASSERT( (condition), __LINE__, (message)) +#define TEST_ASSERT_UNLESS_MESSAGE(condition, message) UNITY_TEST_ASSERT( !(condition), __LINE__, (message)) +#define TEST_ASSERT_FALSE_MESSAGE(condition, message) UNITY_TEST_ASSERT( !(condition), __LINE__, (message)) +#define TEST_ASSERT_NULL_MESSAGE(pointer, message) UNITY_TEST_ASSERT_NULL( (pointer), __LINE__, (message)) +#define TEST_ASSERT_NOT_NULL_MESSAGE(pointer, message) UNITY_TEST_ASSERT_NOT_NULL((pointer), __LINE__, (message)) +#define TEST_ASSERT_EMPTY_MESSAGE(pointer, message) UNITY_TEST_ASSERT_EMPTY( (pointer), __LINE__, (message)) +#define TEST_ASSERT_NOT_EMPTY_MESSAGE(pointer, message) UNITY_TEST_ASSERT_NOT_EMPTY((pointer), __LINE__, (message)) + +/* Integers (of all sizes) */ +#define TEST_ASSERT_EQUAL_INT_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_INT8_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT8((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_INT16_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT16((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_INT32_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT32((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_INT64_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT64((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_UINT_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT( (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_UINT8_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT8( (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_UINT16_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT16( (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_UINT32_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT32( (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_UINT64_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT64( (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_size_t_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT( (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_HEX_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_HEX8_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX8( (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_HEX16_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX16((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_HEX32_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_HEX64_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX64((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_BITS_MESSAGE(mask, expected, actual, message) UNITY_TEST_ASSERT_BITS((mask), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_BITS_HIGH_MESSAGE(mask, actual, message) UNITY_TEST_ASSERT_BITS((mask), (UNITY_UINT32)(-1), (actual), __LINE__, (message)) +#define TEST_ASSERT_BITS_LOW_MESSAGE(mask, actual, message) UNITY_TEST_ASSERT_BITS((mask), (UNITY_UINT32)(0), (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_EQUAL_CHAR_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_CHAR((expected), (actual), __LINE__, (message)) + +/* Integer Not Equal To (of all sizes) */ +#define TEST_ASSERT_NOT_EQUAL_INT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_INT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_INT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_INT8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_INT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_INT16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_INT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_INT32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_INT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_INT64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_UINT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_UINT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_UINT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_UINT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_UINT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_size_t_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_HEX8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_HEX8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_HEX16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_HEX16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_HEX32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_HEX32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_HEX64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_HEX64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_CHAR_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_CHAR((threshold), (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_INT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_INT64((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_UINT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_UINT64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_size_t_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_UINT((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_GREATER_THAN_HEX64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_HEX64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_CHAR_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_CHAR((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_INT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_INT64((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_UINT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_UINT64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_size_t_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_UINT((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)) +#define TEST_ASSERT_LESS_THAN_HEX64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_HEX64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_CHAR_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_CHAR((threshold), (actual), __LINE__, (message)) + +#define TEST_ASSERT_GREATER_OR_EQUAL_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_INT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_INT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_INT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_INT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_INT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_UINT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_UINT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_UINT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_UINT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_UINT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_size_t_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_HEX8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_HEX16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_HEX32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_HEX64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_CHAR_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_CHAR((threshold), (actual), __LINE__, (message)) + +#define TEST_ASSERT_LESS_OR_EQUAL_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_INT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_INT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_INT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_INT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_INT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_UINT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_UINT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_UINT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_UINT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_UINT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_size_t_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_HEX8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_HEX16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_HEX32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_HEX64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_CHAR_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_CHAR((threshold), (actual), __LINE__, (message)) + +/* 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_INT8_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT8_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_INT16_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT16_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_INT32_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT32_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_INT64_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT64_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_UINT_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_UINT8_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT8_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_UINT16_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT16_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_UINT32_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT32_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_UINT64_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT64_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_size_t_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_HEX_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_HEX8_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX8_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_HEX16_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX16_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_HEX32_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_HEX64_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX64_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_CHAR_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_CHAR_WITHIN((delta), (expected), (actual), __LINE__, (message)) + +/* Integer Array Ranges (of all sizes) */ +#define TEST_ASSERT_INT_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_INT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_INT8_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_INT8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_INT16_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_INT16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_INT32_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_INT32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_INT64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_UINT_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_UINT8_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_UINT16_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_UINT32_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_size_t_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_HEX_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_HEX8_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_HEX8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_HEX16_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_HEX16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_HEX32_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_HEX64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_CHAR_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_CHAR_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) + + +/* Structs and Strings */ +#define TEST_ASSERT_EQUAL_PTR_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_PTR((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_STRING_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_STRING((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_STRING_LEN_MESSAGE(expected, actual, len, message) UNITY_TEST_ASSERT_EQUAL_STRING_LEN((expected), (actual), (len), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_MEMORY_MESSAGE(expected, actual, len, message) UNITY_TEST_ASSERT_EQUAL_MEMORY((expected), (actual), (len), __LINE__, (message)) + +/* Arrays */ +#define TEST_ASSERT_EQUAL_INT_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_INT8_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT8_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_INT16_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT16_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_INT32_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT32_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_INT64_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT64_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_UINT_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT8_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_UINT16_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_UINT32_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT32_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_UINT64_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_size_t_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_HEX_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_HEX8_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_HEX16_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX16_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_HEX32_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_HEX64_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_PTR_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_PTR_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_STRING_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_STRING_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_MEMORY_ARRAY_MESSAGE(expected, actual, len, num_elements, message) UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((expected), (actual), (len), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_CHAR_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_CHAR_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) + +/* Arrays Compared To Single Value*/ +#define TEST_ASSERT_EACH_EQUAL_INT_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_INT((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_INT8_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_INT8((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_INT16_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_INT16((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_INT32_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_INT32((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_INT64_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_INT64((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_UINT_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_UINT8_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT8((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_UINT16_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT16((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_UINT32_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT32((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_UINT64_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT64((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_size_t_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_HEX_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_HEX32((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_HEX8_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_HEX8((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_HEX16_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_HEX16((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_HEX32_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_HEX32((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_HEX64_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_HEX64((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_PTR_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_PTR((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_STRING_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_STRING((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_MEMORY_MESSAGE(expected, actual, len, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_MEMORY((expected), (actual), (len), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_CHAR_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_CHAR((expected), (actual), (num_elements), __LINE__, (message)) + +/* Floating Point (If Enabled) */ +#define TEST_ASSERT_FLOAT_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_FLOAT_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_FLOAT_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_FLOAT((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_FLOAT_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_FLOAT((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_FLOAT_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_FLOAT_ARRAY_WITHIN((delta), (expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_FLOAT_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_FLOAT_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_FLOAT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_FLOAT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_FLOAT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_FLOAT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_FLOAT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_LESS_THAN_FLOAT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_FLOAT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_LESS_OR_EQUAL_FLOAT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_FLOAT_IS_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_INF((actual), __LINE__, (message)) +#define TEST_ASSERT_FLOAT_IS_NEG_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF((actual), __LINE__, (message)) +#define TEST_ASSERT_FLOAT_IS_NAN_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NAN((actual), __LINE__, (message)) +#define TEST_ASSERT_FLOAT_IS_DETERMINATE_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_DETERMINATE((actual), __LINE__, (message)) +#define TEST_ASSERT_FLOAT_IS_NOT_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NOT_INF((actual), __LINE__, (message)) +#define TEST_ASSERT_FLOAT_IS_NOT_NEG_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NOT_NEG_INF((actual), __LINE__, (message)) +#define TEST_ASSERT_FLOAT_IS_NOT_NAN_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NOT_NAN((actual), __LINE__, (message)) +#define TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE((actual), __LINE__, (message)) + +/* Double (If Enabled) */ +#define TEST_ASSERT_DOUBLE_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_DOUBLE_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_DOUBLE_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_DOUBLE((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_DOUBLE_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_DOUBLE((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_DOUBLE_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_DOUBLE_ARRAY_WITHIN((delta), (expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_DOUBLE_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_DOUBLE_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_DOUBLE_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_DOUBLE((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_DOUBLE_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_LESS_THAN_DOUBLE((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_DOUBLE_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_LESS_OR_EQUAL_DOUBLE((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_DOUBLE_IS_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_INF((actual), __LINE__, (message)) +#define TEST_ASSERT_DOUBLE_IS_NEG_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF((actual), __LINE__, (message)) +#define TEST_ASSERT_DOUBLE_IS_NAN_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NAN((actual), __LINE__, (message)) +#define TEST_ASSERT_DOUBLE_IS_DETERMINATE_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_DETERMINATE((actual), __LINE__, (message)) +#define TEST_ASSERT_DOUBLE_IS_NOT_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_INF((actual), __LINE__, (message)) +#define TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF((actual), __LINE__, (message)) +#define TEST_ASSERT_DOUBLE_IS_NOT_NAN_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NAN((actual), __LINE__, (message)) +#define TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE((actual), __LINE__, (message)) + +/* Shorthand */ +#ifdef UNITY_SHORTHAND_AS_OLD +#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT(((expected) != (actual)), __LINE__, (message)) +#endif +#ifdef UNITY_SHORTHAND_AS_INT +#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, message) +#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand) +#endif +#ifdef UNITY_SHORTHAND_AS_MEM +#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_MEMORY((&expected), (&actual), sizeof(expected), __LINE__, message) +#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand) +#endif +#ifdef UNITY_SHORTHAND_AS_RAW +#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT(((expected) == (actual)), __LINE__, message) +#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT(((expected) != (actual)), __LINE__, message) +#endif +#ifdef UNITY_SHORTHAND_AS_NONE +#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand) +#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand) +#endif + +/* end of UNITY_FRAMEWORK_H */ +#ifdef __cplusplus +} +#endif +#endif diff --git a/subprojects/unity/src/unity_internals.h b/subprojects/unity/src/unity_internals.h new file mode 100644 index 0000000000..562f5b6da6 --- /dev/null +++ b/subprojects/unity/src/unity_internals.h @@ -0,0 +1,1183 @@ +/* ========================================================================= + Unity - A Test Framework for C + ThrowTheSwitch.org + Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams + SPDX-License-Identifier: MIT +========================================================================= */ + +#ifndef UNITY_INTERNALS_H +#define UNITY_INTERNALS_H + +#ifdef UNITY_INCLUDE_CONFIG_H +#include "unity_config.h" +#endif + +#ifndef UNITY_EXCLUDE_SETJMP_H +#include +#endif + +#ifndef UNITY_EXCLUDE_MATH_H +#include +#endif + +#ifndef UNITY_EXCLUDE_STDDEF_H +#include +#endif + +#ifdef UNITY_INCLUDE_PRINT_FORMATTED +#include +#endif + +/* Unity Attempts to Auto-Detect Integer Types + * Attempt 1: UINT_MAX, ULONG_MAX in , or default to 32 bits + * Attempt 2: UINTPTR_MAX in , or default to same size as long + * The user may override any of these derived constants: + * UNITY_INT_WIDTH, UNITY_LONG_WIDTH, UNITY_POINTER_WIDTH */ +#ifndef UNITY_EXCLUDE_STDINT_H +#include +#endif + +#ifndef UNITY_EXCLUDE_LIMITS_H +#include +#endif + +#if defined(__GNUC__) || defined(__clang__) + #define UNITY_FUNCTION_ATTR(a) __attribute__((a)) +#else + #define UNITY_FUNCTION_ATTR(a) /* ignore */ +#endif + +/* UNITY_NORETURN is only required if we have setjmp.h. */ +#ifndef UNITY_EXCLUDE_SETJMP_H + #ifndef UNITY_NORETURN + #if defined(__cplusplus) + #if __cplusplus >= 201103L + #define UNITY_NORETURN [[ noreturn ]] + #endif + #elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && __STDC_VERSION__ < 202311L + /* _Noreturn keyword is used from C11 but deprecated in C23. */ + #if defined(_WIN32) && defined(_MSC_VER) + /* We are using MSVC compiler on Windows platform. */ + /* Not all Windows SDKs supports , but compiler can support C11: */ + /* https://devblogs.microsoft.com/cppblog/c11-and-c17-standard-support-arriving-in-msvc/ */ + /* Not sure, that Mingw compilers has Windows SDK headers at all. */ + #include + #endif + + /* Using Windows SDK predefined macro for detecting supported SDK with MSVC compiler. */ + /* Mingw GCC should work without that fixes. */ + /* Based on: */ + /* https://docs.microsoft.com/en-us/cpp/porting/modifying-winver-and-win32-winnt?view=msvc-170 */ + /* NTDDI_WIN10_FE is equal to Windows 10 SDK 2104 */ + #if defined(_MSC_VER) && ((!defined(NTDDI_WIN10_FE)) || WDK_NTDDI_VERSION < NTDDI_WIN10_FE) + /* Based on tests and: */ + /* https://docs.microsoft.com/en-us/cpp/c-language/noreturn?view=msvc-170 */ + /* https://en.cppreference.com/w/c/language/_Noreturn */ + #define UNITY_NORETURN _Noreturn + #else /* Using newer Windows SDK or not MSVC compiler */ + #if defined(__GNUC__) + /* The header collides with __attribute(noreturn)__ from GCC. */ + #define UNITY_NORETURN _Noreturn + #else + #include + #define UNITY_NORETURN noreturn + #endif + #endif + #elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L + /* Since C23, the keyword _Noreturn has been replaced by the attribute noreturn, based on: */ + /* https://en.cppreference.com/w/c/language/attributes/noreturn */ + #define UNITY_NORETURN [[ noreturn ]] + #endif + #endif + #ifndef UNITY_NORETURN + #define UNITY_NORETURN UNITY_FUNCTION_ATTR(__noreturn__) + #endif +#endif + +/*------------------------------------------------------- + * Guess Widths If Not Specified + *-------------------------------------------------------*/ + +/* Determine the size of an int, if not already specified. + * We cannot use sizeof(int), because it is not yet defined + * at this stage in the translation of the C program. + * Also sizeof(int) does return the size in addressable units on all platforms, + * which may not necessarily be the size in bytes. + * Therefore, infer it from UINT_MAX if possible. */ +#ifndef UNITY_INT_WIDTH + #ifdef UINT_MAX + #if (UINT_MAX == 0xFFFF) + #define UNITY_INT_WIDTH (16) + #elif (UINT_MAX == 0xFFFFFFFF) + #define UNITY_INT_WIDTH (32) + #elif (UINT_MAX == 0xFFFFFFFFFFFFFFFF) + #define UNITY_INT_WIDTH (64) + #endif + #else /* Set to default */ + #define UNITY_INT_WIDTH (32) + #endif /* UINT_MAX */ +#endif + +/* Determine the size of a long, if not already specified. */ +#ifndef UNITY_LONG_WIDTH + #ifdef ULONG_MAX + #if (ULONG_MAX == 0xFFFF) + #define UNITY_LONG_WIDTH (16) + #elif (ULONG_MAX == 0xFFFFFFFF) + #define UNITY_LONG_WIDTH (32) + #elif (ULONG_MAX == 0xFFFFFFFFFFFFFFFF) + #define UNITY_LONG_WIDTH (64) + #endif + #else /* Set to default */ + #define UNITY_LONG_WIDTH (32) + #endif /* ULONG_MAX */ +#endif + +/* Determine the size of a pointer, if not already specified. */ +#ifndef UNITY_POINTER_WIDTH + #ifdef UINTPTR_MAX + #if (UINTPTR_MAX <= 0xFFFF) + #define UNITY_POINTER_WIDTH (16) + #elif (UINTPTR_MAX <= 0xFFFFFFFF) + #define UNITY_POINTER_WIDTH (32) + #elif (UINTPTR_MAX <= 0xFFFFFFFFFFFFFFFF) + #define UNITY_POINTER_WIDTH (64) + #endif + #else /* Set to default */ + #define UNITY_POINTER_WIDTH UNITY_LONG_WIDTH + #endif /* UINTPTR_MAX */ +#endif + +/*------------------------------------------------------- + * Int Support (Define types based on detected sizes) + *-------------------------------------------------------*/ + +#if (UNITY_INT_WIDTH == 32) + typedef unsigned char UNITY_UINT8; + typedef unsigned short UNITY_UINT16; + typedef unsigned int UNITY_UINT32; + typedef signed char UNITY_INT8; + typedef signed short UNITY_INT16; + typedef signed int UNITY_INT32; +#elif (UNITY_INT_WIDTH == 16) + typedef unsigned char UNITY_UINT8; + typedef unsigned int UNITY_UINT16; + typedef unsigned long UNITY_UINT32; + typedef signed char UNITY_INT8; + typedef signed int UNITY_INT16; + typedef signed long UNITY_INT32; +#else + #error Invalid UNITY_INT_WIDTH specified! (16 or 32 are supported) +#endif + +/*------------------------------------------------------- + * 64-bit Support + *-------------------------------------------------------*/ + +/* Auto-detect 64 Bit Support */ +#ifndef UNITY_SUPPORT_64 + #if UNITY_LONG_WIDTH == 64 || UNITY_POINTER_WIDTH == 64 + #define UNITY_SUPPORT_64 + #endif +#endif + +/* 64-Bit Support Dependent Configuration */ +#ifndef UNITY_SUPPORT_64 + /* No 64-bit Support */ + typedef UNITY_UINT32 UNITY_UINT; + typedef UNITY_INT32 UNITY_INT; + #define UNITY_MAX_NIBBLES (8) /* Maximum number of nibbles in a UNITY_(U)INT */ +#else + /* 64-bit Support */ + #if (UNITY_LONG_WIDTH == 32) + typedef unsigned long long UNITY_UINT64; + typedef signed long long UNITY_INT64; + #elif (UNITY_LONG_WIDTH == 64) + typedef unsigned long UNITY_UINT64; + typedef signed long UNITY_INT64; + #else + #error Invalid UNITY_LONG_WIDTH specified! (32 or 64 are supported) + #endif + typedef UNITY_UINT64 UNITY_UINT; + typedef UNITY_INT64 UNITY_INT; + #define UNITY_MAX_NIBBLES (16) /* Maximum number of nibbles in a UNITY_(U)INT */ +#endif + +/*------------------------------------------------------- + * Pointer Support + *-------------------------------------------------------*/ + +#if (UNITY_POINTER_WIDTH == 32) + #define UNITY_PTR_TO_INT UNITY_INT32 + #define UNITY_DISPLAY_STYLE_POINTER UNITY_DISPLAY_STYLE_HEX32 +#elif (UNITY_POINTER_WIDTH == 64) + #define UNITY_PTR_TO_INT UNITY_INT64 + #define UNITY_DISPLAY_STYLE_POINTER UNITY_DISPLAY_STYLE_HEX64 +#elif (UNITY_POINTER_WIDTH == 16) + #define UNITY_PTR_TO_INT UNITY_INT16 + #define UNITY_DISPLAY_STYLE_POINTER UNITY_DISPLAY_STYLE_HEX16 +#else + #error Invalid UNITY_POINTER_WIDTH specified! (16, 32 or 64 are supported) +#endif + +#ifndef UNITY_PTR_ATTRIBUTE + #define UNITY_PTR_ATTRIBUTE +#endif + +#ifndef UNITY_INTERNAL_PTR + #define UNITY_INTERNAL_PTR UNITY_PTR_ATTRIBUTE const void* +#endif + +/* optionally define UNITY_COMPARE_PTRS_ON_ZERO_ARRAY */ + +/*------------------------------------------------------- + * Float Support + *-------------------------------------------------------*/ + +#ifdef UNITY_EXCLUDE_FLOAT + +/* No Floating Point Support */ +#ifndef UNITY_EXCLUDE_DOUBLE +#define UNITY_EXCLUDE_DOUBLE /* Remove double when excluding float support */ +#endif +#ifndef UNITY_EXCLUDE_FLOAT_PRINT +#define UNITY_EXCLUDE_FLOAT_PRINT +#endif + +#else + +/* Floating Point Support */ +#ifndef UNITY_FLOAT_PRECISION +#define UNITY_FLOAT_PRECISION (0.00001f) +#endif +#ifndef UNITY_FLOAT_TYPE +#define UNITY_FLOAT_TYPE float +#endif +typedef UNITY_FLOAT_TYPE UNITY_FLOAT; + +/* isnan macro should be provided by math.h. Override if not macro */ +#ifndef UNITY_IS_NAN +#ifndef isnan +/* NaN is the only floating point value that does NOT equal itself. + * Therefore if n != n, then it is NaN. */ +#define UNITY_IS_NAN(n) ((n != n) ? 1 : 0) +#else +#define UNITY_IS_NAN(n) isnan(n) +#endif +#endif + +/* isinf macro should be provided by math.h. Override if not macro */ +#ifndef UNITY_IS_INF +#ifndef isinf +/* The value of Inf - Inf is NaN */ +#define UNITY_IS_INF(n) (UNITY_IS_NAN((n) - (n)) && !UNITY_IS_NAN(n)) +#else +#define UNITY_IS_INF(n) isinf(n) +#endif +#endif + +#endif + +/*------------------------------------------------------- + * Double Float Support + *-------------------------------------------------------*/ + +/* unlike float, we DON'T include by default */ +#if defined(UNITY_EXCLUDE_DOUBLE) || !defined(UNITY_INCLUDE_DOUBLE) + + /* No Floating Point Support */ + #ifndef UNITY_EXCLUDE_DOUBLE + #define UNITY_EXCLUDE_DOUBLE + #else + #undef UNITY_INCLUDE_DOUBLE + #endif + + #ifndef UNITY_EXCLUDE_FLOAT + #ifndef UNITY_DOUBLE_TYPE + #define UNITY_DOUBLE_TYPE double + #endif + typedef UNITY_FLOAT UNITY_DOUBLE; + /* For parameter in UnityPrintFloat(UNITY_DOUBLE), which aliases to double or float */ + #endif + +#else + + /* Double Floating Point Support */ + #ifndef UNITY_DOUBLE_PRECISION + #define UNITY_DOUBLE_PRECISION (1e-12) + #endif + + #ifndef UNITY_DOUBLE_TYPE + #define UNITY_DOUBLE_TYPE double + #endif + typedef UNITY_DOUBLE_TYPE UNITY_DOUBLE; + +#endif + +/*------------------------------------------------------- + * Output Method: stdout (DEFAULT) + *-------------------------------------------------------*/ +#ifndef UNITY_OUTPUT_CHAR + /* Default to using putchar, which is defined in stdio.h */ + #include + #define UNITY_OUTPUT_CHAR(a) (void)putchar(a) +#else + /* If defined as something else, make sure we declare it here so it's ready for use */ + #ifdef UNITY_OUTPUT_CHAR_HEADER_DECLARATION + extern void UNITY_OUTPUT_CHAR_HEADER_DECLARATION; + #endif +#endif + +#ifndef UNITY_OUTPUT_FLUSH + #ifdef UNITY_USE_FLUSH_STDOUT + /* We want to use the stdout flush utility */ + #include + #define UNITY_OUTPUT_FLUSH() (void)fflush(stdout) + #else + /* We've specified nothing, therefore flush should just be ignored */ + #define UNITY_OUTPUT_FLUSH() (void)0 + #endif +#else + /* If defined as something else, make sure we declare it here so it's ready for use */ + #ifdef UNITY_OUTPUT_FLUSH_HEADER_DECLARATION + extern void UNITY_OUTPUT_FLUSH_HEADER_DECLARATION; + #endif +#endif + +#ifndef UNITY_OUTPUT_FLUSH +#define UNITY_FLUSH_CALL() +#else +#define UNITY_FLUSH_CALL() UNITY_OUTPUT_FLUSH() +#endif + +#ifndef UNITY_PRINT_EOL +#define UNITY_PRINT_EOL() UNITY_OUTPUT_CHAR('\n') +#endif + +#ifndef UNITY_OUTPUT_START +#define UNITY_OUTPUT_START() +#endif + +#ifndef UNITY_OUTPUT_COMPLETE +#define UNITY_OUTPUT_COMPLETE() +#endif + +#ifdef UNITY_INCLUDE_EXEC_TIME + #if !defined(UNITY_EXEC_TIME_START) && \ + !defined(UNITY_EXEC_TIME_STOP) && \ + !defined(UNITY_PRINT_EXEC_TIME) && \ + !defined(UNITY_TIME_TYPE) + /* If none any of these macros are defined then try to provide a default implementation */ + + #if defined(UNITY_CLOCK_MS) + /* This is a simple way to get a default implementation on platforms that support getting a millisecond counter */ + #define UNITY_TIME_TYPE UNITY_UINT + #define UNITY_EXEC_TIME_START() Unity.CurrentTestStartTime = UNITY_CLOCK_MS() + #define UNITY_EXEC_TIME_STOP() Unity.CurrentTestStopTime = UNITY_CLOCK_MS() + #define UNITY_PRINT_EXEC_TIME() { \ + UNITY_UINT execTimeMs = (Unity.CurrentTestStopTime - Unity.CurrentTestStartTime); \ + UnityPrint(" ("); \ + UnityPrintNumberUnsigned(execTimeMs); \ + UnityPrint(" ms)"); \ + } + #elif defined(_WIN32) + #include + #define UNITY_TIME_TYPE clock_t + #define UNITY_GET_TIME(t) t = (clock_t)((clock() * 1000) / CLOCKS_PER_SEC) + #define UNITY_EXEC_TIME_START() UNITY_GET_TIME(Unity.CurrentTestStartTime) + #define UNITY_EXEC_TIME_STOP() UNITY_GET_TIME(Unity.CurrentTestStopTime) + #define UNITY_PRINT_EXEC_TIME() { \ + UNITY_UINT execTimeMs = (Unity.CurrentTestStopTime - Unity.CurrentTestStartTime); \ + UnityPrint(" ("); \ + UnityPrintNumberUnsigned(execTimeMs); \ + UnityPrint(" ms)"); \ + } + #elif defined(__unix__) || defined(__APPLE__) + #include + #define UNITY_TIME_TYPE struct timespec + #define UNITY_GET_TIME(t) clock_gettime(CLOCK_MONOTONIC, &t) + #define UNITY_EXEC_TIME_START() UNITY_GET_TIME(Unity.CurrentTestStartTime) + #define UNITY_EXEC_TIME_STOP() UNITY_GET_TIME(Unity.CurrentTestStopTime) + #define UNITY_PRINT_EXEC_TIME() { \ + UNITY_UINT execTimeMs = ((Unity.CurrentTestStopTime.tv_sec - Unity.CurrentTestStartTime.tv_sec) * 1000L); \ + execTimeMs += ((Unity.CurrentTestStopTime.tv_nsec - Unity.CurrentTestStartTime.tv_nsec) / 1000000L); \ + UnityPrint(" ("); \ + UnityPrintNumberUnsigned(execTimeMs); \ + UnityPrint(" ms)"); \ + } + #endif + #endif +#endif + +#ifndef UNITY_EXEC_TIME_START +#define UNITY_EXEC_TIME_START() do { /* nothing*/ } while (0) +#endif + +#ifndef UNITY_EXEC_TIME_STOP +#define UNITY_EXEC_TIME_STOP() do { /* nothing*/ } while (0) +#endif + +#ifndef UNITY_TIME_TYPE +#define UNITY_TIME_TYPE UNITY_UINT +#endif + +#ifndef UNITY_PRINT_EXEC_TIME +#define UNITY_PRINT_EXEC_TIME() do { /* nothing*/ } while (0) +#endif + +/*------------------------------------------------------- + * Footprint + *-------------------------------------------------------*/ + +#ifndef UNITY_LINE_TYPE +#define UNITY_LINE_TYPE UNITY_UINT +#endif + +#ifndef UNITY_COUNTER_TYPE +#define UNITY_COUNTER_TYPE UNITY_UINT +#endif + +/*------------------------------------------------------- + * Internal Structs Needed + *-------------------------------------------------------*/ + +typedef void (*UnityTestFunction)(void); + +#define UNITY_DISPLAY_RANGE_INT (0x10) +#define UNITY_DISPLAY_RANGE_UINT (0x20) +#define UNITY_DISPLAY_RANGE_HEX (0x40) +#define UNITY_DISPLAY_RANGE_CHAR (0x80) + +typedef enum +{ + UNITY_DISPLAY_STYLE_INT = (UNITY_INT_WIDTH / 8) + UNITY_DISPLAY_RANGE_INT, + UNITY_DISPLAY_STYLE_INT8 = 1 + UNITY_DISPLAY_RANGE_INT, + UNITY_DISPLAY_STYLE_INT16 = 2 + UNITY_DISPLAY_RANGE_INT, + UNITY_DISPLAY_STYLE_INT32 = 4 + UNITY_DISPLAY_RANGE_INT, +#ifdef UNITY_SUPPORT_64 + UNITY_DISPLAY_STYLE_INT64 = 8 + UNITY_DISPLAY_RANGE_INT, +#endif + + UNITY_DISPLAY_STYLE_UINT = (UNITY_INT_WIDTH / 8) + UNITY_DISPLAY_RANGE_UINT, + UNITY_DISPLAY_STYLE_UINT8 = 1 + UNITY_DISPLAY_RANGE_UINT, + UNITY_DISPLAY_STYLE_UINT16 = 2 + UNITY_DISPLAY_RANGE_UINT, + UNITY_DISPLAY_STYLE_UINT32 = 4 + UNITY_DISPLAY_RANGE_UINT, +#ifdef UNITY_SUPPORT_64 + UNITY_DISPLAY_STYLE_UINT64 = 8 + UNITY_DISPLAY_RANGE_UINT, +#endif + + UNITY_DISPLAY_STYLE_HEX8 = 1 + UNITY_DISPLAY_RANGE_HEX, + UNITY_DISPLAY_STYLE_HEX16 = 2 + UNITY_DISPLAY_RANGE_HEX, + UNITY_DISPLAY_STYLE_HEX32 = 4 + UNITY_DISPLAY_RANGE_HEX, +#ifdef UNITY_SUPPORT_64 + UNITY_DISPLAY_STYLE_HEX64 = 8 + UNITY_DISPLAY_RANGE_HEX, +#endif + + UNITY_DISPLAY_STYLE_CHAR = 1 + UNITY_DISPLAY_RANGE_CHAR + UNITY_DISPLAY_RANGE_INT, + + UNITY_DISPLAY_STYLE_UNKNOWN +} UNITY_DISPLAY_STYLE_T; + +typedef enum +{ + UNITY_WITHIN = 0x0, + UNITY_EQUAL_TO = 0x1, + UNITY_GREATER_THAN = 0x2, + UNITY_GREATER_OR_EQUAL = 0x2 + UNITY_EQUAL_TO, + UNITY_SMALLER_THAN = 0x4, + UNITY_SMALLER_OR_EQUAL = 0x4 + UNITY_EQUAL_TO, + UNITY_NOT_EQUAL = 0x0, + UNITY_UNKNOWN +} UNITY_COMPARISON_T; + +#ifndef UNITY_EXCLUDE_FLOAT +typedef enum UNITY_FLOAT_TRAIT +{ + UNITY_FLOAT_IS_NOT_INF = 0, + UNITY_FLOAT_IS_INF, + UNITY_FLOAT_IS_NOT_NEG_INF, + UNITY_FLOAT_IS_NEG_INF, + UNITY_FLOAT_IS_NOT_NAN, + UNITY_FLOAT_IS_NAN, + UNITY_FLOAT_IS_NOT_DET, + UNITY_FLOAT_IS_DET, + UNITY_FLOAT_INVALID_TRAIT +} UNITY_FLOAT_TRAIT_T; +#endif + +typedef enum +{ + UNITY_ARRAY_TO_VAL = 0, + UNITY_ARRAY_TO_ARRAY, + UNITY_ARRAY_UNKNOWN +} UNITY_FLAGS_T; + +struct UNITY_STORAGE_T +{ + const char* TestFile; + const char* CurrentTestName; +#ifndef UNITY_EXCLUDE_DETAILS + const char* CurrentDetail1; + const char* CurrentDetail2; +#endif + UNITY_LINE_TYPE CurrentTestLineNumber; + UNITY_COUNTER_TYPE NumberOfTests; + UNITY_COUNTER_TYPE TestFailures; + UNITY_COUNTER_TYPE TestIgnores; + UNITY_COUNTER_TYPE CurrentTestFailed; + UNITY_COUNTER_TYPE CurrentTestIgnored; +#ifdef UNITY_INCLUDE_EXEC_TIME + UNITY_TIME_TYPE CurrentTestStartTime; + UNITY_TIME_TYPE CurrentTestStopTime; +#endif +#ifndef UNITY_EXCLUDE_SETJMP_H + jmp_buf AbortFrame; +#endif +}; + +extern struct UNITY_STORAGE_T Unity; + +/*------------------------------------------------------- + * Test Suite Management + *-------------------------------------------------------*/ + +void UnityBegin(const char* filename); +int UnityEnd(void); +void UnitySetTestFile(const char* filename); +void UnityConcludeTest(void); + +#ifndef RUN_TEST +void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int FuncLineNum); +#else +#define UNITY_SKIP_DEFAULT_RUNNER +#endif + +/*------------------------------------------------------- + * Details Support + *-------------------------------------------------------*/ + +#ifdef UNITY_EXCLUDE_DETAILS +#define UNITY_CLR_DETAILS() +#define UNITY_SET_DETAIL(d1) +#define UNITY_SET_DETAILS(d1,d2) +#else +#define UNITY_CLR_DETAILS() do { Unity.CurrentDetail1 = 0; Unity.CurrentDetail2 = 0; } while (0) +#define UNITY_SET_DETAIL(d1) do { Unity.CurrentDetail1 = (d1); Unity.CurrentDetail2 = 0; } while (0) +#define UNITY_SET_DETAILS(d1,d2) do { Unity.CurrentDetail1 = (d1); Unity.CurrentDetail2 = (d2); } while (0) + +#ifndef UNITY_DETAIL1_NAME +#define UNITY_DETAIL1_NAME "Function" +#endif + +#ifndef UNITY_DETAIL2_NAME +#define UNITY_DETAIL2_NAME "Argument" +#endif +#endif + +#ifdef UNITY_PRINT_TEST_CONTEXT +void UNITY_PRINT_TEST_CONTEXT(void); +#endif + +/*------------------------------------------------------- + * Test Output + *-------------------------------------------------------*/ + +void UnityPrint(const char* string); + +#ifdef UNITY_INCLUDE_PRINT_FORMATTED +void UnityPrintF(const UNITY_LINE_TYPE line, const char* format, ...); +#endif + +void UnityPrintLen(const char* string, const UNITY_UINT32 length); +void UnityPrintMask(const UNITY_UINT mask, const UNITY_UINT number); +void UnityPrintNumberByStyle(const UNITY_INT number, const UNITY_DISPLAY_STYLE_T style); +void UnityPrintNumber(const UNITY_INT number_to_print); +void UnityPrintNumberUnsigned(const UNITY_UINT number); +void UnityPrintNumberHex(const UNITY_UINT number, const char nibbles_to_print); + +#ifndef UNITY_EXCLUDE_FLOAT_PRINT +void UnityPrintFloat(const UNITY_DOUBLE input_number); +#endif + +/*------------------------------------------------------- + * Test Assertion Functions + *------------------------------------------------------- + * Use the macros below this section instead of calling + * these directly. The macros have a consistent naming + * convention and will pull in file and line information + * for you. */ + +void UnityAssertEqualNumber(const UNITY_INT expected, + const UNITY_INT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_DISPLAY_STYLE_T style); + +void UnityAssertGreaterOrLessOrEqualNumber(const UNITY_INT threshold, + const UNITY_INT actual, + const UNITY_COMPARISON_T compare, + const char *msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_DISPLAY_STYLE_T style); + +void UnityAssertEqualIntArray(UNITY_INTERNAL_PTR expected, + UNITY_INTERNAL_PTR actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_DISPLAY_STYLE_T style, + const UNITY_FLAGS_T flags); + +void UnityAssertBits(const UNITY_INT mask, + const UNITY_INT expected, + const UNITY_INT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber); + +void UnityAssertEqualString(const char* expected, + const char* actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber); + +void UnityAssertEqualStringLen(const char* expected, + const char* actual, + const UNITY_UINT32 length, + const char* msg, + const UNITY_LINE_TYPE lineNumber); + +void UnityAssertEqualStringArray( UNITY_INTERNAL_PTR expected, + const char** actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLAGS_T flags); + +void UnityAssertEqualMemory( UNITY_INTERNAL_PTR expected, + UNITY_INTERNAL_PTR actual, + const UNITY_UINT32 length, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLAGS_T flags); + +void UnityAssertNumbersWithin(const UNITY_UINT delta, + const UNITY_INT expected, + const UNITY_INT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_DISPLAY_STYLE_T style); + +void UnityAssertNumbersArrayWithin(const UNITY_UINT delta, + UNITY_INTERNAL_PTR expected, + UNITY_INTERNAL_PTR actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_DISPLAY_STYLE_T style, + const UNITY_FLAGS_T flags); + +#ifndef UNITY_EXCLUDE_SETJMP_H +UNITY_NORETURN void UnityFail(const char* message, const UNITY_LINE_TYPE line); +UNITY_NORETURN void UnityIgnore(const char* message, const UNITY_LINE_TYPE line); +#else +void UnityFail(const char* message, const UNITY_LINE_TYPE line); +void UnityIgnore(const char* message, const UNITY_LINE_TYPE line); +#endif + +void UnityMessage(const char* message, const UNITY_LINE_TYPE line); + +#ifndef UNITY_EXCLUDE_FLOAT +void UnityAssertFloatsWithin(const UNITY_FLOAT delta, + const UNITY_FLOAT expected, + const UNITY_FLOAT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber); + +void UnityAssertFloatsNotWithin(const UNITY_FLOAT delta, + const UNITY_FLOAT expected, + const UNITY_FLOAT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber); + +void UnityAssertGreaterOrLessFloat(const UNITY_FLOAT threshold, + const UNITY_FLOAT actual, + const UNITY_COMPARISON_T compare, + const char* msg, + const UNITY_LINE_TYPE linenumber); + +void UnityAssertWithinFloatArray(const UNITY_FLOAT delta, + UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* expected, + UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLAGS_T flags); + +void UnityAssertFloatSpecial(const UNITY_FLOAT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLOAT_TRAIT_T style); +#endif + +#ifndef UNITY_EXCLUDE_DOUBLE +void UnityAssertDoublesWithin(const UNITY_DOUBLE delta, + const UNITY_DOUBLE expected, + const UNITY_DOUBLE actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber); + +void UnityAssertDoublesNotWithin(const UNITY_DOUBLE delta, + const UNITY_DOUBLE expected, + const UNITY_DOUBLE actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber); + +void UnityAssertGreaterOrLessDouble(const UNITY_DOUBLE threshold, + const UNITY_DOUBLE actual, + const UNITY_COMPARISON_T compare, + const char* msg, + const UNITY_LINE_TYPE linenumber); + +void UnityAssertWithinDoubleArray(const UNITY_DOUBLE delta, + UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* expected, + UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLAGS_T flags); + +void UnityAssertDoubleSpecial(const UNITY_DOUBLE actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLOAT_TRAIT_T style); +#endif + +/*------------------------------------------------------- + * Helpers + *-------------------------------------------------------*/ + +UNITY_INTERNAL_PTR UnityNumToPtr(const UNITY_INT num, const UNITY_UINT8 size); +#ifndef UNITY_EXCLUDE_FLOAT +UNITY_INTERNAL_PTR UnityFloatToPtr(const float num); +#endif +#ifndef UNITY_EXCLUDE_DOUBLE +UNITY_INTERNAL_PTR UnityDoubleToPtr(const double num); +#endif + +/*------------------------------------------------------- + * Error Strings We Might Need + *-------------------------------------------------------*/ + +extern const char UnityStrOk[]; +extern const char UnityStrPass[]; +extern const char UnityStrFail[]; +extern const char UnityStrIgnore[]; + +extern const char UnityStrErrFloat[]; +extern const char UnityStrErrDouble[]; +extern const char UnityStrErr64[]; +extern const char UnityStrErrShorthand[]; + +/*------------------------------------------------------- + * Test Running Macros + *-------------------------------------------------------*/ + +#ifdef UNITY_TEST_PROTECT +#define TEST_PROTECT() UNITY_TEST_PROTECT() +#else +#ifndef UNITY_EXCLUDE_SETJMP_H +#define TEST_PROTECT() (setjmp(Unity.AbortFrame) == 0) +#else +#define TEST_PROTECT() 1 +#endif +#endif + +#ifdef UNITY_TEST_ABORT +#define TEST_ABORT() UNITY_TEST_ABORT() +#else +#ifndef UNITY_EXCLUDE_SETJMP_H +#define TEST_ABORT() longjmp(Unity.AbortFrame, 1) +#else +#define TEST_ABORT() return +#endif +#endif + +/* Automatically enable variadic macros support, if it not enabled before */ +#ifndef UNITY_SUPPORT_VARIADIC_MACROS + #ifdef __STDC_VERSION__ + #if __STDC_VERSION__ >= 199901L + #define UNITY_SUPPORT_VARIADIC_MACROS + #endif + #endif +#endif + +/* This tricky series of macros gives us an optional line argument to treat it as RUN_TEST(func, num=__LINE__) */ +#ifndef RUN_TEST +#ifdef UNITY_SUPPORT_VARIADIC_MACROS +#define RUN_TEST(...) RUN_TEST_AT_LINE(__VA_ARGS__, __LINE__, throwaway) +#define RUN_TEST_AT_LINE(func, line, ...) UnityDefaultTestRun(func, #func, line) +#endif +#endif + +/* Enable default macros for masking param tests test cases */ +#ifdef UNITY_SUPPORT_TEST_CASES + #ifdef UNITY_SUPPORT_VARIADIC_MACROS + #if !defined(TEST_CASE) && !defined(UNITY_EXCLUDE_TEST_CASE) + #define TEST_CASE(...) + #endif + #if !defined(TEST_RANGE) && !defined(UNITY_EXCLUDE_TEST_RANGE) + #define TEST_RANGE(...) + #endif + #if !defined(TEST_MATRIX) && !defined(UNITY_EXCLUDE_TEST_MATRIX) + #define TEST_MATRIX(...) + #endif + #endif +#endif + +/* If we can't do the tricky version, we'll just have to require them to always include the line number */ +#ifndef RUN_TEST +#ifdef CMOCK +#define RUN_TEST(func, num) UnityDefaultTestRun(func, #func, num) +#else +#define RUN_TEST(func) UnityDefaultTestRun(func, #func, __LINE__) +#endif +#endif + +#define TEST_LINE_NUM (Unity.CurrentTestLineNumber) +#define TEST_IS_IGNORED (Unity.CurrentTestIgnored) +#define UNITY_NEW_TEST(a) \ + Unity.CurrentTestName = (a); \ + Unity.CurrentTestLineNumber = (UNITY_LINE_TYPE)(__LINE__); \ + Unity.NumberOfTests++; + +#ifndef UNITY_BEGIN +#define UNITY_BEGIN() UnityBegin(__FILE__) +#endif + +#ifndef UNITY_END +#define UNITY_END() UnityEnd() +#endif + +#ifndef UNITY_SHORTHAND_AS_INT +#ifndef UNITY_SHORTHAND_AS_MEM +#ifndef UNITY_SHORTHAND_AS_NONE +#ifndef UNITY_SHORTHAND_AS_RAW +#define UNITY_SHORTHAND_AS_OLD +#endif +#endif +#endif +#endif + +/*----------------------------------------------- + * Command Line Argument Support + *-----------------------------------------------*/ + +#ifdef UNITY_USE_COMMAND_LINE_ARGS +int UnityParseOptions(int argc, char** argv); +int UnityTestMatches(void); +#endif + +/*------------------------------------------------------- + * Basic Fail and Ignore + *-------------------------------------------------------*/ + +#define UNITY_TEST_FAIL(line, message) UnityFail( (message), (UNITY_LINE_TYPE)(line)) +#define UNITY_TEST_IGNORE(line, message) UnityIgnore( (message), (UNITY_LINE_TYPE)(line)) + +/*------------------------------------------------------- + * Test Asserts + *-------------------------------------------------------*/ + +#define UNITY_TEST_ASSERT(condition, line, message) do { if (condition) { /* nothing*/ } else { UNITY_TEST_FAIL((line), (message)); } } while (0) +#define UNITY_TEST_ASSERT_NULL(pointer, line, message) UNITY_TEST_ASSERT(((pointer) == NULL), (line), (message)) +#define UNITY_TEST_ASSERT_NOT_NULL(pointer, line, message) UNITY_TEST_ASSERT(((pointer) != NULL), (line), (message)) +#define UNITY_TEST_ASSERT_EMPTY(pointer, line, message) UNITY_TEST_ASSERT(((pointer[0]) == 0), (line), (message)) +#define UNITY_TEST_ASSERT_NOT_EMPTY(pointer, line, message) UNITY_TEST_ASSERT(((pointer[0]) != 0), (line), (message)) + +#define UNITY_TEST_ASSERT_EQUAL_INT(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT) +#define UNITY_TEST_ASSERT_EQUAL_INT8(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT8 )(expected), (UNITY_INT)(UNITY_INT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8) +#define UNITY_TEST_ASSERT_EQUAL_INT16(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT16)(expected), (UNITY_INT)(UNITY_INT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16) +#define UNITY_TEST_ASSERT_EQUAL_INT32(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT32)(expected), (UNITY_INT)(UNITY_INT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) +#define UNITY_TEST_ASSERT_EQUAL_UINT(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) +#define UNITY_TEST_ASSERT_EQUAL_UINT8(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_UINT8 )(expected), (UNITY_INT)(UNITY_UINT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) +#define UNITY_TEST_ASSERT_EQUAL_UINT16(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_UINT16)(expected), (UNITY_INT)(UNITY_UINT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) +#define UNITY_TEST_ASSERT_EQUAL_UINT32(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_UINT32)(expected), (UNITY_INT)(UNITY_UINT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) +#define UNITY_TEST_ASSERT_EQUAL_HEX8(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT8 )(expected), (UNITY_INT)(UNITY_INT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) +#define UNITY_TEST_ASSERT_EQUAL_HEX16(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT16)(expected), (UNITY_INT)(UNITY_INT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) +#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_CHAR(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT8 )(expected), (UNITY_INT)(UNITY_INT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR) +#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_NOT_EQUAL_INT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT) +#define UNITY_TEST_ASSERT_NOT_EQUAL_INT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8) +#define UNITY_TEST_ASSERT_NOT_EQUAL_INT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT16)(threshold), (UNITY_INT)(UNITY_INT16)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16) +#define UNITY_TEST_ASSERT_NOT_EQUAL_INT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT32)(threshold), (UNITY_INT)(UNITY_INT32)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) +#define UNITY_TEST_ASSERT_NOT_EQUAL_UINT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) +#define UNITY_TEST_ASSERT_NOT_EQUAL_UINT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) +#define UNITY_TEST_ASSERT_NOT_EQUAL_UINT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) +#define UNITY_TEST_ASSERT_NOT_EQUAL_UINT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) +#define UNITY_TEST_ASSERT_NOT_EQUAL_HEX8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) +#define UNITY_TEST_ASSERT_NOT_EQUAL_HEX16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) +#define UNITY_TEST_ASSERT_NOT_EQUAL_HEX32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32) +#define UNITY_TEST_ASSERT_NOT_EQUAL_CHAR(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR) + +#define UNITY_TEST_ASSERT_GREATER_THAN_INT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT) +#define UNITY_TEST_ASSERT_GREATER_THAN_INT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8) +#define UNITY_TEST_ASSERT_GREATER_THAN_INT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT16)(threshold), (UNITY_INT)(UNITY_INT16)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16) +#define UNITY_TEST_ASSERT_GREATER_THAN_INT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT32)(threshold), (UNITY_INT)(UNITY_INT32)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) +#define UNITY_TEST_ASSERT_GREATER_THAN_UINT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) +#define UNITY_TEST_ASSERT_GREATER_THAN_UINT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) +#define UNITY_TEST_ASSERT_GREATER_THAN_UINT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) +#define UNITY_TEST_ASSERT_GREATER_THAN_UINT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) +#define UNITY_TEST_ASSERT_GREATER_THAN_HEX8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) +#define UNITY_TEST_ASSERT_GREATER_THAN_HEX16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) +#define UNITY_TEST_ASSERT_GREATER_THAN_HEX32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32) +#define UNITY_TEST_ASSERT_GREATER_THAN_CHAR(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR) + +#define UNITY_TEST_ASSERT_SMALLER_THAN_INT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT) +#define UNITY_TEST_ASSERT_SMALLER_THAN_INT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8) +#define UNITY_TEST_ASSERT_SMALLER_THAN_INT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT16)(threshold), (UNITY_INT)(UNITY_INT16)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16) +#define UNITY_TEST_ASSERT_SMALLER_THAN_INT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT32)(threshold), (UNITY_INT)(UNITY_INT32)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) +#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) +#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) +#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) +#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) +#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) +#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) +#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32) +#define UNITY_TEST_ASSERT_SMALLER_THAN_CHAR(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR) + +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT) (threshold), (UNITY_INT) (actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 ) (threshold), (UNITY_INT)(UNITY_INT8 ) (actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT16) (threshold), (UNITY_INT)(UNITY_INT16) (actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT32) (threshold), (UNITY_INT)(UNITY_INT32) (actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT) (threshold), (UNITY_INT) (actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_CHAR(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 ) (threshold), (UNITY_INT)(UNITY_INT8 ) (actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR) + +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT) (threshold), (UNITY_INT) (actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 ) (actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT16)(threshold), (UNITY_INT)(UNITY_INT16) (actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT32)(threshold), (UNITY_INT)(UNITY_INT32) (actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT) (threshold), (UNITY_INT) (actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_CHAR(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 ) (actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR) + +#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_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_INT32_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT32)(delta), (UNITY_INT)(UNITY_INT32) (expected), (UNITY_INT)(UNITY_INT32) (actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) +#define UNITY_TEST_ASSERT_UINT_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin( (delta), (UNITY_INT) (expected), (UNITY_INT) (actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) +#define UNITY_TEST_ASSERT_UINT8_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT8 )(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT8 )(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) +#define UNITY_TEST_ASSERT_UINT16_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT16)(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT16)(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) +#define UNITY_TEST_ASSERT_UINT32_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT32)(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT32)(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) +#define UNITY_TEST_ASSERT_HEX8_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT8 )(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT8 )(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) +#define UNITY_TEST_ASSERT_HEX16_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT16)(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT16)(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) +#define UNITY_TEST_ASSERT_HEX32_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT32)(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT32)(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32) +#define UNITY_TEST_ASSERT_CHAR_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_CHAR) + +#define UNITY_TEST_ASSERT_INT_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin( (delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_INT8_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT8 )(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_INT16_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT16)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_INT32_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT32)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_UINT_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin( (delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_UINT8_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT8 )(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_UINT16_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT16)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_UINT32_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT32)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_HEX8_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT8 )(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_HEX16_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT16)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT32)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_CHAR_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT8 )(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR, UNITY_ARRAY_TO_ARRAY) + + +#define UNITY_TEST_ASSERT_EQUAL_PTR(expected, actual, line, message) UnityAssertEqualNumber((UNITY_PTR_TO_INT)(expected), (UNITY_PTR_TO_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_POINTER) +#define UNITY_TEST_ASSERT_EQUAL_STRING(expected, actual, line, message) UnityAssertEqualString((const char*)(expected), (const char*)(actual), (message), (UNITY_LINE_TYPE)(line)) +#define UNITY_TEST_ASSERT_EQUAL_STRING_LEN(expected, actual, len, line, message) UnityAssertEqualStringLen((const char*)(expected), (const char*)(actual), (UNITY_UINT32)(len), (message), (UNITY_LINE_TYPE)(line)) +#define UNITY_TEST_ASSERT_EQUAL_MEMORY(expected, actual, len, line, message) UnityAssertEqualMemory((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(len), 1, (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) + +#define UNITY_TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_INT8_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_INT16_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_INT32_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_UINT8_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_UINT32_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_HEX16_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_PTR_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_POINTER, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualStringArray((UNITY_INTERNAL_PTR)(expected), (const char**)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY(expected, actual, len, num_elements, line, message) UnityAssertEqualMemory((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(len), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_CHAR_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR, UNITY_ARRAY_TO_ARRAY) + +#define UNITY_TEST_ASSERT_EACH_EQUAL_INT(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT) (expected), (UNITY_INT_WIDTH / 8)), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_INT8(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT8 )(expected), 1), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_INT16(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT16 )(expected), 2), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_INT32(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT32 )(expected), 4), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT) (expected), (UNITY_INT_WIDTH / 8)), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT8(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_UINT8 )(expected), 1), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT16(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_UINT16)(expected), 2), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT32(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_UINT32)(expected), 4), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_HEX8(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT8 )(expected), 1), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_HEX16(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT16 )(expected), 2), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_HEX32(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT32 )(expected), 4), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_PTR(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_PTR_TO_INT) (expected), (UNITY_POINTER_WIDTH / 8)), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_POINTER, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_STRING(expected, actual, num_elements, line, message) UnityAssertEqualStringArray((UNITY_INTERNAL_PTR)(expected), (const char**)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_MEMORY(expected, actual, len, num_elements, line, message) UnityAssertEqualMemory((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(len), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_CHAR(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT8 )(expected), 1), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR, UNITY_ARRAY_TO_VAL) + +#ifdef UNITY_SUPPORT_64 +#define UNITY_TEST_ASSERT_EQUAL_INT64(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) +#define UNITY_TEST_ASSERT_EQUAL_UINT64(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) +#define UNITY_TEST_ASSERT_EQUAL_HEX64(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) +#define UNITY_TEST_ASSERT_EQUAL_INT64_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EACH_EQUAL_INT64(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT64)(expected), 8), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT64(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_UINT64)(expected), 8), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_HEX64(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT64)(expected), 8), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_INT64_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((delta), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) +#define UNITY_TEST_ASSERT_UINT64_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((delta), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) +#define UNITY_TEST_ASSERT_HEX64_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((delta), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) +#define UNITY_TEST_ASSERT_NOT_EQUAL_INT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) +#define UNITY_TEST_ASSERT_NOT_EQUAL_UINT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) +#define UNITY_TEST_ASSERT_NOT_EQUAL_HEX64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) +#define UNITY_TEST_ASSERT_GREATER_THAN_INT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) +#define UNITY_TEST_ASSERT_GREATER_THAN_UINT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) +#define UNITY_TEST_ASSERT_GREATER_THAN_HEX64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) +#define UNITY_TEST_ASSERT_SMALLER_THAN_INT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) +#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) +#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) +#define UNITY_TEST_ASSERT_INT64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT64)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_UINT64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT64)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_HEX64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT64)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64, UNITY_ARRAY_TO_ARRAY) +#else +#define UNITY_TEST_ASSERT_EQUAL_INT64(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_EQUAL_UINT64(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_EQUAL_HEX64(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_EQUAL_INT64_ARRAY(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_INT64_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_UINT64_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_HEX64_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_GREATER_THAN_INT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_GREATER_THAN_UINT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_GREATER_THAN_HEX64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_SMALLER_THAN_INT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_INT64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_UINT64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_HEX64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#endif + +#ifdef UNITY_EXCLUDE_FLOAT +#define UNITY_TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_FLOAT_NOT_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_EQUAL_FLOAT(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_NOT_EQUAL_FLOAT(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_FLOAT_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_GREATER_THAN_FLOAT(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_LESS_THAN_FLOAT(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_LESS_OR_EQUAL_FLOAT(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_FLOAT_IS_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_FLOAT_IS_NAN(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_FLOAT_IS_DETERMINATE(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_NEG_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_NAN(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#else +#define UNITY_TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual, line, message) UnityAssertFloatsWithin((UNITY_FLOAT)(delta), (UNITY_FLOAT)(expected), (UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line)) +#define UNITY_TEST_ASSERT_FLOAT_NOT_WITHIN(delta, expected, actual, line, message) UnityAssertFloatsNotWithin((UNITY_FLOAT)(delta), (UNITY_FLOAT)(expected), (UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line)) +#define UNITY_TEST_ASSERT_EQUAL_FLOAT(expected, actual, line, message) UNITY_TEST_ASSERT_FLOAT_WITHIN((UNITY_FLOAT)(expected) * (UNITY_FLOAT)UNITY_FLOAT_PRECISION, (UNITY_FLOAT)(expected), (UNITY_FLOAT)(actual), (UNITY_LINE_TYPE)(line), (message)) +#define UNITY_TEST_ASSERT_NOT_EQUAL_FLOAT(expected, actual, line, message) UNITY_TEST_ASSERT_FLOAT_NOT_WITHIN((UNITY_FLOAT)(expected) * (UNITY_FLOAT)UNITY_FLOAT_PRECISION, (UNITY_FLOAT)(expected), (UNITY_FLOAT)(actual), (UNITY_LINE_TYPE)(line), (message)) +#define UNITY_TEST_ASSERT_FLOAT_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertWithinFloatArray((UNITY_FLOAT)(delta), (const UNITY_FLOAT*)(expected), (const UNITY_FLOAT*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, line, message) UnityAssertWithinFloatArray((UNITY_FLOAT)0, (const UNITY_FLOAT*)(expected), (const UNITY_FLOAT*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT(expected, actual, num_elements, line, message) UnityAssertWithinFloatArray((UNITY_FLOAT)0, UnityFloatToPtr(expected), (const UNITY_FLOAT*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_GREATER_THAN_FLOAT(threshold, actual, line, message) UnityAssertGreaterOrLessFloat((UNITY_FLOAT)(threshold), (UNITY_FLOAT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line)) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(threshold, actual, line, message) UnityAssertGreaterOrLessFloat((UNITY_FLOAT)(threshold), (UNITY_FLOAT)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line)) +#define UNITY_TEST_ASSERT_LESS_THAN_FLOAT(threshold, actual, line, message) UnityAssertGreaterOrLessFloat((UNITY_FLOAT)(threshold), (UNITY_FLOAT)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line)) +#define UNITY_TEST_ASSERT_LESS_OR_EQUAL_FLOAT(threshold, actual, line, message) UnityAssertGreaterOrLessFloat((UNITY_FLOAT)(threshold), (UNITY_FLOAT)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line)) +#define UNITY_TEST_ASSERT_FLOAT_IS_INF(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_INF) +#define UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NEG_INF) +#define UNITY_TEST_ASSERT_FLOAT_IS_NAN(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NAN) +#define UNITY_TEST_ASSERT_FLOAT_IS_DETERMINATE(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_DET) +#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_INF(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_INF) +#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_NEG_INF(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_NEG_INF) +#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_NAN(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_NAN) +#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_DET) +#endif + +#ifdef UNITY_EXCLUDE_DOUBLE +#define UNITY_TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_DOUBLE_NOT_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_EQUAL_DOUBLE(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_NOT_EQUAL_DOUBLE(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_DOUBLE_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_GREATER_THAN_DOUBLE(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_LESS_THAN_DOUBLE(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_DOUBLE_IS_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NAN(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_DOUBLE_IS_DETERMINATE(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NAN(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#else +#define UNITY_TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual, line, message) UnityAssertDoublesWithin((UNITY_DOUBLE)(delta), (UNITY_DOUBLE)(expected), (UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line)) +#define UNITY_TEST_ASSERT_DOUBLE_NOT_WITHIN(delta, expected, actual, line, message) UnityAssertDoublesNotWithin((UNITY_DOUBLE)(delta), (UNITY_DOUBLE)(expected), (UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line)) +#define UNITY_TEST_ASSERT_EQUAL_DOUBLE(expected, actual, line, message) UNITY_TEST_ASSERT_DOUBLE_WITHIN((UNITY_DOUBLE)(expected) * (UNITY_DOUBLE)UNITY_DOUBLE_PRECISION, (UNITY_DOUBLE)(expected), (UNITY_DOUBLE)(actual), (UNITY_LINE_TYPE)(line), (message)) +#define UNITY_TEST_ASSERT_NOT_EQUAL_DOUBLE(expected, actual, line, message) UNITY_TEST_ASSERT_DOUBLE_NOT_WITHIN((UNITY_DOUBLE)(expected) * (UNITY_DOUBLE)UNITY_DOUBLE_PRECISION, (UNITY_DOUBLE)(expected), (UNITY_DOUBLE)(actual), (UNITY_LINE_TYPE)(line), (message)) +#define UNITY_TEST_ASSERT_DOUBLE_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertWithinDoubleArray((UNITY_DOUBLE)(delta), (const UNITY_DOUBLE*)(expected), (const UNITY_DOUBLE*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements, line, message) UnityAssertWithinDoubleArray((UNITY_DOUBLE)0, (const UNITY_DOUBLE*)(expected), (const UNITY_DOUBLE*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE(expected, actual, num_elements, line, message) UnityAssertWithinDoubleArray((UNITY_DOUBLE)0, UnityDoubleToPtr(expected), (const UNITY_DOUBLE*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_GREATER_THAN_DOUBLE(threshold, actual, line, message) UnityAssertGreaterOrLessDouble((UNITY_DOUBLE)(threshold), (UNITY_DOUBLE)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line)) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(threshold, actual, line, message) UnityAssertGreaterOrLessDouble((UNITY_DOUBLE)(threshold), (UNITY_DOUBLE)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line)) +#define UNITY_TEST_ASSERT_LESS_THAN_DOUBLE(threshold, actual, line, message) UnityAssertGreaterOrLessDouble((UNITY_DOUBLE)(threshold), (UNITY_DOUBLE)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line)) +#define UNITY_TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(threshold, actual, line, message) UnityAssertGreaterOrLessDouble((UNITY_DOUBLE)(threshold), (UNITY_DOUBLE)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line)) +#define UNITY_TEST_ASSERT_DOUBLE_IS_INF(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_INF) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NEG_INF) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NAN(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NAN) +#define UNITY_TEST_ASSERT_DOUBLE_IS_DETERMINATE(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_DET) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_INF(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_INF) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_NEG_INF) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NAN(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_NAN) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_DET) +#endif + +/* End of UNITY_INTERNALS_H */ +#endif diff --git a/subprojects/unity/unityConfig.cmake b/subprojects/unity/unityConfig.cmake new file mode 100644 index 0000000000..55410ccc8d --- /dev/null +++ b/subprojects/unity/unityConfig.cmake @@ -0,0 +1 @@ +include(${CMAKE_CURRENT_LIST_DIR}/unityTargets.cmake) \ No newline at end of file diff --git a/test/ctest_test.py b/test/ctest_test.py new file mode 100644 index 0000000000..a143d138ce --- /dev/null +++ b/test/ctest_test.py @@ -0,0 +1,41 @@ +import io +import os +import re +import subprocess +import unittest + + +class Ctest(unittest.TestCase): + def test_run_ctests(self): + filename_regex = re.compile(".*run_ctests.*") + + test_dir = os.path.dirname(os.path.abspath(__file__)) + pg_dir = os.path.join(test_dir, "..") + + test_executable_exists = False + test_filename = "" + for filename in os.listdir(pg_dir): + if re.match(filename_regex, filename): + test_filename = filename + test_executable_exists = True + break + + if test_executable_exists: + cwd = os.getcwd() + os.chdir(pg_dir) + + with open(f"{cwd}/ctest.log", 'w') as ctest_log: + test_result = subprocess.run( + [test_filename], stdout=ctest_log, stderr=subprocess.STDOUT + ) + + os.chdir(cwd) + + self.assertEqual(test_result.returncode, 0) + + else: + unittest.skip("Test Executable Not Available") + + +if __name__ == "__main__": + unittest.main() diff --git a/test/meson.build b/test/meson.build index 1e2cadfa7d..5ee558cc3e 100644 --- a/test/meson.build +++ b/test/meson.build @@ -9,6 +9,7 @@ test_files = files( 'color_test.py', 'constants_test.py', 'controller_test.py', + 'ctest_test.py', 'cursors_test.py', 'debug_test.py', 'display_test.py', From 67e404333adaa543011092b8aa4313b519842753 Mon Sep 17 00:00:00 2001 From: Andrew Coffey Date: Thu, 5 Jun 2025 22:36:38 -0500 Subject: [PATCH 02/21] Updated actions for ctest --- .github/workflows/build-debian-multiarch.yml | 2 +- .github/workflows/build-ubuntu-ctest.yml | 87 ++++++++++++++++++++ 2 files changed, 88 insertions(+), 1 deletion(-) create mode 100644 .github/workflows/build-ubuntu-ctest.yml diff --git a/.github/workflows/build-debian-multiarch.yml b/.github/workflows/build-debian-multiarch.yml index 2daa1dabc0..927b5f841b 100644 --- a/.github/workflows/build-debian-multiarch.yml +++ b/.github/workflows/build-debian-multiarch.yml @@ -144,7 +144,7 @@ jobs: install: ${{ env.INSTALL_CMD }} run: | echo "\nInstalling wheel\n" - pip3 install --no-index --pre --break-system-packages --find-links /artifacts_new pygame-ce -Csetup_args=-Dctest=true + pip3 install --no-index --pre --break-system-packages --find-links /artifacts_new pygame-ce echo "\nRunning tests\n" export SDL_VIDEODRIVER=dummy export SDL_AUDIODRIVER=disk diff --git a/.github/workflows/build-ubuntu-ctest.yml b/.github/workflows/build-ubuntu-ctest.yml new file mode 100644 index 0000000000..ade94fd313 --- /dev/null +++ b/.github/workflows/build-ubuntu-ctest.yml @@ -0,0 +1,87 @@ +# This workflow generates C code tests +# Note that for intrinsics, it only runs what gets compiled +# and would naturally run. It also is limited to what can run in +# a CI environment +# IMPORTANT: binaries are not to be uploaded from this workflow! + +name: Ubuntu ctest + +# Run CI only on changes to main branch, or any PR to main. +# Do not run CI on any other branch. Also, skip any non-source changes +# from running on CI +on: + push: + branches: main + paths-ignore: + - 'docs/**' + - 'examples/**' + - '.gitignore' + - '*.rst' + - '*.md' + - '.github/workflows/*.yml' + # only care about c code that changes + - 'src_py/**' + # re-include current file to not be excluded + - '!.github/workflows/build-ubuntu-ctest.yml' + + pull_request: + branches: main + paths-ignore: + - 'docs/**' + - 'examples/**' + - '.gitignore' + - '*.rst' + - '*.md' + - '.github/workflows/*.yml' + # only care about c code that changes + - 'src_py/**' + # re-include current file to not be excluded + - '!.github/workflows/build-ubuntu-ctest.yml' + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }}-ubuntu-ctest + cancel-in-progress: true + +jobs: + gen_coverage: + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false # if a particular matrix build fails, don't skip the rest + matrix: + os: [ubuntu-24.04] + + env: + # Pip now forces us to either make a venv or set this flag, so we will do + # this + PIP_BREAK_SYSTEM_PACKAGES: 1 + # We are using dependencies installed from apt + PG_DEPS_FROM_SYSTEM: 1 + + steps: + - uses: actions/checkout@v4.2.2 + + - name: Install deps + # https://github.com/actions/runner-images/issues/7192 + # https://github.com/orgs/community/discussions/47863 + run: | + sudo apt-get update --fix-missing + sudo apt-get install libsdl2-dev libsdl2-image-dev libsdl2-mixer-dev libsdl2-ttf-dev libfreetype6-dev libportmidi-dev python3-dev -y + + - name: Build with the ctest suite + id: build + run: | + python3 -m pip install . -Csetup-args="-Dctest=true" --break-system-packages + + - name: Run tests + env: + SDL_VIDEODRIVER: "dummy" + SDL_AUDIODRIVER: "disk" + run: python3 -m pygame.tests -v --exclude opengl,music,timing --time_out 300 + + # We upload the generated files under github actions assets + - name: Upload ctest log + if: !cancelled() + uses: actions/upload-artifact@v4 + with: + name: ctest_suite_log + path: ctest.log From 8aa55bb3f87caf8a8bebf4ab82f8709fde7c0506 Mon Sep 17 00:00:00 2001 From: Andrew Coffey Date: Fri, 6 Jun 2025 05:18:53 -0500 Subject: [PATCH 03/21] Unity now a wrap --- .github/workflows/build-debian-packaged.yml | 189 ++ .github/workflows/build-ubuntu-ctest.yml | 2 +- subprojects/unity/CMakeLists.txt | 172 -- subprojects/unity/LICENSE.txt | 21 - subprojects/unity/README.md | 234 -- subprojects/unity/docs/CODE_OF_CONDUCT.md | 138 - subprojects/unity/docs/CONTRIBUTING.md | 238 -- .../unity/docs/MesonGeneratorRunner.md | 18 - .../docs/ThrowTheSwitchCodingStandard.md | 187 -- ...tSuitableforPrintingandPossiblyFraming.pdf | Bin 144467 -> 0 bytes .../unity/docs/UnityAssertionsReference.md | 860 ------ subprojects/unity/docs/UnityChangeLog.md | 110 - .../unity/docs/UnityConfigurationGuide.md | 654 ----- .../unity/docs/UnityGettingStartedGuide.md | 242 -- .../unity/docs/UnityHelperScriptsGuide.md | 533 ---- subprojects/unity/docs/UnityKnownIssues.md | 13 - subprojects/unity/extras/bdd/readme.md | 40 - subprojects/unity/extras/bdd/src/unity_bdd.h | 44 - subprojects/unity/extras/bdd/test/meson.build | 9 - subprojects/unity/extras/bdd/test/test_bdd.c | 129 - .../unity/extras/eclipse/error_parsers.txt | 26 - subprojects/unity/extras/fixture/readme.md | 26 - .../unity/extras/fixture/src/meson.build | 10 - .../unity/extras/fixture/src/unity_fixture.c | 310 -- .../unity/extras/fixture/src/unity_fixture.h | 94 - .../fixture/src/unity_fixture_internals.h | 50 - .../unity/extras/fixture/test/Makefile | 72 - .../unity/extras/fixture/test/main/AllTests.c | 20 - .../fixture/test/template_fixture_tests.c | 39 - .../extras/fixture/test/unity_fixture_Test.c | 245 -- .../fixture/test/unity_fixture_TestRunner.c | 32 - subprojects/unity/extras/memory/readme.md | 42 - .../unity/extras/memory/src/meson.build | 9 - .../unity/extras/memory/src/unity_memory.c | 203 -- .../unity/extras/memory/src/unity_memory.h | 61 - subprojects/unity/extras/memory/test/Makefile | 85 - .../extras/memory/test/unity_memory_Test.c | 326 --- .../memory/test/unity_memory_TestRunner.c | 50 - .../extras/memory/test/unity_output_Spy.c | 57 - .../extras/memory/test/unity_output_Spy.h | 17 - subprojects/unity/library.json | 25 - subprojects/unity/meson.build | 80 - subprojects/unity/meson_options.txt | 3 - subprojects/unity/platformio-build.py | 24 - subprojects/unity/src/meson.build | 17 - subprojects/unity/src/unity.c | 2501 ----------------- subprojects/unity/src/unity.h | 698 ----- subprojects/unity/src/unity_internals.h | 1183 -------- subprojects/unity/unity.wrap | 3 + subprojects/unity/unityConfig.cmake | 1 - 50 files changed, 193 insertions(+), 9949 deletions(-) create mode 100644 .github/workflows/build-debian-packaged.yml delete mode 100644 subprojects/unity/CMakeLists.txt delete mode 100644 subprojects/unity/LICENSE.txt delete mode 100644 subprojects/unity/README.md delete mode 100644 subprojects/unity/docs/CODE_OF_CONDUCT.md delete mode 100644 subprojects/unity/docs/CONTRIBUTING.md delete mode 100644 subprojects/unity/docs/MesonGeneratorRunner.md delete mode 100644 subprojects/unity/docs/ThrowTheSwitchCodingStandard.md delete mode 100644 subprojects/unity/docs/UnityAssertionsCheatSheetSuitableforPrintingandPossiblyFraming.pdf delete mode 100644 subprojects/unity/docs/UnityAssertionsReference.md delete mode 100644 subprojects/unity/docs/UnityChangeLog.md delete mode 100644 subprojects/unity/docs/UnityConfigurationGuide.md delete mode 100644 subprojects/unity/docs/UnityGettingStartedGuide.md delete mode 100644 subprojects/unity/docs/UnityHelperScriptsGuide.md delete mode 100644 subprojects/unity/docs/UnityKnownIssues.md delete mode 100644 subprojects/unity/extras/bdd/readme.md delete mode 100644 subprojects/unity/extras/bdd/src/unity_bdd.h delete mode 100644 subprojects/unity/extras/bdd/test/meson.build delete mode 100644 subprojects/unity/extras/bdd/test/test_bdd.c delete mode 100644 subprojects/unity/extras/eclipse/error_parsers.txt delete mode 100644 subprojects/unity/extras/fixture/readme.md delete mode 100644 subprojects/unity/extras/fixture/src/meson.build delete mode 100644 subprojects/unity/extras/fixture/src/unity_fixture.c delete mode 100644 subprojects/unity/extras/fixture/src/unity_fixture.h delete mode 100644 subprojects/unity/extras/fixture/src/unity_fixture_internals.h delete mode 100644 subprojects/unity/extras/fixture/test/Makefile delete mode 100644 subprojects/unity/extras/fixture/test/main/AllTests.c delete mode 100644 subprojects/unity/extras/fixture/test/template_fixture_tests.c delete mode 100644 subprojects/unity/extras/fixture/test/unity_fixture_Test.c delete mode 100644 subprojects/unity/extras/fixture/test/unity_fixture_TestRunner.c delete mode 100644 subprojects/unity/extras/memory/readme.md delete mode 100644 subprojects/unity/extras/memory/src/meson.build delete mode 100644 subprojects/unity/extras/memory/src/unity_memory.c delete mode 100644 subprojects/unity/extras/memory/src/unity_memory.h delete mode 100644 subprojects/unity/extras/memory/test/Makefile delete mode 100644 subprojects/unity/extras/memory/test/unity_memory_Test.c delete mode 100644 subprojects/unity/extras/memory/test/unity_memory_TestRunner.c delete mode 100644 subprojects/unity/extras/memory/test/unity_output_Spy.c delete mode 100644 subprojects/unity/extras/memory/test/unity_output_Spy.h delete mode 100644 subprojects/unity/library.json delete mode 100644 subprojects/unity/meson.build delete mode 100644 subprojects/unity/meson_options.txt delete mode 100644 subprojects/unity/platformio-build.py delete mode 100644 subprojects/unity/src/meson.build delete mode 100644 subprojects/unity/src/unity.c delete mode 100644 subprojects/unity/src/unity.h delete mode 100644 subprojects/unity/src/unity_internals.h create mode 100644 subprojects/unity/unity.wrap delete mode 100644 subprojects/unity/unityConfig.cmake diff --git a/.github/workflows/build-debian-packaged.yml b/.github/workflows/build-debian-packaged.yml new file mode 100644 index 0000000000..295886c1cf --- /dev/null +++ b/.github/workflows/build-debian-packaged.yml @@ -0,0 +1,189 @@ +# Tests pygame on more exotic architectures. This is not something that is +# actively supported, but source code support for this is nice to have. We +# don't do any releases from here. + +name: Debian Packaged + +# Run CI only on changes to main branch, or any PR to main. Do not run CI on +# any other branch. Also, skip any non-source changes from running on CI +on: + push: + branches: main + paths-ignore: + - 'docs/**' + - 'examples/**' + - '.gitignore' + - '*.rst' + - '*.md' + - '.github/workflows/*.yml' + # re-include current file to not be excluded + - '!.github/workflows/build-debian-packaged.yml' + + pull_request: + branches: main + paths-ignore: + - 'docs/**' + - 'examples/**' + - '.gitignore' + - '*.rst' + - '*.md' + - '.github/workflows/*.yml' + # re-include current file to not be excluded + - '!.github/workflows/build-debian-packaged.yml' + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }}-debian-packaged + cancel-in-progress: true + +# this command is called in two places, so save it in an env first +env: + INSTALL_CMD: | + apt-get update --fix-missing + apt-get upgrade -y + apt-get install build-essential meson cython3 -y + apt-get install libsdl2-dev libsdl2-image-dev libsdl2-mixer-dev libsdl2-ttf-dev -y + apt-get install libfreetype6-dev libportmidi-dev fontconfig -y + apt-get install python3-dev python3-pip python3-wheel python3-sphinx python3-all dh-python python-all python-setuptools -y + apt-get update + apt-get install debhelper-compat python3-pyproject-metadata python3-tomli -y + wget http://http.us.debian.org/debian/pool/main/m/meson-python/python3-mesonpy_0.12.0-2_all.deb + dpkg -i python3-mesonpy_0.12.0-2_all.deb + apt install + pip3 install meson-python "sphinx-autoapi<=3.3.2" meson --break-system-packages + +jobs: + build-packaged: + name: Debian (Bookworm - 12) [${{ matrix.arch }}, ${{matrix.python}}] + runs-on: ubuntu-22.04 + + strategy: + fail-fast: false # if a particular matrix build fails, don't skip the rest + matrix: + # maybe more things could be added in here in the future (if needed) + include: + # - { arch: x86, base_image: '' } + # - { arch: x86-64, base_image: '', python: 3.9} + # - { arch: x86-64, base_image: '', python: 3.10} + # - { arch: x86-64, base_image: '', python: 3.11} + # - { arch: x86-64, base_image: '', python: 3.12} + - { arch: x86-64, base_image: '', python: 3.13} + # - { arch: s390x, base_image: '' } + # - { arch: ppc64le, base_image: '' } + # - { arch: armv6, base_image: '' } + # # a custom base_image is specified in the armv7 case. This is done because + # # the armv6 image is just raspbian in disguise. And the wheel built on armv7 + # # is going to be tested on armv6 + # - { arch: armv7, base_image: 'balenalib/raspberrypi3-debian:bookworm' } + + steps: + - uses: actions/checkout@v4.2.2 + + - uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python }} + + # - name: Build sources and run tests + # uses: uraimo/run-on-arch-action@v3.0.1 + # id: build + # with: + # arch: ${{ matrix.base_image && 'none' || matrix.arch }} + # distro: ${{ matrix.base_image && 'none' || 'bookworm' }} + # base_image: ${{ matrix.base_image }} + + # # Not required, but speeds up builds + # githubToken: ${{ github.token }} + + # # Create an artifacts directory + # setup: mkdir -p ~/artifacts + + # # Mount the artifacts directory as /artifacts in the container + # dockerRunArgs: --volume ~/artifacts:/artifacts + + # # The shell to run commands with in the container + # shell: /bin/sh + + # # Install some dependencies in the container. This speeds up builds if + # # you are also using githubToken. Any dependencies installed here will + # # be part of the container image that gets cached, so subsequent + # # builds don't have to re-install them. The image layer is cached + # # publicly in your project's package repository, so it is vital that + # # no secrets are present in the container state or logs. + # install: ${{ env.INSTALL_CMD }} + + # # Build a wheel, install it for running unit tests. + # # pip does not know that ninja is installed, and tries to install it again. + # # so pass --ignore-dep ninja explicitly + # run: | + # echo "\nBuilding and installing pygame wheel\n" + # PIP_BREAK_SYSTEM_PACKAGES=1 python3 dev.py --ignore-dep ninja build --wheel /artifacts --lax + # echo "\nRunning tests\n" + # export SDL_VIDEODRIVER=dummy + # export SDL_AUDIODRIVER=disk + # python3 -m pygame.tests -v --exclude opengl,music,timing --time_out 300 + + - name: Build Packaged Deb + id: build + run: | + ${{env.INSTALL_CMD}} + apt install debmake -y + mkdir ../pygame-ce-2.5.5 + mv * ../pygame-ce-2.5.5 + mv ../pygame-ce-2.5.5 . + tar czf pygame-ce-2.5.5.tar.gz pygame-ce-2.5.5 + mv pygame-ce-2.5.5.tar.gz pygame-ce_2.5.5.orig.tar.gz + cd pygame-ce-2.5.5 + debmake -b:python3 + perl -0000 -pi -e '$INDENT=" "; s{(Build-Depends: debhelper-compat.*python3-all)}{\1,\n${INDENT}cython3,\n${INDENT}libfreetype6-dev,\n${INDENT}libportmidi-dev,\n${INDENT}libsdl2-dev,\n${INDENT}libsdl2-image-dev,\n${INDENT}libsdl2-mixer-dev,\n${INDENT}libsdl2-ttf-dev}s' debian/control + perl -0000 -pi.bak -e 's{Standards-Version}{\nStandards-Version}s' debian/control + cat debian/control + dpkg-source -b . + dpkg-buildpackage + + + - name: debug + if: (failure() && steps.build.outcome == 'failure') + run: cat pygame-ce-2.5.5/debian/control + + # Upload the generated files under github actions assets section + - name: Upload dist + uses: actions/upload-artifact@v4 + with: + name: debian-packaged-${{ matrix.arch }}-dist + path: "*.deb" + + # # test wheels built on armv7 on armv6. Why? + # # because piwheels expects the same armv7 wheel to work on both armv7 and armv6 + # test-armv7-on-armv6: + # needs: build-packaged + # name: Debian (Bookworm - 12) [build - armv7, test - armv6] + # runs-on: ubuntu-22.04 + # steps: + # - name: Download all multiarch artifacts + # uses: actions/download-artifact@v4 + # with: + # name: pygame-multiarch-armv7-dist + # path: ~/artifacts + + # - name: Rename arm wheel in artifacts + # run: | + # cd ~/artifacts + # for f in *; do + # mv "$f" "${f//armv7l/armv6l}" + # done + + # - name: Test armv7 wheel on armv6 + # uses: uraimo/run-on-arch-action@v3.0.1 + # with: + # arch: armv6 + # distro: bookworm + # githubToken: ${{ github.token }} + # dockerRunArgs: --volume ~/artifacts:/artifacts_new + # shell: /bin/sh + # install: ${{ env.INSTALL_CMD }} + # run: | + # echo "\nInstalling wheel\n" + # pip3 install --no-index --pre --break-system-packages --find-links /artifacts_new pygame-ce + # echo "\nRunning tests\n" + # export SDL_VIDEODRIVER=dummy + # export SDL_AUDIODRIVER=disk + # python3 -m pygame.tests -v --exclude opengl,music,timing --time_out 300 diff --git a/.github/workflows/build-ubuntu-ctest.yml b/.github/workflows/build-ubuntu-ctest.yml index ade94fd313..0160df72c8 100644 --- a/.github/workflows/build-ubuntu-ctest.yml +++ b/.github/workflows/build-ubuntu-ctest.yml @@ -43,7 +43,7 @@ concurrency: cancel-in-progress: true jobs: - gen_coverage: + gen_ctest: runs-on: ${{ matrix.os }} strategy: fail-fast: false # if a particular matrix build fails, don't skip the rest diff --git a/subprojects/unity/CMakeLists.txt b/subprojects/unity/CMakeLists.txt deleted file mode 100644 index f7062199e3..0000000000 --- a/subprojects/unity/CMakeLists.txt +++ /dev/null @@ -1,172 +0,0 @@ -################################################################################### -# # -# NAME: CMakeLists.txt # -# # -# AUTHOR: Mike Karlesky, Mark VanderVoord, Greg Williams. # -# WRITTEN BY: Michael Brockus. # -# # -# License: MIT # -# # -################################################################################### - -cmake_minimum_required(VERSION 3.12) - -# Read src/unity.h file and get project version from it -set(UNITY_HEADER "src/unity.h") - -file(STRINGS "${UNITY_HEADER}" UNITY_HEADER_CONTENT - REGEX "^#define UNITY_VERSION_(MAJOR|MINOR|BUILD) +[0-9]+$" -) - -set(UNITY_HEADER_VERSION_MAJOR 0) -set(UNITY_HEADER_VERSION_MINOR 0) -set(UNITY_HEADER_VERSION_BUILD 0) - -foreach(VERSION_LINE IN LISTS UNITY_HEADER_CONTENT) - foreach(VERSION_PART MAJOR MINOR BUILD) - string(CONCAT REGEX_STRING "#define UNITY_VERSION_" - "${VERSION_PART}" - " +([0-9]+)" - ) - - if(VERSION_LINE MATCHES "${REGEX_STRING}") - set(UNITY_HEADER_VERSION_${VERSION_PART} "${CMAKE_MATCH_1}") - endif() - endforeach() -endforeach() - -project(unity - VERSION ${UNITY_HEADER_VERSION_MAJOR}.${UNITY_HEADER_VERSION_MINOR}.${UNITY_HEADER_VERSION_BUILD} - LANGUAGES C - DESCRIPTION "C Unit testing framework." -) - -# Options to Build With Extras ------------------------------------------------- -option(UNITY_EXTENSION_FIXTURE "Compiles Unity with the \"fixture\" extension." OFF) -option(UNITY_EXTENSION_MEMORY "Compiles Unity with the \"memory\" extension." OFF) - -set(UNITY_EXTENSION_FIXTURE_ENABLED $) -set(UNITY_EXTENSION_MEMORY_ENABLED $>) - -if(${UNITY_EXTENSION_FIXTURE}) - message(STATUS "Unity: Building with the fixture extension.") -endif() - -if(${UNITY_EXTENSION_MEMORY}) - message(STATUS "Unity: Building with the memory extension.") -endif() - -# Main target ------------------------------------------------------------------ -add_library(${PROJECT_NAME} STATIC) -add_library(${PROJECT_NAME}::framework ALIAS ${PROJECT_NAME}) - -# Includes --------------------------------------------------------------------- -include(GNUInstallDirs) -include(CMakePackageConfigHelpers) - -target_sources(${PROJECT_NAME} - PRIVATE - src/unity.c - $<$:extras/fixture/src/unity_fixture.c> - $<$:extras/memory/src/unity_memory.c> -) - -target_include_directories(${PROJECT_NAME} - PUBLIC - $ - $ - $ - $ - $:${CMAKE_CURRENT_SOURCE_DIR}/extras/memory/src>> - $:${CMAKE_CURRENT_SOURCE_DIR}/extras/fixture/src>> -) - -set(${PROJECT_NAME}_PUBLIC_HEADERS - src/unity.h - src/unity_internals.h - $<$:${CMAKE_CURRENT_SOURCE_DIR}/extras/fixture/src/unity_fixture.h> - $<$:${CMAKE_CURRENT_SOURCE_DIR}/extras/fixture/src/unity_fixture_internals.h> - $<$:${CMAKE_CURRENT_SOURCE_DIR}/extras/memory/src/unity_memory.h> -) - -set_target_properties(${PROJECT_NAME} - PROPERTIES - C_STANDARD 11 - C_STANDARD_REQUIRED ON - C_EXTENSIONS OFF - PUBLIC_HEADER "${${PROJECT_NAME}_PUBLIC_HEADERS}" - EXPORT_NAME framework -) - -target_compile_options(${PROJECT_NAME} - PRIVATE - # Clang - $<$: - -Wcast-align - -Wcast-qual - -Wconversion - -Wexit-time-destructors - -Wglobal-constructors - -Wmissing-noreturn - -Wmissing-prototypes - -Wno-missing-braces - -Wold-style-cast - -Wshadow - -Wweak-vtables - -Werror - -Wall - $<$,8.0.0>:-Wextra-semi-stmt> - > - - # GCC - $<$: - -Waddress - -Waggregate-return - -Wformat-nonliteral - -Wformat-security - -Wformat - -Winit-self - -Wmissing-declarations - -Wmissing-include-dirs - -Wno-multichar - -Wno-parentheses - -Wno-type-limits - -Wno-unused-parameter - -Wunreachable-code - -Wwrite-strings - -Wpointer-arith - -Werror - -Wall - > - - # MSVC - $<$: - /Wall - > -) - -write_basic_package_version_file(${PROJECT_NAME}ConfigVersion.cmake - VERSION ${PROJECT_VERSION} - COMPATIBILITY SameMajorVersion -) - -## Target installation -install(TARGETS ${PROJECT_NAME} - EXPORT ${PROJECT_NAME}Targets - ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} - LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} - PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME} - COMPONENT library -) - -## Target's cmake files: targets export -install(EXPORT ${PROJECT_NAME}Targets - NAMESPACE ${PROJECT_NAME}:: - DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME} -) - -## Target's cmake files: config and version config for find_package() -install(FILES ${PROJECT_NAME}Config.cmake - ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake - DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME} -) diff --git a/subprojects/unity/LICENSE.txt b/subprojects/unity/LICENSE.txt deleted file mode 100644 index 3e3aad5bcd..0000000000 --- a/subprojects/unity/LICENSE.txt +++ /dev/null @@ -1,21 +0,0 @@ -The MIT License (MIT) - -Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in -all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -THE SOFTWARE. diff --git a/subprojects/unity/README.md b/subprojects/unity/README.md deleted file mode 100644 index 2ebf988e6a..0000000000 --- a/subprojects/unity/README.md +++ /dev/null @@ -1,234 +0,0 @@ -# Unity Test ![CI][] - -__Copyright (c) 2007 - 2024 Unity Project by Mike Karlesky, Mark VanderVoord, and Greg Williams__ - -Welcome to the Unity Test Project, one of the main projects of ThrowTheSwitch.org. -Unity Test is a unit testing framework built for C, with a focus on working with embedded toolchains. - -This project is made to test code targetting microcontrollers big and small. -The core project is a single C file and a pair of headers, allowing it to be added to your existing build setup without too much headache. -You may use any compiler you wish, and may use most existing build systems including Make, CMake, etc. -If you'd like to leave the hard work to us, you might be interested in Ceedling, a build tool also by ThrowTheSwitch.org. - -If you're new to Unity, we encourage you to tour the [getting started guide][]. - -You can also find the [change log][] and [known issues][] in our documentation. - -## Getting Started - -The [docs][] folder contains a [getting started guide][] and much more tips about using Unity. - -## Unity Assertion Summary - -For the full list, see [UnityAssertionsReference.md][]. - -### Basic Validity Tests - - TEST_ASSERT_TRUE(condition) - -Evaluates whatever code is in condition and fails if it evaluates to false - - TEST_ASSERT_FALSE(condition) - -Evaluates whatever code is in condition and fails if it evaluates to true - - TEST_ASSERT(condition) - -Another way of calling `TEST_ASSERT_TRUE` - - TEST_ASSERT_UNLESS(condition) - -Another way of calling `TEST_ASSERT_FALSE` - - TEST_FAIL() - TEST_FAIL_MESSAGE(message) - -This test is automatically marked as a failure. -The message is output stating why. - -### Numerical Assertions: Integers - - TEST_ASSERT_EQUAL_INT(expected, actual) - TEST_ASSERT_EQUAL_INT8(expected, actual) - TEST_ASSERT_EQUAL_INT16(expected, actual) - TEST_ASSERT_EQUAL_INT32(expected, actual) - TEST_ASSERT_EQUAL_INT64(expected, actual) - -Compare two integers for equality and display errors as signed integers. -A cast will be performed to your natural integer size so often this can just be used. -When you need to specify the exact size, you can use a specific version. - - TEST_ASSERT_EQUAL_UINT(expected, actual) - TEST_ASSERT_EQUAL_UINT8(expected, actual) - TEST_ASSERT_EQUAL_UINT16(expected, actual) - TEST_ASSERT_EQUAL_UINT32(expected, actual) - TEST_ASSERT_EQUAL_UINT64(expected, actual) - -Compare two integers for equality and display errors as unsigned integers. -Like INT, there are variants for different sizes also. - - TEST_ASSERT_EQUAL_HEX(expected, actual) - TEST_ASSERT_EQUAL_HEX8(expected, actual) - TEST_ASSERT_EQUAL_HEX16(expected, actual) - TEST_ASSERT_EQUAL_HEX32(expected, actual) - TEST_ASSERT_EQUAL_HEX64(expected, actual) - -Compares two integers for equality and display errors as hexadecimal. -Like the other integer comparisons, you can specify the size... -here the size will also effect how many nibbles are shown (for example, `HEX16` will show 4 nibbles). - - TEST_ASSERT_EQUAL(expected, actual) - -Another way of calling TEST_ASSERT_EQUAL_INT - - TEST_ASSERT_INT_WITHIN(delta, expected, actual) - -Asserts that the actual value is within plus or minus delta of the expected value. -This also comes in 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 - - _ARRAY - -You can append `_ARRAY` to any of these macros to make an array comparison of that type. -Here you will need to care a bit more about the actual size of the value being checked. -You will also specify an additional argument which is the number of elements to compare. -For example: - - TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, elements) - - _EACH_EQUAL - -Another array comparison option is to check that EVERY element of an array is equal to a single expected value. -You do this by specifying the EACH_EQUAL macro. -For example: - - TEST_ASSERT_EACH_EQUAL_INT32(expected, actual, elements) - -### Numerical Assertions: Bitwise - - TEST_ASSERT_BITS(mask, expected, actual) - -Use an integer mask to specify which bits should be compared between two other integers. -High bits in the mask are compared, low bits ignored. - - TEST_ASSERT_BITS_HIGH(mask, actual) - -Use an integer mask to specify which bits should be inspected to determine if they are all set high. -High bits in the mask are compared, low bits ignored. - - TEST_ASSERT_BITS_LOW(mask, actual) - -Use an integer mask to specify which bits should be inspected to determine if they are all set low. -High bits in the mask are compared, low bits ignored. - - TEST_ASSERT_BIT_HIGH(bit, actual) - -Test a single bit and verify that it is high. -The bit is specified 0-31 for a 32-bit integer. - - TEST_ASSERT_BIT_LOW(bit, actual) - -Test a single bit and verify that it is low. -The bit is specified 0-31 for a 32-bit integer. - -### Numerical Assertions: Floats - - TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual) - TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual) - -Asserts that the actual value is within plus or minus delta of the expected value. - - TEST_ASSERT_FLOAT_NOT_WITHIN(delta, expected, actual) - TEST_ASSERT_DOUBLE_NOT_WITHIN(delta, expected, actual) - -Asserts that the actual value is NOT within plus or minus delta of the expected value. - - TEST_ASSERT_EQUAL_FLOAT(expected, actual) - TEST_ASSERT_EQUAL_DOUBLE(expected, actual) - -Asserts that two floating point values are "equal" within a small % delta of the expected value. - - TEST_ASSERT_NOT_EQUAL_FLOAT(expected, actual) - TEST_ASSERT_NOT_EQUAL_DOUBLE(expected, actual) - -Asserts that two floating point values are NOT "equal" within a small % delta of the expected value. - - TEST_ASSERT_LESS_THAN_FLOAT(threshold, actual) - TEST_ASSERT_LESS_THAN_DOUBLE(threshold, actual) - TEST_ASSERT_GREATER_THAN_FLOAT(threshold, actual) - TEST_ASSERT_GREATER_THAN_DOUBLE(threshold, actual) - -Asserts that the actual value is less than or greater than the threshold. - -There are also `LESS_OR_EQUAL` and `GREATER_OR_EQUAL` variations. -These obey the same rules for equality as do `TEST_ASSERT_EQUAL_FLOAT` and `TEST_ASSERT_EQUAL_DOUBLE`: -If the two values are within a small % delta of the expected value, the assertion will pass. - -### String Assertions - - TEST_ASSERT_EQUAL_STRING(expected, actual) - -Compare two null-terminate strings. -Fail if any character is different or if the lengths are different. - - TEST_ASSERT_EQUAL_STRING_LEN(expected, actual, len) - -Compare two strings. -Fail if any character is different, stop comparing after len characters. - - TEST_ASSERT_EQUAL_STRING_MESSAGE(expected, actual, message) - -Compare two null-terminate strings. -Fail if any character is different or if the lengths are different. -Output a custom message on failure. - - TEST_ASSERT_EQUAL_STRING_LEN_MESSAGE(expected, actual, len, message) - -Compare two strings. -Fail if any character is different, stop comparing after len characters. -Output a custom message on failure. - -### Pointer Assertions - -Most pointer operations can be performed by simply using the integer comparisons above. -However, a couple of special cases are added for clarity. - - TEST_ASSERT_NULL(pointer) - -Fails if the pointer is not equal to NULL - - TEST_ASSERT_NOT_NULL(pointer) - -Fails if the pointer is equal to NULL - -### Memory Assertions - - TEST_ASSERT_EQUAL_MEMORY(expected, actual, len) - -Compare two blocks of memory. -This is a good generic assertion for types that can't be coerced into acting like standard types... -but since it's a memory compare, you have to be careful that your data types are packed. - -### \_MESSAGE - -You can append `\_MESSAGE` to any of the macros to make them take an additional argument. -This argument is a string that will be printed at the end of the failure strings. -This is useful for specifying more information about the problem. - -[CI]: https://github.com/ThrowTheSwitch/Unity/workflows/CI/badge.svg -[getting started guide]: docs/UnityGettingStartedGuide.md -[change log]: docs/UnityChangeLog.md -[known issues]: docs/UnityKnownIssues.md -[docs]: docs/ -[UnityAssertionsReference.md]: docs/UnityAssertionsReference.md diff --git a/subprojects/unity/docs/CODE_OF_CONDUCT.md b/subprojects/unity/docs/CODE_OF_CONDUCT.md deleted file mode 100644 index 84e34806a9..0000000000 --- a/subprojects/unity/docs/CODE_OF_CONDUCT.md +++ /dev/null @@ -1,138 +0,0 @@ - -# ThrowTheSwitch.org Code of Conduct - -Thank you for participating in a ThrowTheSwitch.org community project! We want -this to continue to be a warm and inviting place for everyone to share ideas -and get help. To accomplish this goal, we've developed this Code of Conduct. - -## Our Pledge - -We as members, contributors, and leaders pledge to make participation in our -community a harassment-free experience for everyone, regardless of age, body -size, visible or invisible disability, ethnicity, sex characteristics, gender -identity and expression, level of experience, education, socio-economic status, -nationality, personal appearance, race, caste, color, religion, or sexual -identity and orientation. - -We pledge to act and interact in ways that contribute to an open, welcoming, -diverse, inclusive, and healthy community. - -## Our Standards - -Examples of behavior that contributes to a positive environment for our -community include: - -* Demonstrating empathy and kindness toward other people -* Being respectful of differing opinions, viewpoints, and experiences -* Giving and gracefully accepting constructive feedback -* Accepting responsibility and apologizing to those affected by our mistakes, - and learning from the experience -* Focusing on what is best not just for us as individuals, but for the overall - community - -Examples of unacceptable behavior include: - -* The use of sexualized language or imagery, and sexual attention or advances of - any kind -* Trolling, insulting or derogatory comments, and personal or political attacks -* Public or private harassment -* Publishing others' private information, such as a physical or email address, - without their explicit permission -* Other conduct which could reasonably be considered inappropriate in a - professional setting - -## Enforcement Responsibilities - -Community leaders are responsible for clarifying and enforcing our standards of -acceptable behavior and will take appropriate and fair corrective action in -response to any behavior that they deem inappropriate, threatening, offensive, -or harmful. - -Community leaders have the right and responsibility to remove, edit, or reject -comments, commits, code, wiki edits, issues, and other contributions that are -not aligned to this Code of Conduct, and will communicate reasons for moderation -decisions when appropriate. - -## Scope - -This Code of Conduct applies within all community spaces, and also applies when -an individual is officially representing the community in public spaces. -Examples of representing our community include using an official email address, -posting via an official social media account, or acting as an appointed -representative at an online or offline event. - -## Enforcement - -Instances of abusive, harassing, or otherwise unacceptable behavior may be -reported to the community leaders responsible for enforcement at -hello@thingamabyte.com. - -All complaints will be reviewed and investigated promptly and fairly. - -All community leaders are obligated to respect the privacy and security of the -reporter of any incident. - -## Enforcement Guidelines - -Community leaders will follow these Community Impact Guidelines in determining -the consequences for any action they deem in violation of this Code of Conduct: - -### 1. Correction - -**Community Impact**: Use of inappropriate language or other behavior deemed -unprofessional or unwelcome in the community. - -**Consequence**: A private, written warning from community leaders, providing -clarity around the nature of the violation and an explanation of why the -behavior was inappropriate. A public apology may be requested. - -### 2. Warning - -**Community Impact**: A violation through a single incident or series of -actions. - -**Consequence**: A warning with consequences for continued behavior. No -interaction with the people involved, including unsolicited interaction with -those enforcing the Code of Conduct, for a specified period of time. This -includes avoiding interactions in community spaces as well as external channels -like social media. Violating these terms may lead to a temporary or permanent -ban. - -### 3. Temporary Ban - -**Community Impact**: A serious violation of community standards, including -sustained inappropriate behavior. - -**Consequence**: A temporary ban from any sort of interaction or public -communication with the community for a specified period of time. No public or -private interaction with the people involved, including unsolicited interaction -with those enforcing the Code of Conduct, is allowed during this period. -Violating these terms may lead to a permanent ban. - -### 4. Permanent Ban - -**Community Impact**: Demonstrating a pattern of violation of community -standards, including sustained inappropriate behavior, harassment of an -individual, or aggression toward or disparagement of classes of individuals. - -**Consequence**: A permanent ban from any sort of public interaction within the -community. - -## Attribution - -This Code of Conduct is adapted from the [Contributor Covenant][homepage], -version 2.1, available at -[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1]. - -Community Impact Guidelines were inspired by -[Mozilla's code of conduct enforcement ladder][Mozilla CoC]. - -For answers to common questions about this code of conduct, see the FAQ at -[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at -[https://www.contributor-covenant.org/translations][translations]. - -[homepage]: https://www.contributor-covenant.org -[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html -[Mozilla CoC]: https://github.com/mozilla/diversity -[FAQ]: https://www.contributor-covenant.org/faq -[translations]: https://www.contributor-covenant.org/translations diff --git a/subprojects/unity/docs/CONTRIBUTING.md b/subprojects/unity/docs/CONTRIBUTING.md deleted file mode 100644 index e64a285a15..0000000000 --- a/subprojects/unity/docs/CONTRIBUTING.md +++ /dev/null @@ -1,238 +0,0 @@ -# Contributing to a ThrowTheSwitch.org Project - -👍🎉 _First off, thanks for taking the time to contribute!_ 🎉👍 - -The following is a set of guidelines for contributing to any of ThrowTheSwitch.org's projects or the website itself, hosted at throwtheswitch.org or ThrowTheSwitch's organization on GitHub. These are mostly guidelines, not rules. Use your best judgment, and feel free to propose changes to this document in a pull request. - -### Table Of Contents - -- [Code of Conduct](#book-code-of-conduct) -- [Asking Questions](#bulb-asking-questions) -- [Opening an Issue](#inbox_tray-opening-an-issue) -- [Feature Requests](#love_letter-feature-requests) -- [Triaging Issues](#mag-triaging-issues) -- [Submitting Pull Requests](#repeat-submitting-pull-requests) -- [Writing Commit Messages](#memo-writing-commit-messages) -- [Code Review](#white_check_mark-code-review) -- [Coding Style](#nail_care-coding-style) -- [Certificate of Origin](#medal_sports-certificate-of-origin) -- [Credits](#pray-credits) - -## :book: Code of Conduct - -Please review our [Code of Conduct](CODE_OF_CONDUCT.md). It is in effect at all times. We expect it to be honored by everyone who contributes to this project. Be a Good Human! - -## :bulb: Asking Questions - -> **Note:** Please don't file an issue to ask a question. We have an official forum where the community chimes in with helpful advice if you have questions. - -* [ThrowTheSwitch Forums](https://throwtheswitch.org/forums) - -### What should I know before I get started? - -ThrowTheSwitch hosts a number of open source projects — Ceedling is the entrypoint for many users. Ceedling is actually built upon the foundation of Unity Test (a flexible C testing framework) and CMock (a mocking tool for C) and it coordinates many other open source and proprietary tools. Please do your best to focus your ideas and questions at the correct tool. We'll do our best to help you find your way, but there will be times where we'll have to direct your attention to another subtool. - -Here are some of the main projects hosted by ThrowTheSwitch.org: - - - [Ceedling](https://www.github.com/throwtheswitch/ceedling) -- Build coordinator for testing C applications, especially embedded C (and optionally your release build too!) - - [CMock](https://www.github.com/throwtheswitch/cmock) -- Mocking tool for automatically creating stubs, mocks, and skeletons in C - - [Unity](https://www.github.com/throwtheswitch/unity) -- Unit Testing framework for C, specially embedded C. - - [MadScienceLabDocker](https://www.github.com/throwtheswitch/madsciencelabdocker) -- Docker image giving you a shortcut to getting running with Ceedling - - [CException](https://www.github.com/throwtheswitch/cexception) -- An exception framework for using simple exceptions in C. - -There are many more, but this list should be a good starting point. - -## :inbox_tray: Opening an Issue - -Before [creating an issue](https://help.github.com/en/github/managing-your-work-on-github/creating-an-issue), check if you are using the latest version of the project. If you are not up-to-date, see if updating fixes your issue first. - -### :beetle: Bug Reports and Other Issues - -A great way to contribute to the project is to send a detailed issue when you encounter a problem. We always appreciate a well-written, thorough bug report. :v: - -In short, since you are most likely a developer, **provide a ticket that you would like to receive**. - -- **Review the documentation** before opening a new issue. - -- **Do not open a duplicate issue!** Search through existing issues to see if your issue has previously been reported. If your issue exists, comment with any additional information you have. You may simply note "I have this problem too", which helps prioritize the most common problems and requests. - -- **Prefer using [reactions](https://github.blog/2016-03-10-add-reactions-to-pull-requests-issues-and-comments/)**, not comments, if you simply want to "+1" an existing issue. - -- **Fully complete the provided issue template.** The bug report template requests all the information we need to quickly and efficiently address your issue. Be clear, concise, and descriptive. Provide as much information as you can, including steps to reproduce, stack traces, compiler errors, library versions, OS versions, and screenshots (if applicable). - -- **Use [GitHub-flavored Markdown](https://help.github.com/en/github/writing-on-github/basic-writing-and-formatting-syntax).** Especially put code blocks and console outputs in backticks (```). This improves readability. - -## :seedling: Feature Requests - -Feature requests are welcome! We don't have all the answers and we truly love the collaborative experience of building software together! That being said, we cannot guarantee your request will be accepted. We want to avoid [feature creep](https://en.wikipedia.org/wiki/Feature_creep). Your idea may be great, but also out-of-scope for the project. If accepted, we'll do our best to tackle it in a timely manner, but cannot make any commitments regarding the timeline for implementation and release. However, you are welcome to submit a pull request to help! - -- **Please don't open a duplicate feature request.** Search for existing feature requests first. If you find your feature (or one very similar) previously requested, comment on that issue. - -- **Fully complete the provided issue template.** The feature request template asks for all necessary information for us to begin a productive conversation. - -- Be precise about the proposed outcome of the feature and how it relates to existing features. Include implementation details if possible. - -## :mag: Triaging Issues - -You can triage issues which may include reproducing bug reports or asking for additional information, such as version numbers or reproduction instructions. Any help you can provide to quickly resolve an issue is very much appreciated! - -## :repeat: Submitting Pull Requests - -We **love** pull requests! Before [forking the repo](https://help.github.com/en/github/getting-started-with-github/fork-a-repo) and [creating a pull request](https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/proposing-changes-to-your-work-with-pull-requests) for non-trivial changes, it is usually best to first open an issue to discuss the changes, or discuss your intended approach for solving the problem in the comments for an existing issue. - -For most contributions, after your first pull request is accepted and merged, you will be [invited to the project](https://help.github.com/en/github/setting-up-and-managing-your-github-user-account/inviting-collaborators-to-a-personal-repository) and given **push access**. :tada: - -*Note: All contributions will be licensed under the project's license.* - -- **Smaller is better.** Submit **one** pull request per bug fix or feature. A pull request should contain isolated changes pertaining to a single bug fix or feature implementation. **Do not** refactor or reformat code that is unrelated to your change. It is better to **submit many small pull requests** rather than a single large one. Enormous pull requests will take enormous amounts of time to review, or may be rejected altogether. - -- **Coordinate bigger changes.** For large and non-trivial changes, open an issue to discuss a strategy with the maintainers. Otherwise, you risk doing a lot of work for nothing! - -- **Prioritize understanding over cleverness.** Write code clearly and concisely. Remember that source code usually gets written once and read often. Ensure the code is clear to the reader. The purpose and logic should be obvious to a reasonably skilled developer, otherwise you should add a comment that explains it. - -- **Follow existing coding style and conventions.** Keep your code consistent with the style, formatting, and conventions in the rest of the code base. When possible, these will be enforced with a linter. Consistency makes it easier to review and modify in the future. - -- **Include test coverage.** Add unit tests when possible. Follow existing patterns for implementing tests. - -- **Update the example project** if one exists to exercise any new functionality you have added. - -- **Add documentation.** Document your changes with code doc comments or in existing guides. - -- **Update the CHANGELOG** for all enhancements and bug fixes. Include the corresponding issue number if one exists, and your GitHub username. (example: "- Fixed crash in profile view. #123 @jessesquires") - -- **Use the repo's default branch.** Branch from and [submit your pull request](https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/creating-a-pull-request-from-a-fork) to the repo's default branch. Usually this is `main`, but it could be `dev`, `develop`, or `master`. - -- **[Resolve any merge conflicts](https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/resolving-a-merge-conflict-on-github)** that occur. - -- **Promptly address any CI failures**. If your pull request fails to build or pass tests, please push another commit to fix it. - -- When writing comments, use properly constructed sentences, including punctuation. - -- Use spaces, not tabs. - -## :memo: Writing Commit Messages - -Please [write a great commit message](https://chris.beams.io/posts/git-commit/). - -1. Separate subject from body with a blank line -1. Limit the subject line to 50 characters -1. Capitalize the subject line -1. Do not end the subject line with a period -1. Wrap the body at _about_ 72 characters -1. Use the body to explain **why**, *not what and how* (the code shows that!) -1. If applicable, prefix the title with the relevant component name or emoji (see below. examples: "[Docs] Fix typo", "[Profile] Fix missing avatar") - -``` -:palm_tree: Summary of Amazing Feature Here - -Add a more detailed explanation here, if necessary. Possibly give -some background about the issue being fixed, etc. The body of the -commit message can be several paragraphs. Further paragraphs come -after blank lines and please do proper word-wrap. - -Wrap it to about 72 characters or so. In some contexts, -the first line is treated as the subject of the commit and the -rest of the text as the body. The blank line separating the summary -from the body is critical (unless you omit the body entirely); -various tools like `log`, `shortlog` and `rebase` can get confused -if you run the two together. - -Explain the problem that this commit is solving. Focus on why you -are making this change as opposed to how or what. The code explains -how or what. Reviewers and your future self can read the patch, -but might not understand why a particular solution was implemented. -Are there side effects or other unintuitive consequences of this -change? Here's the place to explain them. - - - Bullet points are awesome, too - - - A hyphen should be used for the bullet, preceded - by a single space, with blank lines in between - -Note the fixed or relevant GitHub issues at the end: - -Resolves: #123 -See also: #456, #789 -``` - -## :heart: Who Loves Emoji? - -Commit comments, Issues, Feature Requests... they can all use a little sprucing up, right? Consider using the following emoji for a mix of function and :sparkles: dazzle! - - - actions - - :seedling: `:seedling:` (or other plants) when growing new features. Choose your fav! :cactus: :herb: :evergreen_tree: :palm_tree: :deciduous_tree: :blossom: - - :art: `:art:` when improving the format/structure of the code - - :racehorse: `:racehorse:` when improving performance - - :non-potable_water: `:non-potable_water:` when plugging memory leaks - - :memo: `:memo:` when writing docs - - :bug: `:bug:` (or other insects) when fixing a bug. Maybe :beetle: :ant: or :honeybee: ? - - :fire: `:fire:` when removing code or files - - :green_heart: `:green_heart:` when fixing the CI build - - :white_check_mark: `:white_check_mark:` when adding tests - - :lock: `:lock:` when dealing with security - - :arrow_up: `:arrow_up:` when upgrading dependencies - - :arrow_down: `:arrow_down:` when downgrading dependencies - - :shirt: `:shirt:` when removing linter warnings - - - platforms - - :penguin: `:penguin:` when fixing something on Linux - - :apple: `:apple:` when fixing something on macOS - - :checkered_flag: `:checkered_flag:` when fixing something on Windows - -## :white_check_mark: Code Review - -- **Review the code, not the author.** Look for and suggest improvements without disparaging or insulting the author. Provide actionable feedback and explain your reasoning. - -- **You are not your code.** When your code is critiqued, questioned, or constructively criticized, remember that you are not your code. Do not take code review personally. - -- **Always do your best.** No one writes bugs on purpose. Do your best, and learn from your mistakes. - -- Kindly note any violations to the guidelines specified in this document. - -## :violin: Coding Style - -Consistency is the most important. Following the existing style, formatting, and naming conventions of the file you are modifying and of the overall project. Failure to do so will result in a prolonged review process that has to focus on updating the superficial aspects of your code, rather than improving its functionality and performance. - -For example, if all private properties are prefixed with an underscore `_`, then new ones you add should be prefixed in the same way. Or, if methods are named using camelcase, like `thisIsMyNewMethod`, then do not diverge from that by writing `this_is_my_new_method`. You get the idea. If in doubt, please ask or search the codebase for something similar. - -When possible, style and format will be enforced with a linter. - -### C Styleguide - -C code is linted with [AStyle](https://astyle.sourceforge.net/). - -### Ruby Styleguide - -Ruby code is linted with [Rubocop](https://github.com/rubocop/rubocop) - -## :medal_sports: Certificate of Origin - -*Developer's Certificate of Origin 1.1* - -By making a contribution to this project, I certify that: - -> 1. The contribution was created in whole or in part by me and I have the right to submit it under the open source license indicated in the file; or -> 1. The contribution is based upon previous work that, to the best of my knowledge, is covered under an appropriate open source license and I have the right under that license to submit that work with modifications, whether created in whole or in part by me, under the same open source license (unless I am permitted to submit under a different license), as indicated in the file; or -> 1. The contribution was provided directly to me by some other person who certified (1), (2) or (3) and I have not modified it. -> 1. I understand and agree that this project and the contribution are public and that a record of the contribution (including all personal information I submit with it, including my sign-off) is maintained indefinitely and may be redistributed consistent with this project or the open source license(s) involved. - -## [No Brown M&M's](https://en.wikipedia.org/wiki/Van_Halen#Contract_riders) - -If you are reading this, bravo dear user and (hopefully) contributor for making it this far! You are awesome. :100: - -To confirm that you have read this guide and are following it as best as possible, **include this emoji at the top** of your issue or pull request: :pineapple: `:pineapple:` - -## :pray: Credits - -Written by [@jessesquires](https://github.com/jessesquires). Lovingly adapted to ThrowTheSwitch.org by [@mvandervoord](https://github.com/mvandervoord). - -**Please feel free to adopt this guide in your own projects. Fork it wholesale or remix it for your needs.** - -*Many of the ideas and prose for the statements in this document were based on or inspired by work from the following communities:* - -- [Alamofire](https://github.com/Alamofire/Alamofire/blob/master/CONTRIBUTING.md) -- [CocoaPods](https://github.com/CocoaPods/CocoaPods/blob/master/CONTRIBUTING.md) -- [Docker](https://github.com/moby/moby/blob/master/CONTRIBUTING.md) -- [Linux](https://elinux.org/Developer_Certificate_Of_Origin) - -*We commend them for their efforts to facilitate collaboration in their projects.* diff --git a/subprojects/unity/docs/MesonGeneratorRunner.md b/subprojects/unity/docs/MesonGeneratorRunner.md deleted file mode 100644 index 3b81e37827..0000000000 --- a/subprojects/unity/docs/MesonGeneratorRunner.md +++ /dev/null @@ -1,18 +0,0 @@ -# Meson Generator - Test Runner - -One of the really nice things about using Unity with Ceedling is that Ceedling takes care of generating all of the test runners automatically. If you're not using Ceedling though, you'll need to do this yourself. - -The way this is done in Unity is via a Ruby script called `generate_test_runner.rb`. When given a test file such as `test_example.c`, the script will generate `test_example_Runner.c`, which provides the `main` method and some other useful plumbing. - -So that you don't have to run this by hand, a Meson generator is provided to generate the runner automatically for you. Generally with Meson, you would use Unity as a subproject and you'd want to access the generator from the parent. - -For example, to get the generator you can use: - - unity_proj = subproject('unity') - runner_gen = unity_proj.get_variable('gen_test_runner') - -Once you have the generator you need to pass it the absolute path of your test file. This seems to be a bug in how the paths work with subprojects in Meson. You can get the full path with `meson.source_root()`, so you could do: - - test_runner = meson.source_root() / 'test/test_example.c' - -You can then include `test_runner` as a normal dependency to your builds. Meson will create the test runner in a private directory for each build target. It's only meant to be used as part of the build, so if you need to refer to the runner after the build, you won't be able to use the generator. \ No newline at end of file diff --git a/subprojects/unity/docs/ThrowTheSwitchCodingStandard.md b/subprojects/unity/docs/ThrowTheSwitchCodingStandard.md deleted file mode 100644 index 517b8fb6b6..0000000000 --- a/subprojects/unity/docs/ThrowTheSwitchCodingStandard.md +++ /dev/null @@ -1,187 +0,0 @@ -# ThrowTheSwitch.org Coding Standard - -Hi. -Welcome to the coding standard for ThrowTheSwitch.org. -For the most part, we try to follow these standards to unify our contributors' code into a cohesive unit (puns intended). -You might find places where these standards aren't followed. -We're not perfect. Please be polite where you notice these discrepancies and we'll try to be polite when we notice yours. - -;) - -## Why Have A Coding Standard? - -Being consistent makes code easier to understand. -We've tried to keep our standard simple because we also believe that we can only expect someone to follow something that is understandable. -Please do your best. - -## Our Philosophy - -Before we get into details on syntax, let's take a moment to talk about our vision for these tools. -We're C developers and embedded software developers. -These tools are great to test any C code, but catering to embedded software made us more tolerant of compiler quirks. -There are a LOT of quirky compilers out there. -By quirky I mean "doesn't follow standards because they feel like they have a license to do as they wish." - -Our philosophy is "support every compiler we can". -Most often, this means that we aim for writing C code that is standards compliant (often C89... that seems to be a sweet spot that is almost always compatible). -But it also means these tools are tolerant of things that aren't common. -Some that aren't even compliant. -There are configuration options to override the size of standard types. -There are configuration options to force Unity to not use certain standard library functions. -A lot of Unity is configurable and we have worked hard to make it not TOO ugly in the process. - -Similarly, our tools that parse C do their best. -They aren't full C parsers (yet) and, even if they were, they would still have to accept non-standard additions like gcc extensions or specifying `@0x1000` to force a variable to compile to a particular location. -It's just what we do, because we like everything to Just Work™. - -Speaking of having things Just Work™, that's our second philosophy. -By that, we mean that we do our best to have EVERY configuration option have a logical default. -We believe that if you're working with a simple compiler and target, you shouldn't need to configure very much... we try to make the tools guess as much as they can, but give the user the power to override it when it's wrong. - -## Naming Things - -Let's talk about naming things. -Programming is all about naming things. -We name files, functions, variables, and so much more. -While we're not always going to find the best name for something, we actually put a bit of effort into finding *What Something WANTS to be Called*™. - -When naming things, we follow this hierarchy, the first being the most important to us (but we do all four when possible): - -1. Readable -2. Descriptive -3. Consistent -4. Memorable - -### Readable - -We want to read our code. -This means we like names and flow that are more naturally read. -We try to avoid double negatives. -We try to avoid cryptic abbreviations (sticking to ones we feel are common). - -### Descriptive - -We like descriptive names for things, especially functions and variables. -Finding the right name for something is an important endeavour. -You might notice from poking around our code that this often results in names that are a little longer than the average. -Guilty. -We're okay with a bit more typing if it means our code is easier to understand. - -There are two exceptions to this rule that we also stick to as religiously as possible: - -First, while we realize hungarian notation (and similar systems for encoding type information into variable names) is providing a more descriptive name, we feel that (for the average developer) it takes away from readability and is to be avoided. - -Second, loop counters and other local throw-away variables often have a purpose which is obvious. -There's no need, therefore, to get carried away with complex naming. -We find i, j, and k are better loop counters than loopCounterVar or whatnot. -We only break this rule when we see that more description could improve understanding of an algorithm. - -### Consistent - -We like consistency, but we're not really obsessed with it. -We try to name our configuration macros in a consistent fashion... you'll notice a repeated use of UNITY_EXCLUDE_BLAH or UNITY_USES_BLAH macros. -This helps users avoid having to remember each macro's details. - -### Memorable - -Where ever it doesn't violate the above principles, we try to apply memorable names. -Sometimes this means using something that is simply descriptive, but often we strive for descriptive AND unique... we like quirky names that stand out in our memory and are easier to search for. -Take a look through the file names in Ceedling and you'll get a good idea of what we are talking about here. -Why use preprocess when you can use preprocessinator? -Or what better describes a module in charge of invoking tasks during releases than release_invoker? -Don't get carried away. -The names are still descriptive and fulfil the above requirements, but they don't feel stale. - -## C and C++ Details - -We don't really want to add to the style battles out there. -Tabs or spaces? -How many spaces? -Where do the braces go? -These are age-old questions that will never be answered... or at least not answered in a way that will make everyone happy. - -We've decided on our own style preferences. -If you'd like to contribute to these projects (and we hope that you do), then we ask if you do your best to follow the same. -It will only hurt a little. We promise. - -### Whitespace in C/C++ - -Our C-style is to use spaces and to use 4 of them per indent level. -It's a nice power-of-2 number that looks decent on a wide-screen. -We have no more reason than that. -We break that rule when we have lines that wrap (macros or function arguments or whatnot). -When that happens, we like to indent further to line things up in nice tidy columns. - -```C - if (stuff_happened) - { - do_something(); - } -``` - -### Case in C/C++ - -- Files - all lower case with underscores. -- Variables - all lower case with underscores -- Macros - all caps with underscores. -- Typedefs - all caps with underscores. (also ends with _T). -- Functions - camel cased. Usually named ModuleName_FuncName -- Constants and Globals - camel cased. - -### Braces in C/C++ - -The left brace is on the next line after the declaration. -The right brace is directly below that. -Everything in between in indented one level. -If you're catching an error and you have a one-line, go ahead and to it on the same line. - -```C - while (blah) - { - //Like so. Even if only one line, we use braces. - } -``` - -### Comments in C/C++ - -Do you know what we hate? -Old-school C block comments. -BUT, we're using them anyway. -As we mentioned, our goal is to support every compiler we can, especially embedded compilers. -There are STILL C compilers out there that only support old-school block comments. -So that is what we're using. -We apologize. -We think they are ugly too. - -## Ruby Details - -Is there really such thing as a Ruby coding standard? -Ruby is such a free form language, it seems almost sacrilegious to suggest that people should comply to one method! -We'll keep it really brief! - -### Whitespace in Ruby - -Our Ruby style is to use spaces and to use 2 of them per indent level. -It's a nice power-of-2 number that really grooves with Ruby's compact style. -We have no more reason than that. -We break that rule when we have lines that wrap. -When that happens, we like to indent further to line things up in nice tidy columns. - -### Case in Ruby - -- Files - all lower case with underscores. -- Variables - all lower case with underscores -- Classes, Modules, etc - Camel cased. -- Functions - all lower case with underscores -- Constants - all upper case with underscores - -## Documentation - -Egad. -Really? -We use markdown and we like PDF files because they can be made to look nice while still being portable. -Good enough? - -*Find The Latest of This And More at [ThrowTheSwitch.org][]* - -[ThrowTheSwitch.org]: https://throwtheswitch.org \ No newline at end of file diff --git a/subprojects/unity/docs/UnityAssertionsCheatSheetSuitableforPrintingandPossiblyFraming.pdf b/subprojects/unity/docs/UnityAssertionsCheatSheetSuitableforPrintingandPossiblyFraming.pdf deleted file mode 100644 index 28f0c32144c4f2b55ff07007555e5777480320ac..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 144467 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 diff --git a/subprojects/unity/docs/UnityAssertionsReference.md b/subprojects/unity/docs/UnityAssertionsReference.md deleted file mode 100644 index 0a0e51b65b..0000000000 --- a/subprojects/unity/docs/UnityAssertionsReference.md +++ /dev/null @@ -1,860 +0,0 @@ -# Unity Assertions Reference - -## Background and Overview - -### Super Condensed Version - -- An assertion establishes truth (i.e. boolean True) for a single condition. -Upon boolean False, an assertion stops execution and reports the failure. -- Unity is mainly a rich collection of assertions and the support to gather up -and easily execute those assertions. -- The structure of Unity allows you to easily separate test assertions from -source code in, well, test code. -- Unity’s assertions: - - Come in many, many flavors to handle different C types and assertion cases. - - Use context to provide detailed and helpful failure messages. - - Document types, expected values, and basic behavior in your source code for -free. - -### Unity Is Several Things But Mainly It’s Assertions - -One way to think of Unity is simply as a rich collection of assertions you can -use to establish whether your source code behaves the way you think it does. -Unity provides a framework to easily organize and execute those assertions in -test code separate from your source code. - -### What’s an Assertion? - -At their core, assertions are an establishment of truth - boolean truth. Was this -thing equal to that thing? Does that code doohickey have such-and-such property -or not? You get the idea. Assertions are executable code. Static analysis is a -valuable approach to improving code quality, but it is not executing your code -in the way an assertion can. A failing assertion stops execution and reports an -error through some appropriate I/O channel (e.g. stdout, GUI, output file, -blinky light). - -Fundamentally, for dynamic verification all you need is a single assertion -mechanism. In fact, that’s what the [assert() macro][] in C’s standard library -is for. So why not just use it? Well, we can do far better in the reporting -department. C’s `assert()` is pretty dumb as-is and is particularly poor for -handling common data types like arrays, structs, etc. And, without some other -support, it’s far too tempting to litter source code with C’s `assert()`’s. It’s -generally much cleaner, manageable, and more useful to separate test and source -code in the way Unity facilitates. - -### Unity’s Assertions: Helpful Messages _and_ Free Source Code Documentation - -Asserting a simple truth condition is valuable, but using the context of the -assertion is even more valuable. For instance, if you know you’re comparing bit -flags and not just integers, then why not use that context to give explicit, -readable, bit-level feedback when an assertion fails? - -That’s what Unity’s collection of assertions do - capture context to give you -helpful, meaningful assertion failure messages. In fact, the assertions -themselves also serve as executable documentation about types and values in your -source code. So long as your tests remain current with your source and all those -tests pass, you have a detailed, up-to-date view of the intent and mechanisms in -your source code. And due to a wondrous mystery, well-tested code usually tends -to be well designed code. - -## Assertion Conventions and Configurations - -### Naming and Parameter Conventions - -The convention of assertion parameters generally follows this order: - -```c -TEST_ASSERT_X( {modifiers}, {expected}, actual, {size/count} ) -``` - -The very simplest assertion possible uses only a single `actual` parameter (e.g. -a simple null check). - -- `Actual` is the value being tested and unlike the other parameters in an - assertion construction is the only parameter present in all assertion variants. -- `Modifiers` are masks, ranges, bit flag specifiers, floating point deltas. -- `Expected` is your expected value (duh) to compare to an `actual` value; it’s - marked as an optional parameter because some assertions only need a single - `actual` parameter (e.g. null check). -- `Size/count` refers to string lengths, number of array elements, etc. - -Many of Unity’s assertions are clear duplications in that the same data type -is handled by several assertions. The differences among these are in how failure -messages are presented. For instance, a `_HEX` variant of an assertion prints -the expected and actual values of that assertion formatted as hexadecimal. - -#### TEST_ASSERT_X_MESSAGE Variants - -_All_ assertions are complemented with a variant that includes a simple string -message as a final parameter. The string you specify is appended to an assertion -failure message in Unity output. - -For brevity, the assertion variants with a message parameter are not listed -below. Just tack on `_MESSAGE` as the final component to any assertion name in -the reference list below and add a string as the final parameter. - -_Example:_ - -```c -TEST_ASSERT_X( {modifiers}, {expected}, actual, {size/count} ) -``` - -becomes messageified like thus… - -```c -TEST_ASSERT_X_MESSAGE( {modifiers}, {expected}, actual, {size/count}, message ) -``` - -Notes: - -- The `_MESSAGE` variants intentionally do not support `printf` style formatting - since many embedded projects don’t support or avoid `printf` for various reasons. - It is possible to use `sprintf` before the assertion to assemble a complex fail - message, if necessary. -- If you want to output a counter value within an assertion fail message (e.g. from - a loop) , building up an array of results and then using one of the `_ARRAY` - assertions (see below) might be a handy alternative to `sprintf`. - -#### TEST_ASSERT_X_ARRAY Variants - -Unity provides a collection of assertions for arrays containing a variety of -types. These are documented in the Array section below. These are almost on par -with the `_MESSAGE`variants of Unity’s Asserts in that for pretty much any Unity -type assertion you can tack on `_ARRAY` and run assertions on an entire block of -memory. - -```c - TEST_ASSERT_EQUAL_TYPEX_ARRAY( expected, actual, {size/count} ) -``` - -- `Expected` is an array itself. -- `Size/count` is one or two parameters necessary to establish the number of array - elements and perhaps the length of elements within the array. - -Notes: - -- The `_MESSAGE` variant convention still applies here to array assertions. The - `_MESSAGE` variants of the `_ARRAY` assertions have names ending with - `_ARRAY_MESSAGE`. -- Assertions for handling arrays of floating point values are grouped with float - and double assertions (see immediately following section). - -### TEST_ASSERT_EACH_EQUAL_X Variants - -Unity provides a collection of assertions for arrays containing a variety of -types which can be compared to a single value as well. These are documented in -the Each Equal section below. these are almost on par with the `_MESSAGE` -variants of Unity’s Asserts in that for pretty much any Unity type assertion you -can inject `_EACH_EQUAL` and run assertions on an entire block of memory. - -```c -TEST_ASSERT_EACH_EQUAL_TYPEX( expected, actual, {size/count} ) -``` - -- `Expected` is a single value to compare to. -- `Actual` is an array where each element will be compared to the expected value. -- `Size/count` is one of two parameters necessary to establish the number of array - elements and perhaps the length of elements within the array. - -Notes: - -- The `_MESSAGE` variant convention still applies here to Each Equal assertions. -- Assertions for handling Each Equal of floating point values are grouped with - float and double assertions (see immediately following section). - -### Configuration - -#### Floating Point Support Is Optional - -Support for floating point types is configurable. That is, by defining the -appropriate preprocessor symbols, floats and doubles can be individually enabled -or disabled in Unity code. This is useful for embedded targets with no floating -point math support (i.e. Unity compiles free of errors for fixed point only -platforms). See Unity documentation for specifics. - -#### Maximum Data Type Width Is Configurable - -Not all targets support 64 bit wide types or even 32 bit wide types. Define the -appropriate preprocessor symbols and Unity will omit all operations from -compilation that exceed the maximum width of your target. See Unity -documentation for specifics. - -## The Assertions in All Their Blessed Glory - -### Basic Fail, Pass and Ignore - -#### `TEST_FAIL()` - -#### `TEST_FAIL_MESSAGE("message")` - -This fella is most often used in special conditions where your test code is -performing logic beyond a simple assertion. That is, in practice, `TEST_FAIL()` -will always be found inside a conditional code block. - -_Examples:_ - -- Executing a state machine multiple times that increments a counter your test -code then verifies as a final step. -- Triggering an exception and verifying it (as in Try / Catch / Throw - see the -[CException](https://github.com/ThrowTheSwitch/CException) project). - -#### `TEST_PASS()` - -#### `TEST_PASS_MESSAGE("message")` - -This will abort the remainder of the test, but count the test as a pass. Under -normal circumstances, it is not necessary to include this macro in your tests… -a lack of failure will automatically be counted as a `PASS`. It is occasionally -useful for tests with `#ifdef`s and such. - -#### `TEST_IGNORE()` - -#### `TEST_IGNORE_MESSAGE("message")` - -Marks a test case (i.e. function meant to contain test assertions) as ignored. -Usually this is employed as a breadcrumb to come back and implement a test case. -An ignored test case has effects if other assertions are in the enclosing test -case (see Unity documentation for more). - -#### `TEST_MESSAGE(message)` - -This can be useful for outputting `INFO` messages into the Unity output stream -without actually ending the test. Like pass and fail messages, it will be output -with the filename and line number. - -### Boolean - -#### `TEST_ASSERT (condition)` - -#### `TEST_ASSERT_TRUE (condition)` - -#### `TEST_ASSERT_FALSE (condition)` - -#### `TEST_ASSERT_UNLESS (condition)` - -A simple wording variation on `TEST_ASSERT_FALSE`.The semantics of -`TEST_ASSERT_UNLESS` aid readability in certain test constructions or -conditional statements. - -#### `TEST_ASSERT_NULL (pointer)` - -#### `TEST_ASSERT_NOT_NULL (pointer)` - -Verify if a pointer is or is not NULL. - -#### `TEST_ASSERT_EMPTY (pointer)` - -#### `TEST_ASSERT_NOT_EMPTY (pointer)` - -Verify if the first element dereferenced from a pointer is or is not zero. This -is particularly useful for checking for empty (or non-empty) null-terminated -C strings, but can be just as easily used for other null-terminated arrays. - -### Signed and Unsigned Integers (of all sizes) - -Large integer sizes can be disabled for build targets that do not support them. -For example, if your target only supports up to 16 bit types, by defining the -appropriate symbols Unity can be configured to omit 32 and 64 bit operations -that would break compilation (see Unity documentation for more). Refer to -Advanced Asserting later in this document for advice on dealing with other word -sizes. - -#### `TEST_ASSERT_EQUAL_INT (expected, actual)` - -#### `TEST_ASSERT_EQUAL_INT8 (expected, actual)` - -#### `TEST_ASSERT_EQUAL_INT16 (expected, actual)` - -#### `TEST_ASSERT_EQUAL_INT32 (expected, actual)` - -#### `TEST_ASSERT_EQUAL_INT64 (expected, actual)` - -#### `TEST_ASSERT_EQUAL_UINT (expected, actual)` - -#### `TEST_ASSERT_EQUAL_UINT8 (expected, actual)` - -#### `TEST_ASSERT_EQUAL_UINT16 (expected, actual)` - -#### `TEST_ASSERT_EQUAL_UINT32 (expected, actual)` - -#### `TEST_ASSERT_EQUAL_UINT64 (expected, actual)` - -### Unsigned Integers (of all sizes) in Hexadecimal - -All `_HEX` assertions are identical in function to unsigned integer assertions -but produce failure messages with the `expected` and `actual` values formatted -in hexadecimal. Unity output is big endian. - -#### `TEST_ASSERT_EQUAL_HEX (expected, actual)` - -#### `TEST_ASSERT_EQUAL_HEX8 (expected, actual)` - -#### `TEST_ASSERT_EQUAL_HEX16 (expected, actual)` - -#### `TEST_ASSERT_EQUAL_HEX32 (expected, actual)` - -#### `TEST_ASSERT_EQUAL_HEX64 (expected, actual)` - -### Characters - -While you can use the 8-bit integer assertions to compare `char`, another option is -to use this specialized assertion which will show printable characters as printables, -otherwise showing the HEX escape code for the characters. - -#### `TEST_ASSERT_EQUAL_CHAR (expected, actual)` - -### Masked and Bit-level Assertions - -Masked and bit-level assertions produce output formatted in hexadecimal. Unity -output is big endian. - -#### `TEST_ASSERT_BITS (mask, expected, actual)` - -Only compares the masked (i.e. high) bits of `expected` and `actual` parameters. - -#### `TEST_ASSERT_BITS_HIGH (mask, actual)` - -Asserts the masked bits of the `actual` parameter are high. - -#### `TEST_ASSERT_BITS_LOW (mask, actual)` - -Asserts the masked bits of the `actual` parameter are low. - -#### `TEST_ASSERT_BIT_HIGH (bit, actual)` - -Asserts the specified bit of the `actual` parameter is high. - -#### `TEST_ASSERT_BIT_LOW (bit, actual)` - -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. There are assertions for -all the various sizes of ints, as for the equality assertions. Some examples: - -#### `TEST_ASSERT_GREATER_THAN_INT8 (threshold, actual)` - -#### `TEST_ASSERT_GREATER_OR_EQUAL_INT16 (threshold, actual)` - -#### `TEST_ASSERT_LESS_THAN_INT32 (threshold, actual)` - -#### `TEST_ASSERT_LESS_OR_EQUAL_UINT (threshold, actual)` - -#### `TEST_ASSERT_NOT_EQUAL_UINT8 (threshold, actual)` - -### Integer Ranges (of all sizes) - -These assertions verify that the `expected` parameter is within +/- `delta` -(inclusive) of the `actual` parameter. For example, if the expected value is 10 -and the delta is 3 then the assertion will fail for any value outside the range -of 7 - 13. - -#### `TEST_ASSERT_INT_WITHIN (delta, expected, actual)` - -#### `TEST_ASSERT_INT8_WITHIN (delta, expected, actual)` - -#### `TEST_ASSERT_INT16_WITHIN (delta, expected, actual)` - -#### `TEST_ASSERT_INT32_WITHIN (delta, expected, actual)` - -#### `TEST_ASSERT_INT64_WITHIN (delta, expected, actual)` - -#### `TEST_ASSERT_UINT_WITHIN (delta, expected, actual)` - -#### `TEST_ASSERT_UINT8_WITHIN (delta, expected, actual)` - -#### `TEST_ASSERT_UINT16_WITHIN (delta, expected, actual)` - -#### `TEST_ASSERT_UINT32_WITHIN (delta, expected, actual)` - -#### `TEST_ASSERT_UINT64_WITHIN (delta, expected, actual)` - -#### `TEST_ASSERT_HEX_WITHIN (delta, expected, actual)` - -#### `TEST_ASSERT_HEX8_WITHIN (delta, expected, actual)` - -#### `TEST_ASSERT_HEX16_WITHIN (delta, expected, actual)` - -#### `TEST_ASSERT_HEX32_WITHIN (delta, expected, actual)` - -#### `TEST_ASSERT_HEX64_WITHIN (delta, expected, actual)` - -#### `TEST_ASSERT_CHAR_WITHIN (delta, expected, actual)` - -### Structs and Strings - -#### `TEST_ASSERT_EQUAL_PTR (expected, actual)` - -Asserts that the pointers point to the same memory location. - -#### `TEST_ASSERT_EQUAL_STRING (expected, actual)` - -Asserts that the null terminated (`’\0’`)strings are identical. If strings are -of different lengths or any portion of the strings before their terminators -differ, the assertion fails. Two NULL strings (i.e. zero length) are considered -equivalent. - -#### `TEST_ASSERT_EQUAL_MEMORY (expected, actual, len)` - -Asserts that the contents of the memory specified by the `expected` and `actual` -pointers is identical. The size of the memory blocks in bytes is specified by -the `len` parameter. - -### Arrays - -`expected` and `actual` parameters are both arrays. `num_elements` specifies the -number of elements in the arrays to compare. - -`_HEX` assertions produce failure messages with expected and actual array -contents formatted in hexadecimal. - -For array of strings comparison behavior, see comments for -`TEST_ASSERT_EQUAL_STRING` in the preceding section. - -Assertions fail upon the first element in the compared arrays found not to -match. Failure messages specify the array index of the failed comparison. - -#### `TEST_ASSERT_EQUAL_INT_ARRAY (expected, actual, num_elements)` - -#### `TEST_ASSERT_EQUAL_INT8_ARRAY (expected, actual, num_elements)` - -#### `TEST_ASSERT_EQUAL_INT16_ARRAY (expected, actual, num_elements)` - -#### `TEST_ASSERT_EQUAL_INT32_ARRAY (expected, actual, num_elements)` - -#### `TEST_ASSERT_EQUAL_INT64_ARRAY (expected, actual, num_elements)` - -#### `TEST_ASSERT_EQUAL_UINT_ARRAY (expected, actual, num_elements)` - -#### `TEST_ASSERT_EQUAL_UINT8_ARRAY (expected, actual, num_elements)` - -#### `TEST_ASSERT_EQUAL_UINT16_ARRAY (expected, actual, num_elements)` - -#### `TEST_ASSERT_EQUAL_UINT32_ARRAY (expected, actual, num_elements)` - -#### `TEST_ASSERT_EQUAL_UINT64_ARRAY (expected, actual, num_elements)` - -#### `TEST_ASSERT_EQUAL_HEX_ARRAY (expected, actual, num_elements)` - -#### `TEST_ASSERT_EQUAL_HEX8_ARRAY (expected, actual, num_elements)` - -#### `TEST_ASSERT_EQUAL_HEX16_ARRAY (expected, actual, num_elements)` - -#### `TEST_ASSERT_EQUAL_HEX32_ARRAY (expected, actual, num_elements)` - -#### `TEST_ASSERT_EQUAL_HEX64_ARRAY (expected, actual, num_elements)` - -#### `TEST_ASSERT_EQUAL_CHAR_ARRAY (expected, actual, num_elements)` - -#### `TEST_ASSERT_EQUAL_PTR_ARRAY (expected, actual, num_elements)` - -#### `TEST_ASSERT_EQUAL_STRING_ARRAY (expected, actual, num_elements)` - -#### `TEST_ASSERT_EQUAL_MEMORY_ARRAY (expected, actual, len, num_elements)` - -`len` is the memory in bytes to be compared at each array element. - -### Integer Array Ranges (of all sizes) - -These assertions verify that the `expected` array parameter is within +/- `delta` -(inclusive) of the `actual` array parameter. For example, if the expected value is -\[10, 12\] and the delta is 3 then the assertion will fail for any value -outside the range of \[7 - 13, 9 - 15\]. - -#### `TEST_ASSERT_INT_ARRAY_WITHIN (delta, expected, actual, num_elements)` - -#### `TEST_ASSERT_INT8_ARRAY_WITHIN (delta, expected, actual, num_elements)` - -#### `TEST_ASSERT_INT16_ARRAY_WITHIN (delta, expected, actual, num_elements)` - -#### `TEST_ASSERT_INT32_ARRAY_WITHIN (delta, expected, actual, num_elements)` - -#### `TEST_ASSERT_INT64_ARRAY_WITHIN (delta, expected, actual, num_elements)` - -#### `TEST_ASSERT_UINT_ARRAY_WITHIN (delta, expected, actual, num_elements)` - -#### `TEST_ASSERT_UINT8_ARRAY_WITHIN (delta, expected, actual, num_elements)` - -#### `TEST_ASSERT_UINT16_ARRAY_WITHIN (delta, expected, actual, num_elements)` - -#### `TEST_ASSERT_UINT32_ARRAY_WITHIN (delta, expected, actual, num_elements)` - -#### `TEST_ASSERT_UINT64_ARRAY_WITHIN (delta, expected, actual, num_elements)` - -#### `TEST_ASSERT_HEX_ARRAY_WITHIN (delta, expected, actual, num_elements)` - -#### `TEST_ASSERT_HEX8_ARRAY_WITHIN (delta, expected, actual, num_elements)` - -#### `TEST_ASSERT_HEX16_ARRAY_WITHIN (delta, expected, actual, num_elements)` - -#### `TEST_ASSERT_HEX32_ARRAY_WITHIN (delta, expected, actual, num_elements)` - -#### `TEST_ASSERT_HEX64_ARRAY_WITHIN (delta, expected, actual, num_elements)` - -#### `TEST_ASSERT_CHAR_ARRAY_WITHIN (delta, expected, actual, num_elements)` - -### Each Equal (Arrays to Single Value) - -`expected` are single values and `actual` are arrays. `num_elements` specifies -the number of elements in the arrays to compare. - -`_HEX` assertions produce failure messages with expected and actual array -contents formatted in hexadecimal. - -Assertions fail upon the first element in the compared arrays found not to -match. Failure messages specify the array index of the failed comparison. - -#### `TEST_ASSERT_EACH_EQUAL_INT (expected, actual, num_elements)` - -#### `TEST_ASSERT_EACH_EQUAL_INT8 (expected, actual, num_elements)` - -#### `TEST_ASSERT_EACH_EQUAL_INT16 (expected, actual, num_elements)` - -#### `TEST_ASSERT_EACH_EQUAL_INT32 (expected, actual, num_elements)` - -#### `TEST_ASSERT_EACH_EQUAL_INT64 (expected, actual, num_elements)` - -#### `TEST_ASSERT_EACH_EQUAL_UINT (expected, actual, num_elements)` - -#### `TEST_ASSERT_EACH_EQUAL_UINT8 (expected, actual, num_elements)` - -#### `TEST_ASSERT_EACH_EQUAL_UINT16 (expected, actual, num_elements)` - -#### `TEST_ASSERT_EACH_EQUAL_UINT32 (expected, actual, num_elements)` - -#### `TEST_ASSERT_EACH_EQUAL_UINT64 (expected, actual, num_elements)` - -#### `TEST_ASSERT_EACH_EQUAL_HEX (expected, actual, num_elements)` - -#### `TEST_ASSERT_EACH_EQUAL_HEX8 (expected, actual, num_elements)` - -#### `TEST_ASSERT_EACH_EQUAL_HEX16 (expected, actual, num_elements)` - -#### `TEST_ASSERT_EACH_EQUAL_HEX32 (expected, actual, num_elements)` - -#### `TEST_ASSERT_EACH_EQUAL_HEX64 (expected, actual, num_elements)` - -#### `TEST_ASSERT_EACH_EQUAL_CHAR (expected, actual, num_elements)` - -#### `TEST_ASSERT_EACH_EQUAL_PTR (expected, actual, num_elements)` - -#### `TEST_ASSERT_EACH_EQUAL_STRING (expected, actual, num_elements)` - -#### `TEST_ASSERT_EACH_EQUAL_MEMORY (expected, actual, len, num_elements)` - -`len` is the memory in bytes to be compared at each array element. - -### Floating Point (If enabled) - -#### `TEST_ASSERT_FLOAT_WITHIN (delta, expected, actual)` - -Asserts that the `actual` value is within +/- `delta` of the `expected` value. -The nature of floating point representation is such that exact evaluations of -equality are not guaranteed. - -#### `TEST_ASSERT_FLOAT_NOT_WITHIN (delta, expected, actual)` - -Asserts that the `actual` value is NOT within +/- `delta` of the `expected` value. - -#### `TEST_ASSERT_EQUAL_FLOAT (expected, actual)` - -Asserts that the `actual` value is “close enough to be considered equal” to the -`expected` value. If you are curious about the details, refer to the Advanced -Asserting section for more details on this. Omitting a user-specified delta in a -floating point assertion is both a shorthand convenience and a requirement of -code generation conventions for CMock. - -#### `TEST_ASSERT_NOT_EQUAL_FLOAT (expected, actual)` - -Asserts that the `actual` value is NOT “close enough to be considered equal” to the -`expected` value. - -#### `TEST_ASSERT_FLOAT_ARRAY_WITHIN (delta, expected, actual, num_elements)` - -See Array assertion section for details. Note that individual array element -uses user-provided delta plus default comparison delta for checking -and is based on `TEST_ASSERT_FLOAT_WITHIN` comparison. - -#### `TEST_ASSERT_EQUAL_FLOAT_ARRAY (expected, actual, num_elements)` - -See Array assertion section for details. Note that individual array element -float comparisons are executed using `TEST_ASSERT_EQUAL_FLOAT`. That is, user -specified delta comparison values requires a custom-implemented floating point -array assertion. - -#### `TEST_ASSERT_LESS_THAN_FLOAT (threshold, actual)` - -Asserts that the `actual` parameter is less than `threshold` (exclusive). -For example, if the threshold value is 1.0f, the assertion will fail if it is -greater than 1.0f. - -#### `TEST_ASSERT_GREATER_THAN_FLOAT (threshold, actual)` - -Asserts that the `actual` parameter is greater than `threshold` (exclusive). -For example, if the threshold value is 1.0f, the assertion will fail if it is -less than 1.0f. - -#### `TEST_ASSERT_LESS_OR_EQUAL_FLOAT (threshold, actual)` - -Asserts that the `actual` parameter is less than or equal to `threshold`. -The rules for equality are the same as for `TEST_ASSERT_EQUAL_FLOAT`. - -#### `TEST_ASSERT_GREATER_OR_EQUAL_FLOAT (threshold, actual)` - -Asserts that the `actual` parameter is greater than `threshold`. -The rules for equality are the same as for `TEST_ASSERT_EQUAL_FLOAT`. - -#### `TEST_ASSERT_FLOAT_IS_INF (actual)` - -Asserts that `actual` parameter is equivalent to positive infinity floating -point representation. - -#### `TEST_ASSERT_FLOAT_IS_NEG_INF (actual)` - -Asserts that `actual` parameter is equivalent to negative infinity floating -point representation. - -#### `TEST_ASSERT_FLOAT_IS_NAN (actual)` - -Asserts that `actual` parameter is a Not A Number floating point representation. - -#### `TEST_ASSERT_FLOAT_IS_DETERMINATE (actual)` - -Asserts that `actual` parameter is a floating point representation usable for -mathematical operations. That is, the `actual` parameter is neither positive -infinity nor negative infinity nor Not A Number floating point representations. - -#### `TEST_ASSERT_FLOAT_IS_NOT_INF (actual)` - -Asserts that `actual` parameter is a value other than positive infinity floating -point representation. - -#### `TEST_ASSERT_FLOAT_IS_NOT_NEG_INF (actual)` - -Asserts that `actual` parameter is a value other than negative infinity floating -point representation. - -#### `TEST_ASSERT_FLOAT_IS_NOT_NAN (actual)` - -Asserts that `actual` parameter is a value other than Not A Number floating -point representation. - -#### `TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE (actual)` - -Asserts that `actual` parameter is not usable for mathematical operations. That -is, the `actual` parameter is either positive infinity or negative infinity or -Not A Number floating point representations. - -### Double (If enabled) - -#### `TEST_ASSERT_DOUBLE_WITHIN (delta, expected, actual)` - -Asserts that the `actual` value is within +/- `delta` of the `expected` value. -The nature of floating point representation is such that exact evaluations of -equality are not guaranteed. - -#### `TEST_ASSERT_DOUBLE_NOT_WITHIN (delta, expected, actual)` - -Asserts that the `actual` value is NOT within +/- `delta` of the `expected` value. - -#### `TEST_ASSERT_EQUAL_DOUBLE (expected, actual)` - -Asserts that the `actual` value is “close enough to be considered equal” to the -`expected` value. If you are curious about the details, refer to the Advanced -Asserting section for more details. Omitting a user-specified delta in a -floating point assertion is both a shorthand convenience and a requirement of -code generation conventions for CMock. - -#### `TEST_ASSERT_NOT_EQUAL_DOUBLE (expected, actual)` - -Asserts that the `actual` value is NOT “close enough to be considered equal” to the -`expected` value. - -#### `TEST_ASSERT_DOUBLE_ARRAY_WITHIN (delta, expected, actual, num_elements)` - -See Array assertion section for details. Note that individual array element -uses user-provided delta plus default comparison delta for checking -and is based on `TEST_ASSERT_DOUBLE_WITHIN` comparison. - -#### `TEST_ASSERT_EQUAL_DOUBLE_ARRAY (expected, actual, num_elements)` - -See Array assertion section for details. Note that individual array element -double comparisons are executed using `TEST_ASSERT_EQUAL_DOUBLE`. That is, user -specified delta comparison values requires a custom implemented double array -assertion. - -#### `TEST_ASSERT_LESS_THAN_DOUBLE (threshold, actual)` - -Asserts that the `actual` parameter is less than `threshold` (exclusive). -For example, if the threshold value is 1.0, the assertion will fail if it is -greater than 1.0. - -#### `TEST_ASSERT_LESS_OR_EQUAL_DOUBLE (threshold, actual)` - -Asserts that the `actual` parameter is less than or equal to `threshold`. -The rules for equality are the same as for `TEST_ASSERT_EQUAL_DOUBLE`. - -#### `TEST_ASSERT_GREATER_THAN_DOUBLE (threshold, actual)` - -Asserts that the `actual` parameter is greater than `threshold` (exclusive). -For example, if the threshold value is 1.0, the assertion will fail if it is -less than 1.0. - -#### `TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE (threshold, actual)` - -Asserts that the `actual` parameter is greater than or equal to `threshold`. -The rules for equality are the same as for `TEST_ASSERT_EQUAL_DOUBLE`. - -#### `TEST_ASSERT_DOUBLE_IS_INF (actual)` - -Asserts that `actual` parameter is equivalent to positive infinity floating -point representation. - -#### `TEST_ASSERT_DOUBLE_IS_NEG_INF (actual)` - -Asserts that `actual` parameter is equivalent to negative infinity floating point -representation. - -#### `TEST_ASSERT_DOUBLE_IS_NAN (actual)` - -Asserts that `actual` parameter is a Not A Number floating point representation. - -#### `TEST_ASSERT_DOUBLE_IS_DETERMINATE (actual)` - -Asserts that `actual` parameter is a floating point representation usable for -mathematical operations. That is, the `actual` parameter is neither positive -infinity nor negative infinity nor Not A Number floating point representations. - -#### `TEST_ASSERT_DOUBLE_IS_NOT_INF (actual)` - -Asserts that `actual` parameter is a value other than positive infinity floating -point representation. - -#### `TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF (actual)` - -Asserts that `actual` parameter is a value other than negative infinity floating -point representation. - -#### `TEST_ASSERT_DOUBLE_IS_NOT_NAN (actual)` - -Asserts that `actual` parameter is a value other than Not A Number floating -point representation. - -#### `TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE (actual)` - -Asserts that `actual` parameter is not usable for mathematical operations. That -is, the `actual` parameter is either positive infinity or negative infinity or -Not A Number floating point representations. - -## Advanced Asserting: Details On Tricky Assertions - -This section helps you understand how to deal with some of the trickier -assertion situations you may run into. It will give you a glimpse into some of -the under-the-hood details of Unity’s assertion mechanisms. If you’re one of -those people who likes to know what is going on in the background, read on. If -not, feel free to ignore the rest of this document until you need it. - -### How do the EQUAL assertions work for FLOAT and DOUBLE? - -As you may know, directly checking for equality between a pair of floats or a -pair of doubles is sloppy at best and an outright no-no at worst. Floating point -values can often be represented in multiple ways, particularly after a series of -operations on a value. Initializing a variable to the value of 2.0 is likely to -result in a floating point representation of 2 x 20,but a series of -mathematical operations might result in a representation of 8 x 2-2 -that also evaluates to a value of 2. At some point repeated operations cause -equality checks to fail. - -So Unity doesn’t do direct floating point comparisons for equality. Instead, it -checks if two floating point values are “really close.” If you leave Unity -running with defaults, “really close” means “within a significant bit or two.” -Under the hood, `TEST_ASSERT_EQUAL_FLOAT` is really `TEST_ASSERT_FLOAT_WITHIN` -with the `delta` parameter calculated on the fly. For single precision, delta is -the expected value multiplied by 0.00001, producing a very small proportional -range around the expected value. - -If you are expecting a value of 20,000.0 the delta is calculated to be 0.2. So -any value between 19,999.8 and 20,000.2 will satisfy the equality check. This -works out to be roughly a single bit of range for a single-precision number, and -that’s just about as tight a tolerance as you can reasonably get from a floating -point value. - -So what happens when it’s zero? Zero - even more than other floating point -values - can be represented many different ways. It doesn’t matter if you have -0x20 or 0x263. It’s still zero, right? Luckily, if you subtract these -values from each other, they will always produce a difference of zero, which -will still fall between 0 plus or minus a delta of 0. So it still works! - -Double precision floating point numbers use a much smaller multiplier, again -approximating a single bit of error. - -If you don’t like these ranges and you want to make your floating point equality -assertions less strict, you can change these multipliers to whatever you like by -defining UNITY_FLOAT_PRECISION and UNITY_DOUBLE_PRECISION. See Unity -documentation for more. - -### How do we deal with targets with non-standard int sizes? - -It’s “fun” that C is a standard where something as fundamental as an integer -varies by target. According to the C standard, an `int` is to be the target’s -natural register size, and it should be at least 16-bits and a multiple of a -byte. It also guarantees an order of sizes: - -```C -char <= short <= int <= long <= long long -``` - -Most often, `int` is 32-bits. In many cases in the embedded world, `int` is -16-bits. There are rare microcontrollers out there that have 24-bit integers, -and this remains perfectly standard C. - -To make things even more interesting, there are compilers and targets out there -that have a hard choice to make. What if their natural register size is 10-bits -or 12-bits? Clearly they can’t fulfill _both_ the requirement to be at least -16-bits AND the requirement to match the natural register size. In these -situations, they often choose the natural register size, leaving us with -something like this: - -```C -char (8 bit) <= short (12 bit) <= int (12 bit) <= long (16 bit) -``` - -Um… yikes. It’s obviously breaking a rule or two… but they had to break SOME -rules, so they made a choice. - -When the C99 standard rolled around, it introduced alternate standard-size types. -It also introduced macros for pulling in MIN/MAX values for your integer types. -It’s glorious! Unfortunately, many embedded compilers can’t be relied upon to -use the C99 types (Sometimes because they have weird register sizes as described -above. Sometimes because they don’t feel like it?). - -A goal of Unity from the beginning was to support every combination of -microcontroller or microprocessor and C compiler. Over time, we’ve gotten really -close to this. There are a few tricks that you should be aware of, though, if -you’re going to do this effectively on some of these more idiosyncratic targets. - -First, when setting up Unity for a new target, you’re going to want to pay -special attention to the macros for automatically detecting types -(where available) or manually configuring them yourself. You can get information -on both of these in Unity’s documentation. - -What about the times where you suddenly need to deal with something odd, like a -24-bit `int`? The simplest solution is to use the next size up. If you have a -24-bit `int`, configure Unity to use 32-bit integers. If you have a 12-bit -`int`, configure Unity to use 16 bits. There are two ways this is going to -affect you: - -1. When Unity displays errors for you, it’s going to pad the upper unused bits - with zeros. -2. You’re going to have to be careful of assertions that perform signed - operations, particularly `TEST_ASSERT_INT_WITHIN`. Such assertions might wrap - your `int` in the wrong place, and you could experience false failures. You can - always back down to a simple `TEST_ASSERT` and do the operations yourself. - -*Find The Latest of This And More at [ThrowTheSwitch.org][]* - -[assert() macro]: http://en.wikipedia.org/wiki/Assert.h -[ThrowTheSwitch.org]: https://throwtheswitch.org diff --git a/subprojects/unity/docs/UnityChangeLog.md b/subprojects/unity/docs/UnityChangeLog.md deleted file mode 100644 index a9fec00f92..0000000000 --- a/subprojects/unity/docs/UnityChangeLog.md +++ /dev/null @@ -1,110 +0,0 @@ -# Unity Test - Change Log - -## A Note - -This document captures significant features and fixes to the Unity project core source files -and scripts. More detail can be found in the history on Github. - -This project is now tracking changes in more detail. Previous releases get less detailed as -we move back in histroy. - -Prior to 2012, the project was hosted on SourceForge.net -Prior to 2008, the project was an internal project and not released to the public. - -## Log - -### Unity 2.6.1 (Jan 2025) - -New Features: - - - Add `-n` comand line option as strict matcher again - -Significant Bugfixes: - - - Protect against problems when mis-matched command line options selected - -Other: - - - Protect against Conversion warnings in gcc - - Remove Redundant line-casts - - Make more internal functions static - -### Unity 2.6.0 (Mar 2024) - -New Features: - - - Fill out missing variations of arrays, within, etc. - - Add `TEST_PRINTF()` - - Add `TEST_MATRIX()` and `TEST_RANGE()` options and documentation - - Add support for searching `TEST_SOURCE_FILE()` for determining test dependencies - - Add Unity BDD plugin - - Add `UNITY_INCLUDE_EXEC_TIME` option to report test times - - Allow user to override test abort underlying mechanism - - Add `NOT_EQUAL*` and `NOT_WITHIN*` checks for floats and doubles - -Significant Bugfixes: - - - More portable validation of NaN and Infinity. Added `UNITY_IS_NAN` and `UNITY_IS_INF` options - - Add `UNITY_PROGMEM` configuration option - - Fix overflow detection of hex values when using arrays - - Fix scripts broken by Ruby standard changes - -Other: - - - Avoid pointer comparison when one is null to avoid compiler warnings - - Significant improvements to documentation - - Updates to match latest Ruby style specification - - Meson, CMake, PlatformIO builds - -### Unity 2.5.2 (January 2021) - - - improvements to RUN_TEST macro and generated RUN_TEST - - Fix `UNITY_TEST_ASSERT_BIT(S)_HIGH` - - Cleaner handling of details tracking by CMock - -### Unity 2.5.1 (May 2020) - -Mostly a bugfix and stability release. -Bonus Features: - - - Optional TEST_PRINTF macro - - Improve self-testing procedures. - -### Unity 2.5.0 (October 2019) - -It's been a LONG time since the last release of Unity. Finally, here it is! -There are too many updates to list here, so some highlights: - - - more standards compliant (without giving up on supporting ALL compilers, no matter how quirky) - - many more specialized assertions for better test feedback - - more examples for integrating into your world - - many many bugfixes and tweaks - -### Unity 2.4.3 (November 2017) - - - Allow suiteSetUp() and suiteTearDown() to be povided as normal C functions - - Fix & Expand Greater Than / Less Than assertions for integers - - Built-in option to colorize test results - - Documentation updates - -### Unity 2.4.2 (September 2017) - - - Fixed bug in UNTY_TEST_ASSERT_EACH_EQUAL_* - - Added TEST_ASSERT_GREATER_THAN and TEST_ASSERT_LESS_THAN - - Updated Module Generator to stop changing names when no style given - - Cleanup to custom float printing for accuracy - - Cleanup incorrect line numbers are partial name matching - - Reduce warnings from using popular function names as variable names - -### Unity 2.4.1 (April 2017) - - - test runner generator can inject defines as well as headers - - added a built-in floating point print routine instead of relying on printf - - updated to new coding and naming standard - - updated documentation to be markdown instead of pdf - - fixed many many little bugs, most of which were supplied by the community (you people are awesome!) - - coding standard actually enforced in CI - -### Unity 2.4.0 (October, 2016) - - - port from SourceForge and numerous bugfixes diff --git a/subprojects/unity/docs/UnityConfigurationGuide.md b/subprojects/unity/docs/UnityConfigurationGuide.md deleted file mode 100644 index 0b735f7ae1..0000000000 --- a/subprojects/unity/docs/UnityConfigurationGuide.md +++ /dev/null @@ -1,654 +0,0 @@ -# Unity Configuration Guide - -## C Standards, Compilers and Microcontrollers - -The embedded software world contains its challenges. -Compilers support different revisions of the C Standard. -They ignore requirements in places, sometimes to make the language more usable in some special regard. -Sometimes it's to simplify their support. -Sometimes it's due to specific quirks of the microcontroller they are targeting. -Simulators add another dimension to this menagerie. - -Unity is designed to run on almost anything that is targeted by a C compiler. -It would be awesome if this could be done with zero configuration. -While there are some targets that come close to this dream, it is sadly not universal. -It is likely that you are going to need at least a couple of the configuration options described in this document. - -All of Unity's configuration options are `#defines`. -Most of these are simple definitions. -A couple are macros with arguments. -They live inside the unity_internals.h header file. -We don't necessarily recommend opening that file unless you really need to. -That file is proof that a cross-platform library is challenging to build. -From a more positive perspective, it is also proof that a great deal of complexity can be centralized primarily to one place to provide a more consistent and simple experience elsewhere. - -### Using These Options - -It doesn't matter if you're using a target-specific compiler and a simulator or a native compiler. -In either case, you've got a couple choices for configuring these options: - -1. Because these options are specified via C defines, you can pass most of these options to your compiler through command line compiler flags. Even if you're using an embedded target that forces you to use their overbearing IDE for all configuration, there will be a place somewhere in your project to configure defines for your compiler. -2. You can create a custom `unity_config.h` configuration file (present in your toolchain's search paths). - In this file, you will list definitions and macros specific to your target. All you must do is define `UNITY_INCLUDE_CONFIG_H` and Unity will rely on `unity_config.h` for any further definitions it may need. - -Unfortunately, it doesn't usually work well to just #define these things in the test itself. -These defines need to take effect where ever unity.h is included. -This would be test test, the test runner (if you're generating one), and from unity.c when it's compiled. - -## The Options - -### Integer Types - -If you've been a C developer for long, you probably already know that C's concept of an integer varies from target to target. -The C Standard has rules about the `int` matching the register size of the target microprocessor. -It has rules about the `int` and how its size relates to other integer types. -An `int` on one target might be 16 bits while on another target it might be 64. -There are more specific types in compilers compliant with C99 or later, but that's certainly not every compiler you are likely to encounter. -Therefore, Unity has a number of features for helping to adjust itself to match your required integer sizes. -It starts off by trying to do it automatically. - -#### `UNITY_EXCLUDE_STDINT_H` - -The first thing that Unity does to guess your types is check `stdint.h`. -This file includes defines like `UINT_MAX` that Unity can use to learn a lot about your system. -It's possible you don't want it to do this (um. why not?) or (more likely) it's possible that your system doesn't support `stdint.h`. -If that's the case, you're going to want to define this. -That way, Unity will know to skip the inclusion of this file and you won't be left with a compiler error. - -_Example:_ - -```C -#define UNITY_EXCLUDE_STDINT_H -``` - -#### `UNITY_EXCLUDE_LIMITS_H` - -The second attempt to guess your types is to check `limits.h`. -Some compilers that don't support `stdint.h` could include `limits.h` instead. -If you don't want Unity to check this file either, define this to make it skip the inclusion. - -_Example:_ - -```C -#define UNITY_EXCLUDE_LIMITS_H -``` - -If you've disabled both of the automatic options above, you're going to have to do the configuration yourself. -Don't worry. -Even this isn't too bad... there are just a handful of defines that you are going to specify if you don't like the defaults. - -#### `UNITY_INT_WIDTH` - -Define this to be the number of bits an `int` takes up on your system. -The default, if not autodetected, is 32 bits. - -_Example:_ - -```C -#define UNITY_INT_WIDTH 16 -``` - -#### `UNITY_LONG_WIDTH` - -Define this to be the number of bits a `long` takes up on your system. -The default, if not autodetected, is 32 bits. -This is used to figure out what kind of 64-bit support your system can handle. -Does it need to specify a `long` or a `long long` to get a 64-bit value. -On 16-bit systems, this option is going to be ignored. - -_Example:_ - -```C -#define UNITY_LONG_WIDTH 16 -``` - -#### `UNITY_POINTER_WIDTH` - -Define this to be the number of bits a pointer takes up on your system. -The default, if not autodetected, is 32-bits. -If you're getting ugly compiler warnings about casting from pointers, this is the one to look at. - -_Hint:_ In order to support exotic processors (for example TI C55x with a pointer width of 23-bit), choose the next power of two (in this case 32-bit). - -_Supported values:_ 16, 32 and 64 - -_Example:_ - -```C -// Choose on of these #defines to set your pointer width (if not autodetected) -//#define UNITY_POINTER_WIDTH 16 -//#define UNITY_POINTER_WIDTH 32 -#define UNITY_POINTER_WIDTH 64 // Set UNITY_POINTER_WIDTH to 64-bit -``` - -#### `UNITY_COMPARE_PTRS_ON_ZERO_ARRAY` - -Define this to make all array assertions compare pointers instead of contents when a length of zero is specified. When not enabled, -defining a length of zero will always result in a failure and a message warning the user that they have tried to compare empty -arrays. - -#### `UNITY_SUPPORT_64` - -Unity will automatically include 64-bit support if it auto-detects it, or if your `int`, `long`, or pointer widths are greater than 32-bits. -Define this to enable 64-bit support if none of the other options already did it for you. -There can be a significant size and speed impact to enabling 64-bit support on small targets, so don't define it if you don't need it. - -_Example:_ - -```C -#define UNITY_SUPPORT_64 -``` - -### Floating Point Types - -In the embedded world, it's not uncommon for targets to have no support for floating point operations at all or to have support that is limited to only single precision. -We are able to guess integer sizes on the fly because integers are always available in at least one size. -Floating point, on the other hand, is sometimes not available at all. -Trying to include `float.h` on these platforms would result in an error. This leaves manual configuration as the only option. - -#### `UNITY_INCLUDE_FLOAT` - -#### `UNITY_EXCLUDE_FLOAT` - -#### `UNITY_INCLUDE_DOUBLE` - -#### `UNITY_EXCLUDE_DOUBLE` - -By default, Unity guesses that you will want single precision floating point support, but not double precision. -It's easy to change either of these using the include and exclude options here. -You may include neither, either, or both, as suits your needs. -For features that are enabled, the following floating point options also become available. - -_Example:_ - -```C -//what manner of strange processor is this? -#define UNITY_EXCLUDE_FLOAT -#define UNITY_INCLUDE_DOUBLE -``` - -#### `UNITY_EXCLUDE_FLOAT_PRINT` - -Unity aims for as small of a footprint as possible and avoids most standard library calls (some embedded platforms don’t have a standard library!). -Because of this, its routines for printing integer values are minimalist and hand-coded. -Therefore, the display of floating point values during a failure are optional. -By default, Unity will print the actual results of floating point assertion failure (e.g. ”Expected 4.56 Was 4.68”). -To not include this extra support, you can use this define to instead respond to a failed assertion with a message like ”Values Not Within Delta”. -If you would like verbose failure messages for floating point assertions, use these options to give more explicit failure messages. - -_Example:_ - -```C -#define UNITY_EXCLUDE_FLOAT_PRINT -``` - -#### `UNITY_FLOAT_TYPE` - -If enabled, Unity assumes you want your `FLOAT` asserts to compare standard C floats. -If your compiler supports a specialty floating point type, you can always override this behavior by using this definition. - -_Example:_ - -```C -#define UNITY_FLOAT_TYPE float16_t -``` - -#### `UNITY_DOUBLE_TYPE` - -If enabled, Unity assumes you want your `DOUBLE` asserts to compare standard C doubles. -If you would like to change this, you can specify something else by using this option. -For example, defining `UNITY_DOUBLE_TYPE` to `long double` could enable gargantuan floating point types on your 64-bit processor instead of the standard `double`. - -_Example:_ - -```C -#define UNITY_DOUBLE_TYPE long double -``` - -#### `UNITY_FLOAT_PRECISION` - -#### `UNITY_DOUBLE_PRECISION` - -If you look up `UNITY_ASSERT_EQUAL_FLOAT` and `UNITY_ASSERT_EQUAL_DOUBLE` as documented in the big daddy Unity Assertion Guide, you will learn that they are not really asserting that two values are equal but rather that two values are "close enough" to equal. -"Close enough" is controlled by these precision configuration options. -If you are working with 32-bit floats and/or 64-bit doubles (the normal on most processors), you should have no need to change these options. -They are both set to give you approximately 1 significant bit in either direction. -The float precision is 0.00001 while the double is 10-12. -For further details on how this works, see the appendix of the Unity Assertion Guide. - -_Example:_ - -```C -#define UNITY_FLOAT_PRECISION 0.001f -``` - -#### `UNITY_IS_NAN` and `UNITY_IS_INF` - -If your toolchain defines `isnan` and `isinf` in `math.h` as macros, nothing needs to be done. If your toolchain doesn't define these, Unity -will create these macros itself. You may override either or both of these defines to specify how you want to evaluate if a number is NaN or Infinity. - -_Example:_ - -```C -#define UNITY_IS_NAN(n) ((n != n) ? 1 : 0) -``` - -### Miscellaneous - -#### `UNITY_EXCLUDE_STDDEF_H` - -Unity uses the `NULL` macro, which defines the value of a null pointer constant, defined in `stddef.h` by default. -If you want to provide your own macro for this, you should exclude the `stddef.h` header file by adding this define to your configuration. - -_Example:_ - -```C -#define UNITY_EXCLUDE_STDDEF_H -``` - -#### `UNITY_INCLUDE_PRINT_FORMATTED` - -Unity provides a simple (and very basic) printf-like string output implementation, which is able to print a string modified by the following format string modifiers: - -- __%d__ - signed value (decimal) -- __%i__ - same as __%d__ -- __%u__ - unsigned value (decimal) -- __%f__ - float/Double (if float support is activated) -- __%g__ - same as __%f__ -- __%b__ - binary prefixed with "0b" -- __%x__ - hexadecimal (upper case) prefixed with "0x" -- __%X__ - same as __%x__ -- __%p__ - pointer (same as __%x__ or __%X__) -- __%c__ - a single character -- __%s__ - a string (e.g. "string") -- __%%__ - The "%" symbol (escaped) - -Length specifiers are also supported. If you are using long long types, make sure UNITY_SUPPORT_64 is true to ensure they are printed correctly. - -- __%ld__ - signed long value (decimal) -- __%lld__ - signed long long value (decimal) -- __%lu__ - unsigned long value (decimal) -- __%llu__ - unsigned long long value (decimal) -- __%lx__ - unsigned long value (hexadecimal) -- __%llx__ - unsigned long long value (hexadecimal) - -_Example:_ - -```C -#define UNITY_INCLUDE_PRINT_FORMATTED - -int a = 0xfab1; -TEST_PRINTF("Decimal %d\n", -7); -TEST_PRINTF("Unsigned %u\n", 987); -TEST_PRINTF("Float %f\n", 3.1415926535897932384); -TEST_PRINTF("Binary %b\n", 0xA); -TEST_PRINTF("Hex %X\n", 0xFAB); -TEST_PRINTF("Pointer %p\n", &a); -TEST_PRINTF("Character %c\n", 'F'); -TEST_PRINTF("String %s\n", "My string"); -TEST_PRINTF("Percent %%\n"); -TEST_PRINTF("Unsigned long long %llu\n", 922337203685477580); -TEST_PRINTF("Color Red \033[41mFAIL\033[0m\n"); -TEST_PRINTF("\n"); -TEST_PRINTF("Multiple (%d) (%i) (%u) (%x)\n", -100, 0, 200, 0x12345); -``` - -### Toolset Customization - -In addition to the options listed above, there are a number of other options which will come in handy to customize Unity's behavior for your specific toolchain. -It is possible that you may not need to touch any of these... but certain platforms, particularly those running in simulators, may need to jump through extra hoops to run properly. -These macros will help in those situations. - -#### `UNITY_OUTPUT_CHAR(a)` - -#### `UNITY_OUTPUT_FLUSH()` - -#### `UNITY_OUTPUT_START()` - -#### `UNITY_OUTPUT_COMPLETE()` - -By default, Unity prints its results to `stdout` as it runs. -This works perfectly fine in most situations where you are using a native compiler for testing. -It works on some simulators as well so long as they have `stdout` routed back to the command line. -There are times, however, where the simulator will lack support for dumping results or you will want to route results elsewhere for other reasons. -In these cases, you should define the `UNITY_OUTPUT_CHAR` macro. -This macro accepts a single character at a time (as an `int`, since this is the parameter type of the standard C `putchar` function most commonly used). -You may replace this with whatever function call you like. - -_Example:_ -Say you are forced to run your test suite on an embedded processor with no `stdout` option. -You decide to route your test result output to a custom serial `RS232_putc()` function you wrote like thus: - -```C -#include "RS232_header.h" -... -#define UNITY_OUTPUT_CHAR(a) RS232_putc(a) -#define UNITY_OUTPUT_START() RS232_config(115200,1,8,0) -#define UNITY_OUTPUT_FLUSH() RS232_flush() -#define UNITY_OUTPUT_COMPLETE() RS232_close() -``` - -_Note:_ -`UNITY_OUTPUT_FLUSH()` can be set to the standard out flush function simply by specifying `UNITY_USE_FLUSH_STDOUT`. -No other defines are required. - -#### `UNITY_OUTPUT_FOR_ECLIPSE` - -#### `UNITY_OUTPUT_FOR_IAR_WORKBENCH` - -#### `UNITY_OUTPUT_FOR_QT_CREATOR` - -When managing your own builds, it is often handy to have messages output in a format which is recognized by your IDE. -These are some standard formats which can be supported. -If you're using Ceedling to manage your builds, it is better to stick with the standard format (leaving these all undefined) and allow Ceedling to use its own decorators. - -#### `UNITY_PTR_ATTRIBUTE` - -Some compilers require a custom attribute to be assigned to pointers, like `near` or `far`. -In these cases, you can give Unity a safe default for these by defining this option with the attribute you would like. - -_Example:_ - -```C -#define UNITY_PTR_ATTRIBUTE __attribute__((far)) -#define UNITY_PTR_ATTRIBUTE near -``` - -#### `UNITY_PRINT_EOL` - -By default, Unity outputs \n at the end of each line of output. -This is easy to parse by the scripts, by Ceedling, etc, but it might not be ideal for YOUR system. -Feel free to override this and to make it whatever you wish. - -_Example:_ - -```C -#define UNITY_PRINT_EOL { UNITY_OUTPUT_CHAR('\r'); UNITY_OUTPUT_CHAR('\n'); } -``` - -#### `UNITY_EXCLUDE_DETAILS` - -This is an option for if you absolutely must squeeze every byte of memory out of your system. -Unity stores a set of internal scratchpads which are used to pass extra detail information around. -It's used by systems like CMock in order to report which function or argument flagged an error. -If you're not using CMock and you're not using these details for other things, then you can exclude them. - -_Example:_ - -```C -#define UNITY_EXCLUDE_DETAILS -``` - -#### `UNITY_PRINT_TEST_CONTEXT` - -This option allows you to specify your own function to print additional context as part of the error message when a test has failed. -It can be useful if you want to output some specific information about the state of the test at the point of failure, and `UNITY_SET_DETAILS` isn't flexible enough for your needs. - -_Example:_ - -```C -#define UNITY_PRINT_TEST_CONTEXT PrintIterationCount - -extern int iteration_count; - -void PrintIterationCount(void) -{ - UnityPrintFormatted("At iteration #%d: ", iteration_count); -} -``` - -#### `UNITY_EXCLUDE_SETJMP` - -If your embedded system doesn't support the standard library setjmp, you can exclude Unity's reliance on this by using this define. -This dropped dependence comes at a price, though. -You will be unable to use custom helper functions for your tests, and you will be unable to use tools like CMock. -Very likely, if your compiler doesn't support setjmp, you wouldn't have had the memory space for those things anyway, though... so this option exists for those situations. - -_Example:_ - -```C -#define UNITY_EXCLUDE_SETJMP -``` - -#### `UNITY_TEST_PROTECT` - -#### `UNITY_TEST_ABORT` - -Unity handles test failures via `setjmp`/`longjmp` pair by default. As mentioned above, you can disable this with `UNITY_EXCLUDE_SETJMP`. You can also customise what happens on every `TEST_PROTECT` and `TEST_ABORT` call. This can be accomplished by providing user-defined `UNITY_TEST_PROTECT` and `UNITY_TEST_ABORT` macros (and these may be defined independently). - -`UNITY_TEST_PROTECT` is used as an `if` statement expression, and has to evaluate to `true` on the first call (when saving stack environment with `setjmp`), and to `false` when it returns as a result of a `TEST_ABORT` (when restoring the stack environment with `longjmp`). - -Whenever an assert macro fails, `TEST_ABORT` is used to restore the stack environment previously set by `TEST_PROTECT`. This part may be overriden with `UNITY_TEST_ABORT`, e.g. if custom failure handling is needed. - -_Example 1:_ - -Calling `longjmp` on your target is possible, but has a platform-specific (or implementation-specific) set of prerequisites, e.g. privileged access level. You can extend the default behaviour of `TEST_PROTECT` and `TEST_ABORT` as: - -`unity_config.h`: - -```C -#include "my_custom_test_handlers.h" - -#define UNITY_TEST_PROTECT() custom_test_protect() -#define UNITY_TEST_ABORT() custom_test_abort() -``` - -`my_custom_test_handlers.c`: - -```C -int custom_test_protect(void) { - platform_specific_code(); - return setjmp(Unity.AbortFrame) == 0; -} - -UNITY_NORETURN void custom_test_abort(void) { - more_platform_specific_code(); - longjmp(Unity.AbortFrame, 1); -} -``` - -_Example 2:_ - -Unity is used to provide the assertion macros only, and an external test harness/runner is used for test orchestration/reporting. In this case you can easily plug your code by overriding `TEST_ABORT` as: - -`unity_config.h`: - -```C -#include "my_custom_test_handlers.h" - -#define UNITY_TEST_PROTECT() 1 -#define UNITY_TEST_ABORT() custom_test_abort() -``` - -`my_custom_test_handlers.c`: - -```C -void custom_test_abort(void) { - if (Unity.CurrentTestFailed == 1) { - custom_failed_test_handler(); - } else if (Unity.CurrentTestIgnored == 1) { - custom_ignored_test_handler(); - } -} -``` - -#### `UNITY_OUTPUT_COLOR` - -If you want to add color using ANSI escape codes you can use this define. - -_Example:_ - -```C -#define UNITY_OUTPUT_COLOR -``` - -#### `UNITY_INCLUDE_EXEC_TIME` - -Define this to measure and report execution time for each test in the suite. When enabled, Unity will do -it's best to automatically find a way to determine the time in milliseconds. On most Windows, macos, or -Linux environments, this is automatic. If not, you can give Unity more information. - -#### `UNITY_CLOCK_MS` - -If you're working on a system (embedded or otherwise) which has an accessible millisecond timer. You can -define `UNITY_CLOCK_MS` to be the name of the function which returns the millisecond timer. It will then -attempt to use that function for timing purposes. - -#### `UNITY_EXEC_TIME_START` - -Define this hook to start a millisecond timer if necessary. - -#### `UNITY_EXEC_TIME_STOP` - -Define this hook to stop a millisecond timer if necessary. - -#### `UNITY_PRINT_EXEC_TIME` - -Define this hook to print the current execution time. Used to report the milliseconds elapsed. - -#### `UNITY_TIME_TYPE` - -Finally, this can be set to the type which holds the millisecond timer. - -#### `UNITY_SHORTHAND_AS_INT` - -#### `UNITY_SHORTHAND_AS_MEM` - -#### `UNITY_SHORTHAND_AS_RAW` - -#### `UNITY_SHORTHAND_AS_NONE` - -These options give you control of the `TEST_ASSERT_EQUAL` and the `TEST_ASSERT_NOT_EQUAL` shorthand assertions. -Historically, Unity treated the former as an alias for an integer comparison. -It treated the latter as a direct comparison using `!=`. -This asymmetry was confusing, but there was much disagreement as to how best to treat this pair of assertions. -These four options will allow you to specify how Unity will treat these assertions. - -- AS INT - the values will be cast to integers and directly compared. - Arguments that don't cast easily to integers will cause compiler errors. -- AS MEM - the address of both values will be taken and the entire object's memory footprint will be compared byte by byte. - Directly placing constant numbers like `456` as expected values will cause errors. -- AS_RAW - Unity assumes that you can compare the two values using `==` and `!=` and will do so. - No details are given about mismatches, because it doesn't really know what type it's dealing with. -- AS_NONE - Unity will disallow the use of these shorthand macros altogether, insisting that developers choose a more descriptive option. - -#### `UNITY_SUPPORT_VARIADIC_MACROS` - -This will force Unity to support variadic macros when using its own built-in RUN_TEST macro. -This will rarely be necessary. Most often, Unity will automatically detect if the compiler supports variadic macros by checking to see if it's C99+ compatible. -In the event that the compiler supports variadic macros, but is primarily C89 (ANSI), defining this option will allow you to use them. -This option is also not necessary when using Ceedling or the test runner generator script. - -#### `UNITY_SUPPORT_TEST_CASES` - -Unity can automatically define all supported parameterized tests macros. -That feature is disabled by default. -To enable it, use the following example: - -```C -#define UNITY_SUPPORT_TEST_CASES -``` - -You can manually provide required `TEST_CASE`, `TEST_RANGE` or `TEST_MATRIX` macro definitions -before including `unity.h`, and they won't be redefined. -If you provide one of the following macros, some of default definitions will not be -defined: -| User defines macro | Unity will _not_ define following macro | -|---|---| -| `UNITY_EXCLUDE_TEST_CASE` | `TEST_CASE` | -| `UNITY_EXCLUDE_TEST_RANGE` | `TEST_RANGE` | -| `UNITY_EXCLUDE_TEST_MATRIX` | `TEST_MATRIX` | -| `TEST_CASE` | `TEST_CASE` | -| `TEST_RANGE` | `TEST_RANGE` | -| `TEST_MATRIX` | `TEST_MATRIX` | - -`UNITY_EXCLUDE_TEST_*` defines is not processed by test runner generator script. -If you exclude one of them from definition, you should provide your own definition -for them or avoid using undefined `TEST_*` macro as a test generator. -Otherwise, compiler cannot build source code file with provided call. - -_Note:_ -That feature requires variadic macro support by compiler. If required feature -is not detected, it will not be enabled, even though preprocessor macro is defined. - -## Getting Into The Guts - -There will be cases where the options above aren't quite going to get everything perfect. -They are likely sufficient for any situation where you are compiling and executing your tests with a native toolchain (e.g. clang on Mac). -These options may even get you through the majority of cases encountered in working with a target simulator run from your local command line. -But especially if you must run your test suite on your target hardware, your Unity configuration will -require special help. -This special help will usually reside in one of two places: the `main()` function or the `RUN_TEST` macro. -Let's look at how these work. - -### `main()` - -Each test module is compiled and run on its own, separate from the other test files in your project. -Each test file, therefore, has a `main` function. -This `main` function will need to contain whatever code is necessary to initialize your system to a workable state. -This is particularly true for situations where you must set up a memory map or initialize a communication channel for the output of your test results. - -A simple main function looks something like this: - -```C -int main(void) { - UNITY_BEGIN(); - RUN_TEST(test_TheFirst); - RUN_TEST(test_TheSecond); - RUN_TEST(test_TheThird); - return UNITY_END(); -} -``` - -You can see that our main function doesn't bother taking any arguments. -For our most barebones case, we'll never have arguments because we just run all the tests each time. -Instead, we start by calling `UNITY_BEGIN`. -We run each test (in whatever order we wish). -Finally, we call `UNITY_END`, returning its return value (which is the total number of failures). - -It should be easy to see that you can add code before any test cases are run or after all the test cases have completed. -This allows you to do any needed system-wide setup or teardown that might be required for your special circumstances. - -#### `RUN_TEST` - -The `RUN_TEST` macro is called with each test case function. -Its job is to perform whatever setup and teardown is necessary for executing a single test case function. -This includes catching failures, calling the test module's `setUp()` and `tearDown()` functions, and calling `UnityConcludeTest()`. -If using CMock or test coverage, there will be additional stubs in use here. -A simple minimalist RUN_TEST macro looks something like this: - -```C -#define RUN_TEST(testfunc) \ - UNITY_NEW_TEST(#testfunc) \ - if (TEST_PROTECT()) { \ - setUp(); \ - testfunc(); \ - } \ - if (TEST_PROTECT() && (!TEST_IS_IGNORED)) \ - tearDown(); \ - UnityConcludeTest(); -``` - -So that's quite a macro, huh? -It gives you a glimpse of what kind of stuff Unity has to deal with for every single test case. -For each test case, we declare that it is a new test. -Then we run `setUp` and our test function. -These are run within a `TEST_PROTECT` block, the function of which is to handle failures that occur during the test. -Then, assuming our test is still running and hasn't been ignored, we run `tearDown`. -No matter what, our last step is to conclude this test before moving on to the next. - -Let's say you need to add a call to `fsync` to force all of your output data to flush to a file after each test. -You could easily insert this after your `UnityConcludeTest` call. -Maybe you want to write an xml tag before and after each result set. -Again, you could do this by adding lines to this macro. -Updates to this macro are for the occasions when you need an action before or after every single test case throughout your entire suite of tests. - -## Happy Porting - -The defines and macros in this guide should help you port Unity to just about any C target we can imagine. -If you run into a snag or two, don't be afraid of asking for help on the forums. -We love a good challenge! - -*Find The Latest of This And More at [ThrowTheSwitch.org][]* - -[ThrowTheSwitch.org]: https://throwtheswitch.org diff --git a/subprojects/unity/docs/UnityGettingStartedGuide.md b/subprojects/unity/docs/UnityGettingStartedGuide.md deleted file mode 100644 index b951c60ce0..0000000000 --- a/subprojects/unity/docs/UnityGettingStartedGuide.md +++ /dev/null @@ -1,242 +0,0 @@ -# Unity - Getting Started - -## Welcome - -Congratulations. -You're now the proud owner of your very own pile of bits! -What are you going to do with all these ones and zeros? -This document should be able to help you decide just that. - -Unity is a unit test framework. -The goal has been to keep it small and functional. -The core Unity test framework is three files: a single C file and a couple header files. -These team up to provide functions and macros to make testing easier. - -Unity was designed to be cross-platform. -It works hard to stick with C standards while still providing support for the many embedded C compilers that bend the rules. -Unity has been used with many compilers, including GCC, IAR, Clang, Green Hills, Microchip, and MS Visual Studio. -It's not much work to get it to work with a new target. - -### Overview of the Documents - -#### Unity Assertions reference - -This document will guide you through all the assertion options provided by Unity. -This is going to be your unit testing bread and butter. -You'll spend more time with assertions than any other part of Unity. - -#### Unity Assertions Cheat Sheet - -This document contains an abridged summary of the assertions described in the previous document. -It's perfect for printing and referencing while you familiarize yourself with Unity's options. - -#### Unity Configuration Guide - -This document is the one to reference when you are going to use Unity with a new target or compiler. -It'll guide you through the configuration options and will help you customize your testing experience to meet your needs. - -#### Unity Helper Scripts - -This document describes the helper scripts that are available for simplifying your testing workflow. -It describes the collection of optional Ruby scripts included in the auto directory of your Unity installation. -Neither Ruby nor these scripts are necessary for using Unity. -They are provided as a convenience for those who wish to use them. - -#### Unity License - -What's an open source project without a license file? -This brief document describes the terms you're agreeing to when you use this software. -Basically, we want it to be useful to you in whatever context you want to use it, but please don't blame us if you run into problems. - -### Overview of the Folders - -If you have obtained Unity through Github or something similar, you might be surprised by just how much stuff you suddenly have staring you in the face. -Don't worry, Unity itself is very small. -The rest of it is just there to make your life easier. -You can ignore it or use it at your convenience. -Here's an overview of everything in the project. - -- `src` - This is the code you care about! This folder contains a C file and two header files. - These three files _are_ Unity. -- `docs` - You're reading this document, so it's possible you have found your way into this folder already. - This is where all the handy documentation can be found. -- `examples` - This contains a few examples of using Unity. -- `extras` - These are optional add ons to Unity that are not part of the core project. - If you've reached us through James Grenning's book, you're going to want to look here. -- `test` - This is how Unity and its scripts are all tested. - If you're just using Unity, you'll likely never need to go in here. - If you are the lucky team member who gets to port Unity to a new toolchain, this is a good place to verify everything is configured properly. -- `auto` - Here you will find helpful Ruby scripts for simplifying your test workflow. - They are purely optional and are not required to make use of Unity. - -## How to Create A Test File - -Test files are C files. -Most often you will create a single test file for each C module that you want to test. -The test file should include unity.h and the header for your C module to be tested. - -Next, a test file will include a `setUp()` and `tearDown()` function. -The setUp function can contain anything you would like to run before each test. -The tearDown function can contain anything you would like to run after each test. -Both functions accept no arguments and return nothing. -You may leave either or both of these blank if you have no need for them. - -If you're using Ceedling or the test runner generator script, you may leave these off completely. -Not sure? -Give it a try. -If your compiler complains that it can't find setUp or tearDown when it links, you'll know you need to at least include an empty function for these. - -The majority of the file will be a series of test functions. -Test functions follow the convention of starting with the word "test_" or "spec_". -You don't HAVE to name them this way, but it makes it clear what functions are tests for other developers. -Also, the automated scripts that come with Unity or Ceedling will default to looking for test functions to be prefixed this way. -Test functions take no arguments and return nothing. All test accounting is handled internally in Unity. - -Finally, at the bottom of your test file, you will write a `main()` function. -This function will call `UNITY_BEGIN()`, then `RUN_TEST` for each test, and finally `UNITY_END()`. -This is what will actually trigger each of those test functions to run, so it is important that each function gets its own `RUN_TEST` call. - -Remembering to add each test to the main function can get to be tedious. -If you enjoy using helper scripts in your build process, you might consider making use of our handy [generate_test_runner.rb][] script. -This will create the main function and all the calls for you, assuming that you have followed the suggested naming conventions. -In this case, there is no need for you to include the main function in your test file at all. - -When you're done, your test file will look something like this: - -```C -#include "unity.h" -#include "file_to_test.h" - -void setUp(void) { - // set stuff up here -} - -void tearDown(void) { - // clean stuff up here -} - -void test_function_should_doBlahAndBlah(void) { - //test stuff -} - -void test_function_should_doAlsoDoBlah(void) { - //more test stuff -} - -// not needed when using generate_test_runner.rb -int main(void) { - UNITY_BEGIN(); - RUN_TEST(test_function_should_doBlahAndBlah); - RUN_TEST(test_function_should_doAlsoDoBlah); - return UNITY_END(); -} -``` - -It's possible that you will need more customization than this, eventually. -For that sort of thing, you're going to want to look at the configuration guide. -This should be enough to get you going, though. - -### Running Test Functions - -When writing your own `main()` functions, for a test-runner. -There are two ways to execute the test. - -The classic variant - -``` c -RUN_TEST(func, linenum) -``` - -Or its simpler replacement that starts at the beginning of the function. - -``` c -RUN_TEST(func) -``` - -These macros perform the necessary setup before the test is called and handles clean-up and result tabulation afterwards. - -### Ignoring Test Functions - -There are times when a test is incomplete or not valid for some reason. -At these times, TEST_IGNORE can be called. -Control will immediately be returned to the caller of the test, and no failures will be returned. -This is useful when your test runners are automatically generated. - -``` c -TEST_IGNORE() -``` - -Ignore this test and return immediately - -```c -TEST_IGNORE_MESSAGE (message) -``` - -Ignore this test and return immediately. -Output a message stating why the test was ignored. - -### Aborting Tests - -There are times when a test will contain an infinite loop on error conditions, or there may be reason to escape from the test early without executing the rest of the test. -A pair of macros support this functionality in Unity. -The first `TEST_PROTECT` sets up the feature, and handles emergency abort cases. -`TEST_ABORT` can then be used at any time within the tests to return to the last `TEST_PROTECT` call. - -```c - TEST_PROTECT() -``` - -Setup and Catch macro - -```c - TEST_ABORT() -``` - -Abort Test macro - -Example: - -```c - main() - { - if (TEST_PROTECT()) - { - MyTest(); - } - } -``` - -If MyTest calls `TEST_ABORT`, program control will immediately return to `TEST_PROTECT` with a return value of zero. - -## How to Build and Run A Test File - -This is the single biggest challenge to picking up a new unit testing framework, at least in a language like C or C++. -These languages are REALLY good at getting you "close to the metal" (why is the phrase metal? Wouldn't it be more accurate to say "close to the silicon"?). -While this feature is usually a good thing, it can make testing more challenging. - -You have two really good options for toolchains. -Depending on where you're coming from, it might surprise you that neither of these options is running the unit tests on your hardware. -There are many reasons for this, but here's a short version: - -- On hardware, you have too many constraints (processing power, memory, etc), -- On hardware, you don't have complete control over all registers, -- On hardware, unit testing is more challenging, -- Unit testing isn't System testing. Keep them separate. - -Instead of running your tests on your actual hardware, most developers choose to develop them as native applications (using gcc or MSVC for example) or as applications running on a simulator. -Either is a good option. -Native apps have the advantages of being faster and easier to set up. -Simulator apps have the advantage of working with the same compiler as your target application. -The options for configuring these are discussed in the configuration guide. - -To get either to work, you might need to make a few changes to the file containing your register set (discussed later). - -In either case, a test is built by linking unity, the test file, and the C file(s) being tested. -These files create an executable which can be run as the test set for that module. -Then, this process is repeated for the next test file. -This flexibility of separating tests into individual executables allows us to much more thoroughly unit test our system and it keeps all the test code out of our final release! - -*Find The Latest of This And More at [ThrowTheSwitch.org][]* - -[generate_test_runner.rb]: ../auto/generate_test_runner.rb -[ThrowTheSwitch.org]: https://throwtheswitch.org diff --git a/subprojects/unity/docs/UnityHelperScriptsGuide.md b/subprojects/unity/docs/UnityHelperScriptsGuide.md deleted file mode 100644 index 90e2193927..0000000000 --- a/subprojects/unity/docs/UnityHelperScriptsGuide.md +++ /dev/null @@ -1,533 +0,0 @@ -# Unity Helper Scripts - -## With a Little Help From Our Friends - -Sometimes what it takes to be a really efficient C programmer is a little non-C. -The Unity project includes a couple of Ruby scripts for making your life just a tad easier. -They are completely optional. -If you choose to use them, you'll need a copy of Ruby, of course. -Just install whatever the latest version is, and it is likely to work. You can find Ruby at [ruby-lang.org][]. - -### `generate_test_runner.rb` - -Are you tired of creating your own `main` function in your test file? -Do you keep forgetting to add a `RUN_TEST` call when you add a new test case to your suite? -Do you want to use CMock or other fancy add-ons but don't want to figure out how to create your own `RUN_TEST` macro? - -Well then we have the perfect script for you! - -The `generate_test_runner` script processes a given test file and automatically creates a separate test runner file that includes ?main?to execute the test cases within the scanned test file. -All you do then is add the generated runner to your list of files to be compiled and linked, and presto you're done! - -This script searches your test file for void function signatures having a function name beginning with "test" or "spec". -It treats each of these functions as a test case and builds up a test suite of them. -For example, the following includes three test cases: - -```C -void testVerifyThatUnityIsAwesomeAndWillMakeYourLifeEasier(void) -{ - ASSERT_TRUE(1); -} -void test_FunctionName_should_WorkProperlyAndReturn8(void) { - ASSERT_EQUAL_INT(8, FunctionName()); -} -void spec_Function_should_DoWhatItIsSupposedToDo(void) { - ASSERT_NOT_NULL(Function(5)); -} -``` - -You can run this script a couple of ways. -The first is from the command line: - -```Shell -ruby generate_test_runner.rb TestFile.c NameOfRunner.c -``` - -Alternatively, if you include only the test file parameter, the script will copy the name of the test file and automatically append `_Runner` to the name of the generated file. -The example immediately below will create TestFile_Runner.c. - -```Shell -ruby generate_test_runner.rb TestFile.c -``` - -You can also add a [YAML][] file to configure extra options. -Conveniently, this YAML file is of the same format as that used by Unity and CMock. -So if you are using YAML files already, you can simply pass the very same file into the generator script. - -```Shell -ruby generate_test_runner.rb TestFile.c my_config.yml -``` - -The contents of the YAML file `my_config.yml` could look something like the example below. -If you're wondering what some of these options do, you're going to love the next section of this document. - -```YAML -:unity: - :includes: - - stdio.h - - microdefs.h - :cexception: 1 - :suite_setup: "blah = malloc(1024);" - :suite_teardown: "free(blah);" -``` - -If you would like to force your generated test runner to include one or more header files, you can just include those at the command line too. -Just make sure these are _after_ the YAML file, if you are using one: - -```Shell -ruby generate_test_runner.rb TestFile.c my_config.yml extras.h -``` - -Another option, particularly if you are already using Ruby to orchestrate your builds - or more likely the Ruby-based build tool Rake - is requiring this script directly. -Anything that you would have specified in a YAML file can be passed to the script as part of a hash. -Let's push the exact same requirement set as we did above but this time through Ruby code directly: - -```Ruby -require "generate_test_runner.rb" -options = { - :includes => ["stdio.h", "microdefs.h"], - :cexception => 1, - :suite_setup => "blah = malloc(1024);", - :suite_teardown => "free(blah);" -} -UnityTestRunnerGenerator.new.run(testfile, runner_name, options) -``` - -If you have multiple files to generate in a build script (such as a Rakefile), you might want to instantiate a generator object with your options and call it to generate each runner afterwards. -Like thus: - -```Ruby -gen = UnityTestRunnerGenerator.new(options) -test_files.each do |f| - gen.run(f, File.basename(f,'.c')+"Runner.c" -end -``` - -#### Options accepted by generate_test_runner.rb - -The following options are available when executing `generate_test_runner`. -You may pass these as a Ruby hash directly or specify them in a YAML file, both of which are described above. -In the `examples` directory, Example 3's Rakefile demonstrates using a Ruby hash. - -##### `:includes` - -This option specifies an array of file names to be `#include`'d at the top of your runner C file. -You might use it to reference custom types or anything else universally needed in your generated runners. - -##### `:defines` - -This option specifies an array of definitions to be `#define`'d at the top of your runner C file. -Each definition will be wrapped in an `#ifndef`. - -##### `:suite_setup` - -Define this option with C code to be executed _before any_ test cases are run. - -Alternatively, if your C compiler supports weak symbols, you can leave this option unset and instead provide a `void suiteSetUp(void)` function in your test suite. -The linker will look for this symbol and fall back to a Unity-provided stub if it is not found. - -This option can also be specified at the command prompt as `--suite_setup=""` - -##### `:suite_teardown` - -Define this option with C code to be executed _after all_ test cases have finished. -An integer variable `num_failures` is available for diagnostics. -The code should end with a `return` statement; the value returned will become the exit code of `main`. -You can normally just return `num_failures`. - -Alternatively, if your C compiler supports weak symbols, you can leave this option unset and instead provide a `int suiteTearDown(int num_failures)` function in your test suite. -The linker will look for this symbol and fall back to a Unity-provided stub if it is not found. - -This option can also be specified at the command prompt as `--suite_teardown=""` - -##### `:enforce_strict_ordering` - -This option should be defined if you have the strict order feature enabled in CMock (see CMock documentation). -This generates extra variables required for everything to run smoothly. -If you provide the same YAML to the generator as used in CMock's configuration, you've already configured the generator properly. - -##### `:externc` - -This option should be defined if you are mixing C and CPP and want your test runners to automatically include extern "C" support when they are generated. - -This option can also be specified at the command prompt as `--externc` - -##### `:mock_prefix` and `:mock_suffix` - -Unity automatically generates calls to Init, Verify and Destroy for every file included in the main test file that starts with the given mock prefix and ends with the given mock suffix, file extension not included. -By default, Unity assumes a `Mock` prefix and no suffix. - -##### `:plugins` - -This option specifies an array of plugins to be used (of course, the array can contain only a single plugin). -This is your opportunity to enable support for CException support, which will add a check for unhandled exceptions in each test, reporting a failure if one is detected. -To enable this feature using Ruby: - -```Ruby -:plugins => [ :cexception ] -``` - -Or as a yaml file: - -```YAML -:plugins: - -:cexception -``` - -If you are using CMock, it is very likely that you are already passing an array of plugins to CMock. -You can just use the same array here. - -This script will just ignore the plugins that don't require additional support. - -This option can also be specified at the command prompt as `--cexception` - -##### `:include_extensions` - -This option specifies the pattern for matching acceptable header file extensions. -By default it will accept hpp, hh, H, and h files. -If you need a different combination of files to search, update this from the default `'(?:hpp|hh|H|h)'`. - -##### `:source_extensions` - -This option specifies the pattern for matching acceptable source file extensions. -By default it will accept cpp, cc, C, c, and ino files. -If you need a different combination of files to search, update this from the default `'(?:cpp|cc|ino|C|c)'`. - -##### `:use_param_tests` - -This option enables parameterized test usage. -That tests accepts arguments from `TEST_CASE` and `TEST_RANGE` macros, -that are located above current test definition. -By default, Unity assumes, that parameterized tests are disabled. - -Few usage examples can be found in `/test/tests/test_unity_parameterized.c` file. - -You should define `UNITY_SUPPORT_TEST_CASES` macro for tests success compiling, -if you enable current option. - -You can see list of supported macros list in the -[Parameterized tests provided macros](#parameterized-tests-provided-macros) -section that follows. - -This option can also be specified at the command prompt as `--use_param_tests=1` - -##### `:cmdline_args` - -When set to `true`, the generated test runner can accept a number of -options to modify how the test(s) are run. - -Ensure Unity is compiled with `UNITY_USE_COMMAND_LINE_ARGS` defined or else -the required functions will not exist. - -These are the available options: - -| Option | Description | -| --------- | ------------------------------------------------- | -| `-l` | List all tests and exit | -| `-f NAME` | Filter to run only tests whose name includes NAME | -| `-n NAME` | Run only the test named NAME | -| `-h` | show the Help menu that lists these options | -| `-q` | Quiet/decrease verbosity | -| `-v` | increase Verbosity | -| `-x NAME` | eXclude tests whose name includes NAME | - -##### `:setup_name` - -Override the default test `setUp` function name. - -This option can also be specified at the command prompt as `--setup_name=""` - -##### `:teardown_name` - -Override the default test `tearDown` function name. - -This option can also be specified at the command prompt as `--teardown_name=""` - -##### `:test_reset_name` - -Override the default test `resetTest` function name. - -This option can also be specified at the command prompt as `--test_reset_name=""` - -##### `:test_verify_name` - -Override the default test `verifyTest` function name. - -This option can also be specified at the command prompt as `--test_verify_name=""` - -##### `:main_name` - -Override the test's `main()` function name (from `main` to whatever is specified). -The sentinel value `:auto` will use the test's filename with the `.c` extension removed prefixed -with `main_` as the "main" function. - -To clarify, if `:main_name == :auto` and the test filename is "test_my_project.c", then the -generated function name will be `main_test_my_project(int argc, char** argv)`. - -This option can also be specified at the command prompt as `--main_name=""` - -##### `main_export_decl` - -Provide any `cdecl` for the `main()` test function. Is empty by default. - -##### `:omit_begin_end` - -If `true`, the `UnityBegin` and `UnityEnd` function will not be called for -Unity test state setup and cleanup. - -This option can also be specified at the command prompt as `--omit_begin_end` - -#### Parameterized tests provided macros - -Unity provides support for few param tests generators, that can be combined -with each other. You must define test function as usual C function with usual -C arguments, and test generator will pass what you tell as a list of arguments. - -Let's show how all of them works on the following test function definitions: - -```C -/* Place your test generators here, usually one generator per one or few lines */ -void test_demoParamFunction(int a, int b, int c) -{ - TEST_ASSERT_GREATER_THAN_INT(a + b, c); -} -``` - -##### `TEST_CASE` - -Test case is a basic generator, that can be used for param testing. -One call of that macro will generate only one call for test function. -It can be used with different args, such as numbers, enums, strings, -global variables, another preprocessor defines. - -If we use replace comment before test function with the following code: - -```C -TEST_CASE(1, 2, 5) -TEST_CASE(10, 7, 20) -``` - -script will generate 2 test calls: - -```C -test_demoParamFunction(1, 2, 5); -test_demoParamFunction(10, 7, 20); -``` - -That calls will be wrapped with `setUp`, `tearDown` and other -usual Unity calls, as for independent unit tests. -The following output can be generated after test executable startup: - -```Log -tests/test_unity_parameterizedDemo.c:14:test_demoParamFunction(1, 2, 5):PASS -tests/test_unity_parameterizedDemo.c:14:test_demoParamFunction(10, 7, 20):PASS -``` - -##### `TEST_RANGE` - -Test range is an advanced generator. It single call can be converted to zero, -one or few `TEST_CASE` equivalent commands. - -That generator can be used for creating numeric ranges in decimal representation -only: integers & floating point numbers. It uses few formats for every parameter: - -1. `[start, stop, step]` is stop-inclusive format -2. `` is stop-exclusive formats - -Format providers 1 and 2 accept only three arguments: - -* `start` is start number -* `stop` is end number (can or cannot exists in result sequence for format 1, -will be always skipped for format 2) -* `step` is incrementing step: can be either positive or negative value. - -Let's use our `test_demoParamFunction` test for checking, what ranges -will be generated for our single `TEST_RANGE` row: - -```C -TEST_RANGE([3, 4, 1], [10, 5, -2], <30, 31, 1>) -``` - -Tests execution output will be similar to that text: - -```Log -tests/test_unity_parameterizedDemo.c:14:test_demoParamFunction(3, 10, 30):PASS -tests/test_unity_parameterizedDemo.c:14:test_demoParamFunction(3, 8, 30):PASS -tests/test_unity_parameterizedDemo.c:14:test_demoParamFunction(3, 6, 30):PASS -tests/test_unity_parameterizedDemo.c:14:test_demoParamFunction(4, 10, 30):PASS -tests/test_unity_parameterizedDemo.c:14:test_demoParamFunction(4, 8, 30):PASS -tests/test_unity_parameterizedDemo.c:14:test_demoParamFunction(4, 6, 30):PASS -``` - -As we can see: - -| Parameter | Format | Possible values | Total of values | Format number | -|---|---|---|---|---| -| `a` | `[3, 4, 1]` | `3`, `4` | 2 | Format 1 | -| `b` | `[10, 5, -2]` | `10`, `8`, `6` | 3 | Format 1, negative step, end number is not included | -| `c` | `<30, 31, 1>` | `30` | 1 | Format 2 | - -_Note_, that format 2 also supports negative step. - -We totally have 2 * 3 * 1 = 6 equal test cases, that can be written as following: - -```C -TEST_CASE(3, 10, 30) -TEST_CASE(3, 8, 30) -TEST_CASE(3, 6, 30) -TEST_CASE(4, 10, 30) -TEST_CASE(4, 8, 30) -TEST_CASE(4, 6, 30) -``` - -##### `TEST_MATRIX` - -Test matix is an advanced generator. It single call can be converted to zero, -one or few `TEST_CASE` equivalent commands. - -That generator will create tests for all cobinations of the provided list. Each argument has to be given as a list of one or more elements in the format `[, , ..., , ]`. - -All parameters supported by the `TEST_CASE` is supported as arguments: -- Numbers incl type specifiers e.g. `<1>`, `<1u>`, `<1l>`, `<2.3>`, or `<2.3f>` -- Strings incl string concatianion e.g. `<"string">`, or `<"partial" "string">` -- Chars e.g. `<'c'>` -- Enums e.g. `` -- Elements of arrays e.g. `` - -Let's use our `test_demoParamFunction` test for checking, what ranges -will be generated for our single `TEST_RANGE` row: - -```C -TEST_MATRIX([3, 4, 7], [10, 8, 2, 1],[30u, 20.0f]) -``` - -Tests execution output will be similar to that text: - -```Log -tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(3, 10, 30u):PASS -tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(3, 10, 20.0f):PASS -tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(3, 8, 30u):PASS -tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(3, 8, 20.0f):PASS -tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(3, 2, 30u):PASS -tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(3, 2, 20.0f):PASS -tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(3, 1, 30u):PASS -tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(3, 1, 20.0f):PASS -tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(4, 10, 30u):PASS -tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(4, 10, 20.0f):PASS -tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(4, 8, 30u):PASS -tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(4, 8, 20.0f):PASS -tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(4, 2, 30u):PASS -tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(4, 2, 20.0f):PASS -tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(4, 1, 30u):PASS -tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(4, 1, 20.0f):PASS -tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(7, 10, 30u):PASS -tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(7, 10, 20.0f):PASS -tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(7, 8, 30u):PASS -tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(7, 8, 20.0f):PASS -tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(7, 2, 30u):PASS -tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(7, 2, 20.0f):PASS -tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(7, 1, 30u):PASS -tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(7, 1, 20.0f):PASS -``` - -As we can see: - -| Parameter | Format | Count of values | -|---|---|---| -| `a` | `[3, 4, 7]` | 2 | -| `b` | `[10, 8, 2, 1]` | 4 | -| `c` | `[30u, 20.0f]` | 2 | - -We totally have 2 * 4 * 2 = 16 equal test cases, that can be written as following: - -```C -TEST_CASE(3, 10, 30u) -TEST_CASE(3, 10, 20.0f) -TEST_CASE(3, 8, 30u) -TEST_CASE(3, 8, 20.0f) -TEST_CASE(3, 2, 30u) -TEST_CASE(3, 2, 20.0f) -TEST_CASE(3, 1, 30u) -TEST_CASE(3, 1, 20.0f) -TEST_CASE(4, 10, 30u) -TEST_CASE(4, 10, 20.0f) -TEST_CASE(4, 8, 30u) -TEST_CASE(4, 8, 20.0f) -TEST_CASE(4, 2, 30u) -TEST_CASE(4, 2, 20.0f) -TEST_CASE(4, 1, 30u) -TEST_CASE(4, 1, 20.0f) -TEST_CASE(7, 10, 30u) -TEST_CASE(7, 10, 20.0f) -TEST_CASE(7, 8, 30u) -TEST_CASE(7, 8, 20.0f) -TEST_CASE(7, 2, 30u) -TEST_CASE(7, 2, 20.0f) -TEST_CASE(7, 1, 30u) -TEST_CASE(7, 1, 20.0f) -``` - -### `unity_test_summary.rb` - -A Unity test file contains one or more test case functions. -Each test case can pass, fail, or be ignored. -Each test file is run individually producing results for its collection of test cases. -A given project will almost certainly be composed of multiple test files. -Therefore, the suite of tests is comprised of one or more test cases spread across one or more test files. -This script aggregates individual test file results to generate a summary of all executed test cases. -The output includes how many tests were run, how many were ignored, and how many failed. In addition, the output includes a listing of which specific tests were ignored and failed. -A good example of the breadth and details of these results can be found in the `examples` directory. -Intentionally ignored and failing tests in this project generate corresponding entries in the summary report. - -If you're interested in other (prettier?) output formats, check into the [Ceedling][] build tool project that works with Unity and CMock and supports xunit-style xml as well as other goodies. - -This script assumes the existence of files ending with the extensions `.testpass` and `.testfail`. -The contents of these files includes the test results summary corresponding to each test file executed with the extension set according to the presence or absence of failures for that test file. -The script searches a specified path for these files, opens each one it finds, parses the results, and aggregates and prints a summary. -Calling it from the command line looks like this: - -```Shell -ruby unity_test_summary.rb build/test/ -``` - -You can optionally specify a root path as well. -This is really helpful when you are using relative paths in your tools' setup, but you want to pull the summary into an IDE like Eclipse for clickable shortcuts. - -```Shell -ruby unity_test_summary.rb build/test/ ~/projects/myproject/ -``` - -Or, if you're more of a Windows sort of person: - -```Shell -ruby unity_test_summary.rb build\teat\ C:\projects\myproject\ -``` - -When configured correctly, you'll see a final summary, like so: - -```Shell --------------------------- -UNITY IGNORED TEST SUMMARY --------------------------- -blah.c:22:test_sandwiches_should_HaveBreadOnTwoSides:IGNORE - -------------------------- -UNITY FAILED TEST SUMMARY -------------------------- -blah.c:87:test_sandwiches_should_HaveCondiments:FAIL:Expected 1 was 0 -meh.c:38:test_soda_should_BeCalledPop:FAIL:Expected "pop" was "coke" - --------------------------- -OVERALL UNITY TEST SUMMARY --------------------------- -45 TOTAL TESTS 2 TOTAL FAILURES 1 IGNORED -``` - -How convenient is that? - -*Find The Latest of This And More at [ThrowTheSwitch.org][]* - -[ruby-lang.org]: https://ruby-lang.org/ -[YAML]: http://www.yaml.org/ -[Ceedling]: http://www.throwtheswitch.org/ceedling -[ThrowTheSwitch.org]: https://throwtheswitch.org diff --git a/subprojects/unity/docs/UnityKnownIssues.md b/subprojects/unity/docs/UnityKnownIssues.md deleted file mode 100644 index 3449319739..0000000000 --- a/subprojects/unity/docs/UnityKnownIssues.md +++ /dev/null @@ -1,13 +0,0 @@ -# Unity Test - Known Issues - -## A Note - -This project will do its best to keep track of significant bugs that might effect your usage of this -project and its supporting scripts. A more detailed and up-to-date list for cutting edge Unity can -be found on our Github repository. - -## Issues - - - No built-in validation of no-return functions - - Incomplete support for Printf-style formatting - - Incomplete support for VarArgs diff --git a/subprojects/unity/extras/bdd/readme.md b/subprojects/unity/extras/bdd/readme.md deleted file mode 100644 index e703588509..0000000000 --- a/subprojects/unity/extras/bdd/readme.md +++ /dev/null @@ -1,40 +0,0 @@ -# Unity Project - BDD Feature - -Unity's Behavior-Driven Development (BDD) test feature. It allows developers to structure and describe various phases (Given, When, Then) of a test scenario in a BDD-style format. - -## Introduction - -This project is based on the Unity framework originally created by Mike Karlesky, Mark VanderVoord, and Greg Williams in 2007. The project extends Unity by providing macros to define BDD structures with descriptive elements. Feature added by Michael Gene Brockus (Dreamer). - -## License - -This project is distributed under the MIT License. See the [license.txt](license.txt) file for more information. - -## Usage - -### BDD Macros - -The provided BDD macros allow you to structure your test scenarios in a descriptive manner. These macros are for descriptive purposes only and do not have functional behavior. - -- `GIVEN(description)`: Describes the "Given" phase of a test scenario. -- `WHEN(description)`: Describes the "When" phase of a test scenario. -- `THEN(description)`: Describes the "Then" phase of a test scenario. - -Example usage: - -```c -GIVEN("a valid input") { - // Test setup and context - // ... - - WHEN("the input is processed") { - // Perform the action - // ... - - THEN("the expected outcome occurs") { - // Assert the outcome - // ... - } - } -} -``` diff --git a/subprojects/unity/extras/bdd/src/unity_bdd.h b/subprojects/unity/extras/bdd/src/unity_bdd.h deleted file mode 100644 index feff492ce2..0000000000 --- a/subprojects/unity/extras/bdd/src/unity_bdd.h +++ /dev/null @@ -1,44 +0,0 @@ -/* ========================================================================= - Unity - A Test Framework for C - ThrowTheSwitch.org - Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams - SPDX-License-Identifier: MIT -========================================================================= */ - -#ifndef UNITY_BDD_TEST_H_ -#define UNITY_BDD_TEST_H_ - -#ifdef __cplusplus -extern "C" -{ -#endif - -#include - -/** - * @brief Macros for defining a Behavior-Driven Development (BDD) structure with descriptions. - * - * These macros provide a way to structure and describe different phases (Given, When, Then) of a - * test scenario in a BDD-style format. However, they don't have functional behavior by themselves - * and are used for descriptive purposes. - */ -#define GIVEN(description) \ - if (0) { \ - printf("Given %s\n", description); \ - } else - -#define WHEN(description) \ - if (0) { \ - printf("When %s\n", description); \ - } else - -#define THEN(description) \ - if (0) { \ - printf("Then %s\n", description); \ - } else - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/subprojects/unity/extras/bdd/test/meson.build b/subprojects/unity/extras/bdd/test/meson.build deleted file mode 100644 index fcdaffff4c..0000000000 --- a/subprojects/unity/extras/bdd/test/meson.build +++ /dev/null @@ -1,9 +0,0 @@ -project('BDD Tester', 'c') - -# Add Unity as a dependency -unity_dep = dependency('unity') - -# Define your source files -sources = files('test_bdd.c') - -executable('tester', sources, dependencies : unity_dep) diff --git a/subprojects/unity/extras/bdd/test/test_bdd.c b/subprojects/unity/extras/bdd/test/test_bdd.c deleted file mode 100644 index f86e5abdd1..0000000000 --- a/subprojects/unity/extras/bdd/test/test_bdd.c +++ /dev/null @@ -1,129 +0,0 @@ -/* ========================================================================= - Unity - A Test Framework for C - ThrowTheSwitch.org - Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams - SPDX-License-Identifier: MIT -========================================================================= */ - -#include "unity.h" -#include "unity_bdd.h" - -void test_bdd_logic_test(void) { - GIVEN("a valid statement is passed") - { - // Set up the context - bool givenExecuted = true; - - WHEN("a statement is true") - { - // Perform the login action - bool whenExecuted = true; - - THEN("we validate everything was worked") - { - // Check the expected outcome - bool thenExecuted = true; - - TEST_ASSERT_TRUE(givenExecuted); - TEST_ASSERT_TRUE(whenExecuted); - TEST_ASSERT_TRUE(thenExecuted); - } - } - } -} // end of case - -void test_bdd_user_account(void) { - GIVEN("a user's account with sufficient balance") - { - // Set up the context - float accountBalance = 500.0; - float withdrawalAmount = 200.0; - - WHEN("the user requests a withdrawal of $200") - { - // Perform the withdrawal action - if (accountBalance >= withdrawalAmount) - { - accountBalance -= withdrawalAmount; - } // end if - THEN("the withdrawal amount should be deducted from the account balance") - { - // Check the expected outcome - - // Simulate the scenario - float compareBalance = 500.0; - TEST_ASSERT_LESS_THAN_FLOAT(accountBalance, compareBalance); - } - } - } -} // end of case - -void test_bdd_empty_cart(void) { - GIVEN("a user with an empty shopping cart") - { - // Set up the context - int cartItemCount = 0; - - WHEN("the user adds a product to the cart") - { - // Perform the action of adding a product - - THEN("the cart item count should increase by 1") - { - // Check the expected outcome - cartItemCount++; - - TEST_ASSERT_EQUAL_INT(cartItemCount, 1); - } - } - } -} // end of case - -void test_bdd_valid_login(void) { - GIVEN("a registered user with valid credentials") - { - // Set up the context - const char* validUsername = "user123"; - const char* validPassword = "pass456"; - - WHEN("the user provides correct username and password") - { - // Perform the action of user login - const char* inputUsername = "user123"; - const char* inputPassword = "pass456"; - - THEN("the login should be successful") - { - // Check the expected outcome - // Simulate login validation - TEST_ASSERT_EQUAL_STRING(inputUsername, validUsername); - TEST_ASSERT_EQUAL_STRING(inputPassword, validPassword); - } - } - - WHEN("the user provides incorrect password") - { - // Perform the action of user login - const char* inputUsername = "user123"; - const char* inputPassword = "wrongpass"; - - THEN("the login should fail with an error message") - { - // Check the expected outcome - // Simulate login validation - TEST_ASSERT_EQUAL_STRING(inputUsername, validUsername); - // TEST_ASSERT_NOT_EQUAL_STRING(inputPassword, validPassword); - } - } - } -} // end of case - -int main(void) -{ - UnityBegin("test_bdd.c"); - RUN_TEST(test_bdd_logic_test); - RUN_TEST(test_bdd_user_account); - RUN_TEST(test_bdd_empty_cart); - RUN_TEST(test_bdd_valid_login); - return UnityEnd(); -} diff --git a/subprojects/unity/extras/eclipse/error_parsers.txt b/subprojects/unity/extras/eclipse/error_parsers.txt deleted file mode 100644 index 94e34ff385..0000000000 --- a/subprojects/unity/extras/eclipse/error_parsers.txt +++ /dev/null @@ -1,26 +0,0 @@ -Eclipse error parsers -===================== - -These are a godsend for extracting & quickly navigating to -warnings & error messages from console output. Unforunately -I don't know how to write an Eclipse plugin so you'll have -to add them manually. - -To add a console parser to Eclipse, go to Window --> Preferences ---> C/C++ --> Build --> Settings. Click on the 'Error Parsers' -tab and then click the 'Add...' button. See the table below for -the parser fields to add. - -Eclipse will only parse the console output during a build, so -running your unit tests must be part of your build process. -Either add this to your make/rakefile, or add it as a post- -build step in your Eclipse project settings. - - -Unity unit test error parsers ------------------------------ -Severity Pattern File Line Description -------------------------------------------------------------------------------- -Error (\.+)(.*?):(\d+):(.*?):FAIL: (.*) $2 $3 $5 -Warning (\.+)(.*?):(\d+):(.*?):IGNORE: (.*) $2 $3 $5 -Warning (\.+)(.*?):(\d+):(.*?):IGNORE\s*$ $2 $3 Ignored test diff --git a/subprojects/unity/extras/fixture/readme.md b/subprojects/unity/extras/fixture/readme.md deleted file mode 100644 index e0c9e1b730..0000000000 --- a/subprojects/unity/extras/fixture/readme.md +++ /dev/null @@ -1,26 +0,0 @@ -# Unity Fixtures - -This Framework is an optional add-on to Unity. -By including unity_fixture.h in place of unity.h, you may now work with Unity in a manner similar to CppUTest. -This framework adds the concepts of test groups and gives finer control of your tests over the command line. - -This framework is primarily supplied for those working through James Grenning's book on Embedded Test Driven Development, or those coming to Unity from CppUTest. -We should note that using this framework glosses over some of the features of Unity, and makes it more difficult to integrate with other testing tools like Ceedling and CMock. - -## Dependency Notification - -Fixtures, by default, uses the Memory addon as well. -This is to make it simple for those trying to follow along with James' book. -Using them together is completely optional. -You may choose to use Fixtures without Memory handling by defining `UNITY_FIXTURE_NO_EXTRAS`. -It will then stop automatically pulling in extras and leave you to do it as desired. - -## Usage information - -By default the test executables produced by Unity Fixtures run all tests once, but the behavior can be configured with command-line flags. -Run the test executable with the `--help` flag for more information. - -It's possible to add a custom line at the end of the help message, typically to point to project-specific or company-specific unit test documentation. -Define `UNITY_CUSTOM_HELP_MSG` to provide a custom message, e.g.: - - #define UNITY_CUSTOM_HELP_MSG "If any test fails see https://example.com/troubleshooting" diff --git a/subprojects/unity/extras/fixture/src/meson.build b/subprojects/unity/extras/fixture/src/meson.build deleted file mode 100644 index 224911de66..0000000000 --- a/subprojects/unity/extras/fixture/src/meson.build +++ /dev/null @@ -1,10 +0,0 @@ -unity_inc += include_directories('.') -unity_src += files('unity_fixture.c') - -if not meson.is_subproject() - install_headers( - 'unity_fixture.h', - 'unity_fixture_internals.h', - subdir: meson.project_name() - ) -endif diff --git a/subprojects/unity/extras/fixture/src/unity_fixture.c b/subprojects/unity/extras/fixture/src/unity_fixture.c deleted file mode 100644 index 9b3fce273a..0000000000 --- a/subprojects/unity/extras/fixture/src/unity_fixture.c +++ /dev/null @@ -1,310 +0,0 @@ -/* ========================================================================= - Unity - A Test Framework for C - ThrowTheSwitch.org - Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams - SPDX-License-Identifier: MIT -========================================================================= */ - -#include "unity_fixture.h" -#include "unity_internals.h" -#include - -struct UNITY_FIXTURE_T UnityFixture; - -/* If you decide to use the function pointer approach. - * Build with -D UNITY_OUTPUT_CHAR=outputChar and include - * int (*outputChar)(int) = putchar; */ - -void setUp(void) { /*does nothing*/ } -void tearDown(void) { /*does nothing*/ } - -static void announceTestRun(unsigned int runNumber) -{ - UnityPrint("Unity test run "); - UnityPrintNumberUnsigned(runNumber+1); - UnityPrint(" of "); - UnityPrintNumberUnsigned(UnityFixture.RepeatCount); - UNITY_PRINT_EOL(); -} - -int UnityMain(int argc, const char* argv[], void (*runAllTests)(void)) -{ - int result = UnityGetCommandLineOptions(argc, argv); - unsigned int r; - if (result != 0) - return result; - - for (r = 0; r < UnityFixture.RepeatCount; r++) - { - UnityBegin(argv[0]); - announceTestRun(r); - runAllTests(); - if (!UnityFixture.Verbose) UNITY_PRINT_EOL(); - UnityEnd(); - } - - return (int)Unity.TestFailures; -} - -static int selected(const char* filter, const char* name) -{ - if (filter == 0) - return 1; - return strstr(name, filter) ? 1 : 0; -} - -static int testSelected(const char* test) -{ - return selected(UnityFixture.NameFilter, test); -} - -static int groupSelected(const char* group) -{ - return selected(UnityFixture.GroupFilter, group); -} - -void UnityTestRunner(unityfunction* setup, - unityfunction* testBody, - unityfunction* teardown, - const char* printableName, - const char* group, - const char* name, - const char* file, - unsigned int line) -{ - if (testSelected(name) && groupSelected(group)) - { - Unity.TestFile = file; - Unity.CurrentTestName = printableName; - Unity.CurrentTestLineNumber = line; - if (UnityFixture.Verbose) - { - UnityPrint(printableName); - #ifndef UNITY_REPEAT_TEST_NAME - Unity.CurrentTestName = NULL; - #endif - } - else if (UnityFixture.Silent) - { - /* Do Nothing */ - } - else - { - UNITY_OUTPUT_CHAR('.'); - } - - Unity.NumberOfTests++; - UnityPointer_Init(); - - UNITY_EXEC_TIME_START(); - - if (TEST_PROTECT()) - { - setup(); - testBody(); - } - if (TEST_PROTECT()) - { - teardown(); - } - if (TEST_PROTECT()) - { - UnityPointer_UndoAllSets(); - } - UnityConcludeFixtureTest(); - } -} - -void UnityIgnoreTest(const char* printableName, const char* group, const char* name) -{ - if (testSelected(name) && groupSelected(group)) - { - Unity.NumberOfTests++; - Unity.TestIgnores++; - if (UnityFixture.Verbose) - { - UnityPrint(printableName); - UNITY_PRINT_EOL(); - } - else if (UnityFixture.Silent) - { - /* Do Nothing */ - } - else - { - UNITY_OUTPUT_CHAR('!'); - } - } -} - -/*-------------------------------------------------------- */ -/*Automatic pointer restoration functions */ -struct PointerPair -{ - void** pointer; - void* old_value; -}; - -static struct PointerPair pointer_store[UNITY_MAX_POINTERS]; -static int pointer_index = 0; - -void UnityPointer_Init(void) -{ - pointer_index = 0; -} - -void UnityPointer_Set(void** pointer, void* newValue, UNITY_LINE_TYPE line) -{ - if (pointer_index >= UNITY_MAX_POINTERS) - { - UNITY_TEST_FAIL(line, "Too many pointers set"); - } - else - { - pointer_store[pointer_index].pointer = pointer; - pointer_store[pointer_index].old_value = *pointer; - *pointer = newValue; - pointer_index++; - } -} - -void UnityPointer_UndoAllSets(void) -{ - while (pointer_index > 0) - { - pointer_index--; - *(pointer_store[pointer_index].pointer) = - pointer_store[pointer_index].old_value; - } -} - -int UnityGetCommandLineOptions(int argc, const char* argv[]) -{ - int i; - UnityFixture.Verbose = 0; - UnityFixture.Silent = 0; - UnityFixture.GroupFilter = 0; - UnityFixture.NameFilter = 0; - UnityFixture.RepeatCount = 1; - - if (argc == 1) - return 0; - - for (i = 1; i < argc; ) - { - if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0) - { - /* Usage */ - UnityPrint("Runs a series of unit tests."); - UNITY_PRINT_EOL(); - UNITY_PRINT_EOL(); - UnityPrint("When no flag is specified, all tests are run."); - UNITY_PRINT_EOL(); - UNITY_PRINT_EOL(); - UnityPrint("Optional flags:"); - UNITY_PRINT_EOL(); - UnityPrint(" -v Verbose output: show all tests executed even if they pass"); - UNITY_PRINT_EOL(); - UnityPrint(" -s Silent mode: minimal output showing only test failures"); - UNITY_PRINT_EOL(); - UnityPrint(" -g NAME Only run tests in groups that contain the string NAME"); - UNITY_PRINT_EOL(); - UnityPrint(" -n NAME Only run tests whose name contains the string NAME"); - UNITY_PRINT_EOL(); - UnityPrint(" -r NUMBER Repeatedly run all tests NUMBER times"); - UNITY_PRINT_EOL(); - UnityPrint(" -h, --help Display this help message"); - UNITY_PRINT_EOL(); - UNITY_PRINT_EOL(); -#ifdef UNITY_CUSTOM_HELP_MSG - /* User-defined help message, e.g. to point to project-specific documentation */ - UnityPrint(UNITY_CUSTOM_HELP_MSG); - UNITY_PRINT_EOL(); -#else - /* Default help suffix if a custom one is not defined */ - UnityPrint("More information about Unity: https://www.throwtheswitch.org/unity"); - UNITY_PRINT_EOL(); -#endif - return 1; /* Exit without running the tests */ - } - else if (strcmp(argv[i], "-v") == 0) - { - UnityFixture.Verbose = 1; - i++; - } - else if (strcmp(argv[i], "-s") == 0) - { - UnityFixture.Silent = 1; - i++; - } - else if (strcmp(argv[i], "-g") == 0) - { - i++; - if (i >= argc) - return 1; - UnityFixture.GroupFilter = argv[i]; - i++; - } - else if (strcmp(argv[i], "-n") == 0) - { - i++; - if (i >= argc) - return 1; - UnityFixture.NameFilter = argv[i]; - i++; - } - else if (strcmp(argv[i], "-r") == 0) - { - UnityFixture.RepeatCount = 2; - i++; - if (i < argc) - { - if (*(argv[i]) >= '0' && *(argv[i]) <= '9') - { - unsigned int digit = 0; - UnityFixture.RepeatCount = 0; - while (argv[i][digit] >= '0' && argv[i][digit] <= '9') - { - UnityFixture.RepeatCount *= 10; - UnityFixture.RepeatCount += (unsigned int)argv[i][digit++] - '0'; - } - i++; - } - } - } - else - { - /* ignore unknown parameter */ - i++; - } - } - return 0; -} - -void UnityConcludeFixtureTest(void) -{ - if (Unity.CurrentTestIgnored) - { - Unity.TestIgnores++; - UNITY_PRINT_EOL(); - } - else if (!Unity.CurrentTestFailed) - { - if (UnityFixture.Verbose) - { - UnityPrint(" "); - UnityPrint(UnityStrPass); - UNITY_EXEC_TIME_STOP(); - UNITY_PRINT_EXEC_TIME(); - UNITY_PRINT_EOL(); - } - } - else /* Unity.CurrentTestFailed */ - { - Unity.TestFailures++; - UNITY_PRINT_EOL(); - } - - Unity.CurrentTestFailed = 0; - Unity.CurrentTestIgnored = 0; -} diff --git a/subprojects/unity/extras/fixture/src/unity_fixture.h b/subprojects/unity/extras/fixture/src/unity_fixture.h deleted file mode 100644 index ed6ff482c9..0000000000 --- a/subprojects/unity/extras/fixture/src/unity_fixture.h +++ /dev/null @@ -1,94 +0,0 @@ -/* ========================================================================= - Unity - A Test Framework for C - ThrowTheSwitch.org - Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams - SPDX-License-Identifier: MIT -========================================================================= */ - -#ifndef UNITY_FIXTURE_H_ -#define UNITY_FIXTURE_H_ - -#include "unity.h" -#include "unity_fixture_internals.h" - -#ifndef UNITY_FIXTURE_NO_EXTRAS -#include "unity_memory.h" -#endif - -#ifdef __cplusplus -extern "C" -{ -#endif - -#include "unity_internals.h" - - -int UnityMain(int argc, const char* argv[], void (*runAllTests)(void)); - - -#define TEST_GROUP(group)\ - static const char* TEST_GROUP_##group = #group - -#define TEST_SETUP(group) void TEST_##group##_SETUP(void);\ - void TEST_##group##_SETUP(void) - -#define TEST_TEAR_DOWN(group) void TEST_##group##_TEAR_DOWN(void);\ - void TEST_##group##_TEAR_DOWN(void) - - -#define TEST(group, name) \ - void TEST_##group##_##name##_(void);\ - void TEST_##group##_##name##_run(void);\ - void TEST_##group##_##name##_run(void)\ - {\ - UnityTestRunner(TEST_##group##_SETUP,\ - TEST_##group##_##name##_,\ - TEST_##group##_TEAR_DOWN,\ - "TEST(" #group ", " #name ")",\ - TEST_GROUP_##group, #name,\ - __FILE__, __LINE__);\ - }\ - void TEST_##group##_##name##_(void) - -#define IGNORE_TEST(group, name) \ - void TEST_##group##_##name##_(void);\ - void TEST_##group##_##name##_run(void);\ - void TEST_##group##_##name##_run(void)\ - {\ - UnityIgnoreTest("IGNORE_TEST(" #group ", " #name ")", TEST_GROUP_##group, #name);\ - }\ - void TEST_##group##_##name##_(void) - -/* Call this for each test, insider the group runner */ -#define RUN_TEST_CASE(group, name) \ - { void TEST_##group##_##name##_run(void);\ - TEST_##group##_##name##_run(); } - -/* This goes at the bottom of each test file or in a separate c file */ -#define TEST_GROUP_RUNNER(group)\ - void TEST_##group##_GROUP_RUNNER(void);\ - void TEST_##group##_GROUP_RUNNER(void) - -/* Call this from main */ -#define RUN_TEST_GROUP(group)\ - { void TEST_##group##_GROUP_RUNNER(void);\ - TEST_##group##_GROUP_RUNNER(); } - -/* CppUTest Compatibility Macros */ -#ifndef UNITY_EXCLUDE_CPPUTEST_ASSERTS -/* Sets a pointer and automatically restores it to its old value after teardown */ -#define UT_PTR_SET(ptr, newPointerValue) UnityPointer_Set((void**)&(ptr), (void*)(newPointerValue), __LINE__) -#define TEST_ASSERT_POINTERS_EQUAL(expected, actual) TEST_ASSERT_EQUAL_PTR((expected), (actual)) -#define TEST_ASSERT_BYTES_EQUAL(expected, actual) TEST_ASSERT_EQUAL_HEX8(0xff & (expected), 0xff & (actual)) -#define FAIL(message) TEST_FAIL_MESSAGE((message)) -#define CHECK(condition) TEST_ASSERT_TRUE((condition)) -#define LONGS_EQUAL(expected, actual) TEST_ASSERT_EQUAL_INT((expected), (actual)) -#define STRCMP_EQUAL(expected, actual) TEST_ASSERT_EQUAL_STRING((expected), (actual)) -#define DOUBLES_EQUAL(expected, actual, delta) TEST_ASSERT_DOUBLE_WITHIN((delta), (expected), (actual)) -#endif - -#ifdef __cplusplus -} -#endif - -#endif /* UNITY_FIXTURE_H_ */ diff --git a/subprojects/unity/extras/fixture/src/unity_fixture_internals.h b/subprojects/unity/extras/fixture/src/unity_fixture_internals.h deleted file mode 100644 index f8f83d2d95..0000000000 --- a/subprojects/unity/extras/fixture/src/unity_fixture_internals.h +++ /dev/null @@ -1,50 +0,0 @@ -/* ========================================================================= - Unity - A Test Framework for C - ThrowTheSwitch.org - Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams - SPDX-License-Identifier: MIT -========================================================================= */ - -#ifndef UNITY_FIXTURE_INTERNALS_H_ -#define UNITY_FIXTURE_INTERNALS_H_ - -#ifdef __cplusplus -extern "C" -{ -#endif - -struct UNITY_FIXTURE_T -{ - int Verbose; - int Silent; - unsigned int RepeatCount; - const char* NameFilter; - const char* GroupFilter; -}; -extern struct UNITY_FIXTURE_T UnityFixture; - -typedef void unityfunction(void); -void UnityTestRunner(unityfunction* setup, - unityfunction* testBody, - unityfunction* teardown, - const char* printableName, - const char* group, - const char* name, - const char* file, unsigned int line); - -void UnityIgnoreTest(const char* printableName, const char* group, const char* name); -int UnityGetCommandLineOptions(int argc, const char* argv[]); -void UnityConcludeFixtureTest(void); - -void UnityPointer_Set(void** pointer, void* newValue, UNITY_LINE_TYPE line); -void UnityPointer_UndoAllSets(void); -void UnityPointer_Init(void); -#ifndef UNITY_MAX_POINTERS -#define UNITY_MAX_POINTERS 5 -#endif - -#ifdef __cplusplus -} -#endif - -#endif /* UNITY_FIXTURE_INTERNALS_H_ */ diff --git a/subprojects/unity/extras/fixture/test/Makefile b/subprojects/unity/extras/fixture/test/Makefile deleted file mode 100644 index bbe32410e9..0000000000 --- a/subprojects/unity/extras/fixture/test/Makefile +++ /dev/null @@ -1,72 +0,0 @@ -CC = gcc -ifeq ($(shell uname -s), Darwin) -CC = clang -endif -#DEBUG = -O0 -g -CFLAGS += -std=c99 -pedantic -Wall -Wextra -Werror -DUNITY_FIXTURE_NO_EXTRAS -CFLAGS += $(DEBUG) -SRC = ../src/unity_fixture.c \ - ../../../src/unity.c \ - unity_fixture_Test.c \ - unity_fixture_TestRunner.c \ - main/AllTests.c - -INC_DIR = -I../src -I../../../src/ -BUILD_DIR = ../build -TARGET = ../build/fixture_tests.exe - -all: default noStdlibMalloc 32bits - -default: $(BUILD_DIR) - $(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -D UNITY_SUPPORT_64 - @ echo "default build" - ./$(TARGET) - -32bits: $(BUILD_DIR) - $(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -m32 - @ echo "32bits build" - ./$(TARGET) - -noStdlibMalloc: $(BUILD_DIR) - $(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -D UNITY_EXCLUDE_STDLIB_MALLOC - @ echo "build with noStdlibMalloc" - ./$(TARGET) - -C89: CFLAGS += -D UNITY_EXCLUDE_STDINT_H # C89 did not have type 'long long', -C89: $(BUILD_DIR) - $(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -std=c89 && ./$(TARGET) - $(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -D UNITY_EXCLUDE_STDLIB_MALLOC -std=c89 - ./$(TARGET) - -$(BUILD_DIR): - mkdir -p $(BUILD_DIR) - -clean: - rm -f $(TARGET) $(BUILD_DIR)/*.gc* - -cov: $(BUILD_DIR) - cd $(BUILD_DIR) && \ - $(CC) $(DEFINES) $(foreach i, $(SRC), ../test/$(i)) $(INC_DIR) -o $(TARGET) -fprofile-arcs -ftest-coverage - rm -f $(BUILD_DIR)/*.gcda - ./$(TARGET) > /dev/null ; ./$(TARGET) -v > /dev/null - cd $(BUILD_DIR) && \ - gcov unity_fixture.c | head -3 - grep '###' $(BUILD_DIR)/unity_fixture.c.gcov -C2 || true # Show uncovered lines - -# These extended flags DO get included before any target build runs -CFLAGS += -Wbad-function-cast -CFLAGS += -Wcast-qual -CFLAGS += -Wconversion -CFLAGS += -Wformat=2 -CFLAGS += -Wmissing-prototypes -CFLAGS += -Wold-style-definition -CFLAGS += -Wpointer-arith -CFLAGS += -Wshadow -CFLAGS += -Wstrict-overflow=5 -CFLAGS += -Wstrict-prototypes -CFLAGS += -Wswitch-default -CFLAGS += -Wundef -CFLAGS += -Wno-error=undef # Warning only, this should not stop the build -CFLAGS += -Wunreachable-code -CFLAGS += -Wunused -CFLAGS += -fstrict-aliasing diff --git a/subprojects/unity/extras/fixture/test/main/AllTests.c b/subprojects/unity/extras/fixture/test/main/AllTests.c deleted file mode 100644 index d5eec4be38..0000000000 --- a/subprojects/unity/extras/fixture/test/main/AllTests.c +++ /dev/null @@ -1,20 +0,0 @@ -/* ========================================================================= - Unity - A Test Framework for C - ThrowTheSwitch.org - Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams - SPDX-License-Identifier: MIT -========================================================================= */ - -#include "unity_fixture.h" - -static void runAllTests(void) -{ - RUN_TEST_GROUP(UnityFixture); - RUN_TEST_GROUP(UnityCommandOptions); -} - -int main(int argc, const char* argv[]) -{ - return UnityMain(argc, argv, runAllTests); -} - diff --git a/subprojects/unity/extras/fixture/test/template_fixture_tests.c b/subprojects/unity/extras/fixture/test/template_fixture_tests.c deleted file mode 100644 index 2397f10576..0000000000 --- a/subprojects/unity/extras/fixture/test/template_fixture_tests.c +++ /dev/null @@ -1,39 +0,0 @@ -/* ========================================================================= - Unity - A Test Framework for C - ThrowTheSwitch.org - Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams - SPDX-License-Identifier: MIT -========================================================================= */ - -#include "unity_fixture.h" - -static int data = -1; - -TEST_GROUP(mygroup); - -TEST_SETUP(mygroup) -{ - data = 0; -} - -TEST_TEAR_DOWN(mygroup) -{ - data = -1; -} - -TEST(mygroup, test1) -{ - TEST_ASSERT_EQUAL_INT(0, data); -} - -TEST(mygroup, test2) -{ - TEST_ASSERT_EQUAL_INT(0, data); - data = 5; -} - -TEST(mygroup, test3) -{ - data = 7; - TEST_ASSERT_EQUAL_INT(7, data); -} diff --git a/subprojects/unity/extras/fixture/test/unity_fixture_Test.c b/subprojects/unity/extras/fixture/test/unity_fixture_Test.c deleted file mode 100644 index d2785d3c56..0000000000 --- a/subprojects/unity/extras/fixture/test/unity_fixture_Test.c +++ /dev/null @@ -1,245 +0,0 @@ -/* ========================================================================= - Unity - A Test Framework for C - ThrowTheSwitch.org - Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams - SPDX-License-Identifier: MIT -========================================================================= */ - -#include "unity_fixture.h" -#include -#include - -TEST_GROUP(UnityFixture); - -TEST_SETUP(UnityFixture) -{ -} - -TEST_TEAR_DOWN(UnityFixture) -{ -} - -static int* pointer1 = 0; -static int* pointer2 = (int*)2; -static int* pointer3 = (int*)3; -static int int1; -static int int2; -static int int3; -static int int4; - -TEST(UnityFixture, PointerSetting) -{ - TEST_ASSERT_POINTERS_EQUAL(pointer1, 0); - UT_PTR_SET(pointer1, &int1); - UT_PTR_SET(pointer2, &int2); - UT_PTR_SET(pointer3, &int3); - TEST_ASSERT_POINTERS_EQUAL(pointer1, &int1); - TEST_ASSERT_POINTERS_EQUAL(pointer2, &int2); - TEST_ASSERT_POINTERS_EQUAL(pointer3, &int3); - UT_PTR_SET(pointer1, &int4); - UnityPointer_UndoAllSets(); - TEST_ASSERT_POINTERS_EQUAL(pointer1, 0); - TEST_ASSERT_POINTERS_EQUAL(pointer2, (int*)2); - TEST_ASSERT_POINTERS_EQUAL(pointer3, (int*)3); -} - -static char *p1; -static char *p2; - -TEST(UnityFixture, PointerSet) -{ - char c1; - char c2; - char newC1; - char newC2; - p1 = &c1; - p2 = &c2; - - UnityPointer_Init(); - UT_PTR_SET(p1, &newC1); - UT_PTR_SET(p2, &newC2); - TEST_ASSERT_POINTERS_EQUAL(&newC1, p1); - TEST_ASSERT_POINTERS_EQUAL(&newC2, p2); - UnityPointer_UndoAllSets(); - TEST_ASSERT_POINTERS_EQUAL(&c1, p1); - TEST_ASSERT_POINTERS_EQUAL(&c2, p2); -} - -TEST(UnityFixture, FreeNULLSafety) -{ - free(NULL); -} - -TEST(UnityFixture, ConcludeTestIncrementsFailCount) -{ - UNITY_UINT savedFails = Unity.TestFailures; - UNITY_UINT savedIgnores = Unity.TestIgnores; - Unity.CurrentTestFailed = 1; - UnityConcludeFixtureTest(); /* Resets TestFailed for this test to pass */ - Unity.CurrentTestIgnored = 1; - UnityConcludeFixtureTest(); /* Resets TestIgnored */ - TEST_ASSERT_EQUAL(savedFails + 1, Unity.TestFailures); - TEST_ASSERT_EQUAL(savedIgnores + 1, Unity.TestIgnores); - Unity.TestFailures = savedFails; - Unity.TestIgnores = savedIgnores; -} - -/*------------------------------------------------------------ */ - -TEST_GROUP(UnityCommandOptions); - -static int savedVerbose; -static unsigned int savedRepeat; -static const char* savedName; -static const char* savedGroup; - -TEST_SETUP(UnityCommandOptions) -{ - savedVerbose = UnityFixture.Verbose; - savedRepeat = UnityFixture.RepeatCount; - savedName = UnityFixture.NameFilter; - savedGroup = UnityFixture.GroupFilter; -} - -TEST_TEAR_DOWN(UnityCommandOptions) -{ - UnityFixture.Verbose = savedVerbose; - UnityFixture.RepeatCount= savedRepeat; - UnityFixture.NameFilter = savedName; - UnityFixture.GroupFilter = savedGroup; -} - - -static const char* noOptions[] = { - "testrunner.exe" -}; - -TEST(UnityCommandOptions, DefaultOptions) -{ - UnityGetCommandLineOptions(1, noOptions); - TEST_ASSERT_EQUAL(0, UnityFixture.Verbose); - TEST_ASSERT_POINTERS_EQUAL(0, UnityFixture.GroupFilter); - TEST_ASSERT_POINTERS_EQUAL(0, UnityFixture.NameFilter); - TEST_ASSERT_EQUAL(1, UnityFixture.RepeatCount); -} - -static const char* verbose[] = { - "testrunner.exe", - "-v" -}; - -TEST(UnityCommandOptions, OptionVerbose) -{ - TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(2, verbose)); - TEST_ASSERT_EQUAL(1, UnityFixture.Verbose); -} - -static const char* group[] = { - "testrunner.exe", - "-g", "groupname" -}; - -TEST(UnityCommandOptions, OptionSelectTestByGroup) -{ - TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(3, group)); - STRCMP_EQUAL("groupname", UnityFixture.GroupFilter); -} - -static const char* name[] = { - "testrunner.exe", - "-n", "testname" -}; - -TEST(UnityCommandOptions, OptionSelectTestByName) -{ - TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(3, name)); - STRCMP_EQUAL("testname", UnityFixture.NameFilter); -} - -static const char* repeat[] = { - "testrunner.exe", - "-r", "99" -}; - -TEST(UnityCommandOptions, OptionSelectRepeatTestsDefaultCount) -{ - TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(2, repeat)); - TEST_ASSERT_EQUAL(2, UnityFixture.RepeatCount); -} - -TEST(UnityCommandOptions, OptionSelectRepeatTestsSpecificCount) -{ - TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(3, repeat)); - TEST_ASSERT_EQUAL(99, UnityFixture.RepeatCount); -} - -static const char* multiple[] = { - "testrunner.exe", - "-v", - "-g", "groupname", - "-n", "testname", - "-r", "98" -}; - -TEST(UnityCommandOptions, MultipleOptions) -{ - TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(8, multiple)); - TEST_ASSERT_EQUAL(1, UnityFixture.Verbose); - STRCMP_EQUAL("groupname", UnityFixture.GroupFilter); - STRCMP_EQUAL("testname", UnityFixture.NameFilter); - TEST_ASSERT_EQUAL(98, UnityFixture.RepeatCount); -} - -static const char* dashRNotLast[] = { - "testrunner.exe", - "-v", - "-g", "gggg", - "-r", - "-n", "tttt", -}; - -TEST(UnityCommandOptions, MultipleOptionsDashRNotLastAndNoValueSpecified) -{ - TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(7, dashRNotLast)); - TEST_ASSERT_EQUAL(1, UnityFixture.Verbose); - STRCMP_EQUAL("gggg", UnityFixture.GroupFilter); - STRCMP_EQUAL("tttt", UnityFixture.NameFilter); - TEST_ASSERT_EQUAL(2, UnityFixture.RepeatCount); -} - -static const char* unknownCommand[] = { - "testrunner.exe", - "-v", - "-g", "groupname", - "-n", "testname", - "-r", "98", - "-z" -}; -TEST(UnityCommandOptions, UnknownCommandIsIgnored) -{ - TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(9, unknownCommand)); - TEST_ASSERT_EQUAL(1, UnityFixture.Verbose); - STRCMP_EQUAL("groupname", UnityFixture.GroupFilter); - STRCMP_EQUAL("testname", UnityFixture.NameFilter); - TEST_ASSERT_EQUAL(98, UnityFixture.RepeatCount); -} - -TEST(UnityCommandOptions, GroupOrNameFilterWithoutStringFails) -{ - TEST_ASSERT_EQUAL(1, UnityGetCommandLineOptions(3, unknownCommand)); - TEST_ASSERT_EQUAL(1, UnityGetCommandLineOptions(5, unknownCommand)); - TEST_ASSERT_EQUAL(1, UnityMain(3, unknownCommand, NULL)); -} - -TEST(UnityCommandOptions, GroupFilterReallyFilters) -{ - UNITY_UINT saved = Unity.NumberOfTests; - TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(4, unknownCommand)); - UnityIgnoreTest(NULL, "non-matching", NULL); - TEST_ASSERT_EQUAL(saved, Unity.NumberOfTests); -} - -IGNORE_TEST(UnityCommandOptions, TestShouldBeIgnored) -{ - TEST_FAIL_MESSAGE("This test should not run!"); -} diff --git a/subprojects/unity/extras/fixture/test/unity_fixture_TestRunner.c b/subprojects/unity/extras/fixture/test/unity_fixture_TestRunner.c deleted file mode 100644 index ec92663f62..0000000000 --- a/subprojects/unity/extras/fixture/test/unity_fixture_TestRunner.c +++ /dev/null @@ -1,32 +0,0 @@ -/* ========================================================================= - Unity - A Test Framework for C - ThrowTheSwitch.org - Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams - SPDX-License-Identifier: MIT -========================================================================= */ - -#include "unity_fixture.h" - -TEST_GROUP_RUNNER(UnityFixture) -{ - RUN_TEST_CASE(UnityFixture, PointerSetting); - RUN_TEST_CASE(UnityFixture, PointerSet); - RUN_TEST_CASE(UnityFixture, FreeNULLSafety); - RUN_TEST_CASE(UnityFixture, ConcludeTestIncrementsFailCount); -} - -TEST_GROUP_RUNNER(UnityCommandOptions) -{ - RUN_TEST_CASE(UnityCommandOptions, DefaultOptions); - RUN_TEST_CASE(UnityCommandOptions, OptionVerbose); - RUN_TEST_CASE(UnityCommandOptions, OptionSelectTestByGroup); - RUN_TEST_CASE(UnityCommandOptions, OptionSelectTestByName); - RUN_TEST_CASE(UnityCommandOptions, OptionSelectRepeatTestsDefaultCount); - RUN_TEST_CASE(UnityCommandOptions, OptionSelectRepeatTestsSpecificCount); - RUN_TEST_CASE(UnityCommandOptions, MultipleOptions); - RUN_TEST_CASE(UnityCommandOptions, MultipleOptionsDashRNotLastAndNoValueSpecified); - RUN_TEST_CASE(UnityCommandOptions, UnknownCommandIsIgnored); - RUN_TEST_CASE(UnityCommandOptions, GroupOrNameFilterWithoutStringFails); - RUN_TEST_CASE(UnityCommandOptions, GroupFilterReallyFilters); - RUN_TEST_CASE(UnityCommandOptions, TestShouldBeIgnored); -} diff --git a/subprojects/unity/extras/memory/readme.md b/subprojects/unity/extras/memory/readme.md deleted file mode 100644 index ea8b9cf706..0000000000 --- a/subprojects/unity/extras/memory/readme.md +++ /dev/null @@ -1,42 +0,0 @@ -# Unity Memory - -This Framework is an optional add-on to Unity. -By including unity.h and then unity_memory.h, you have the added ability to track malloc and free calls. -This addon requires that the stdlib functions be overridden by its own defines. -These defines will still malloc / realloc / free etc, but will also track the calls in order to ensure that you don't have any memory leaks in your programs. - -Note that this is only useful in situations where a unit is in charge of both the allocation and deallocation of memory. -When it is not symmetric, unit testing can report a number of false failures. -A more advanced runtime tool is required to track complete system memory handling. - -## Module API - -### `UnityMalloc_StartTest` and `UnityMalloc_EndTest` - -These must be called at the beginning and end of each test. -For simplicity, they can be added to `setUp` and `tearDown` in order to do their job. -When using the test runner generator scripts, these will be automatically added to the runner whenever unity_memory.h is included. - -### `UnityMalloc_MakeMallocFailAfterCount` - -This can be called from the tests themselves. -Passing this function a number will force the reference counter to start keeping track of malloc calls. -During that test, if the number of malloc calls exceeds the number given, malloc will immediately start returning `NULL`. -This allows you to test error conditions. -Think of it as a simplified mock. - -## Configuration - -### `UNITY_MALLOC` and `UNITY_FREE` - -By default, this module tries to use the real stdlib `malloc` and `free` internally. -If you would prefer it to use something else, like FreeRTOS's `pvPortMalloc` and `pvPortFree`, then you can use these defines to make it so. - -### `UNITY_EXCLUDE_STDLIB_MALLOC` - -If you would like this library to ignore stdlib or other heap engines completely, and manage the memory on its own, then define this. All memory will be handled internally (and at likely lower overhead). -Note that this is not a very featureful memory manager, but is sufficient for most testing purposes. - -### `UNITY_INTERNAL_HEAP_SIZE_BYTES` - -When using the built-in memory manager (see `UNITY_EXCLUDE_STDLIB_MALLOC`) this define allows you to set the heap size this library will use to manage the memory. diff --git a/subprojects/unity/extras/memory/src/meson.build b/subprojects/unity/extras/memory/src/meson.build deleted file mode 100644 index 650ba32d91..0000000000 --- a/subprojects/unity/extras/memory/src/meson.build +++ /dev/null @@ -1,9 +0,0 @@ -unity_inc += include_directories('.') -unity_src += files('unity_memory.c') - -if not meson.is_subproject() - install_headers( - 'unity_memory.h', - subdir: meson.project_name() - ) -endif diff --git a/subprojects/unity/extras/memory/src/unity_memory.c b/subprojects/unity/extras/memory/src/unity_memory.c deleted file mode 100644 index e9eaae35a6..0000000000 --- a/subprojects/unity/extras/memory/src/unity_memory.c +++ /dev/null @@ -1,203 +0,0 @@ -/* ========================================================================= - Unity - A Test Framework for C - ThrowTheSwitch.org - Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams - SPDX-License-Identifier: MIT -========================================================================= */ - -#include "unity.h" -#include "unity_memory.h" -#include - -#define MALLOC_DONT_FAIL -1 -static int malloc_count; -static int malloc_fail_countdown = MALLOC_DONT_FAIL; - -void UnityMalloc_StartTest(void) -{ - malloc_count = 0; - malloc_fail_countdown = MALLOC_DONT_FAIL; -} - -void UnityMalloc_EndTest(void) -{ - malloc_fail_countdown = MALLOC_DONT_FAIL; - if (malloc_count != 0) - { - UNITY_TEST_FAIL(Unity.CurrentTestLineNumber, "This test leaks!"); - } -} - -void UnityMalloc_MakeMallocFailAfterCount(int countdown) -{ - malloc_fail_countdown = countdown; -} - -/* These definitions are always included from unity_fixture_malloc_overrides.h */ -/* We undef to use them or avoid conflict with per the C standard */ -#undef malloc -#undef free -#undef calloc -#undef realloc - -#ifdef UNITY_EXCLUDE_STDLIB_MALLOC -static unsigned char unity_heap[UNITY_INTERNAL_HEAP_SIZE_BYTES]; -static size_t heap_index; -#else -#include -#endif - -typedef struct GuardBytes -{ - size_t size; - size_t guard_space; -} Guard; - -#define UNITY_MALLOC_ALIGNMENT (UNITY_POINTER_WIDTH / 8) -static const char end[] = "END"; - -static size_t unity_size_round_up(size_t size) -{ - size_t rounded_size; - - rounded_size = ((size + UNITY_MALLOC_ALIGNMENT - 1) / UNITY_MALLOC_ALIGNMENT) * UNITY_MALLOC_ALIGNMENT; - - return rounded_size; -} - -void* unity_malloc(size_t size) -{ - char* mem; - Guard* guard; - size_t total_size; - - total_size = sizeof(Guard) + unity_size_round_up(size + sizeof(end)); - - if (malloc_fail_countdown != MALLOC_DONT_FAIL) - { - if (malloc_fail_countdown == 0) - return NULL; - malloc_fail_countdown--; - } - - if (size == 0) return NULL; -#ifdef UNITY_EXCLUDE_STDLIB_MALLOC - if (heap_index + total_size > UNITY_INTERNAL_HEAP_SIZE_BYTES) - { - guard = NULL; - } - else - { - /* We know we can get away with this cast because we aligned memory already */ - guard = (Guard*)(void*)(&unity_heap[heap_index]); - heap_index += total_size; - } -#else - guard = (Guard*)UNITY_MALLOC(total_size); -#endif - if (guard == NULL) return NULL; - malloc_count++; - guard->size = size; - guard->guard_space = 0; - mem = (char*)&(guard[1]); - memcpy(&mem[size], end, sizeof(end)); - - return (void*)mem; -} - -static int isOverrun(void* mem) -{ - Guard* guard = (Guard*)mem; - char* memAsChar = (char*)mem; - guard--; - - return guard->guard_space != 0 || strcmp(&memAsChar[guard->size], end) != 0; -} - -static void release_memory(void* mem) -{ - Guard* guard = (Guard*)mem; - guard--; - - malloc_count--; -#ifdef UNITY_EXCLUDE_STDLIB_MALLOC - { - size_t block_size; - - block_size = unity_size_round_up(guard->size + sizeof(end)); - - if (mem == unity_heap + heap_index - block_size) - { - heap_index -= (sizeof(Guard) + block_size); - } - } -#else - UNITY_FREE(guard); -#endif -} - -void unity_free(void* mem) -{ - int overrun; - - if (mem == NULL) - { - return; - } - - overrun = isOverrun(mem); - release_memory(mem); - if (overrun) - { - UNITY_TEST_FAIL(Unity.CurrentTestLineNumber, "Buffer overrun detected during free()"); - } -} - -void* unity_calloc(size_t num, size_t size) -{ - void* mem = unity_malloc(num * size); - if (mem == NULL) return NULL; - memset(mem, 0, num * size); - return mem; -} - -void* unity_realloc(void* oldMem, size_t size) -{ - Guard* guard = (Guard*)oldMem; - void* newMem; - - if (oldMem == NULL) return unity_malloc(size); - - guard--; - if (isOverrun(oldMem)) - { - release_memory(oldMem); - UNITY_TEST_FAIL(Unity.CurrentTestLineNumber, "Buffer overrun detected during realloc()"); - } - - if (size == 0) - { - release_memory(oldMem); - return NULL; - } - - if (guard->size >= size) return oldMem; - -#ifdef UNITY_EXCLUDE_STDLIB_MALLOC /* Optimization if memory is expandable */ - { - size_t old_total_size = unity_size_round_up(guard->size + sizeof(end)); - - if ((oldMem == unity_heap + heap_index - old_total_size) && - ((heap_index - old_total_size + unity_size_round_up(size + sizeof(end))) <= UNITY_INTERNAL_HEAP_SIZE_BYTES)) - { - release_memory(oldMem); /* Not thread-safe, like unity_heap generally */ - return unity_malloc(size); /* No memcpy since data is in place */ - } - } -#endif - newMem = unity_malloc(size); - if (newMem == NULL) return NULL; /* Do not release old memory */ - memcpy(newMem, oldMem, guard->size); - release_memory(oldMem); - return newMem; -} diff --git a/subprojects/unity/extras/memory/src/unity_memory.h b/subprojects/unity/extras/memory/src/unity_memory.h deleted file mode 100644 index 70a7f25fc1..0000000000 --- a/subprojects/unity/extras/memory/src/unity_memory.h +++ /dev/null @@ -1,61 +0,0 @@ -/* ========================================================================= - Unity - A Test Framework for C - ThrowTheSwitch.org - Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams - SPDX-License-Identifier: MIT -========================================================================= */ - -#ifndef UNITY_MEMORY_OVERRIDES_H_ -#define UNITY_MEMORY_OVERRIDES_H_ - -#ifdef __cplusplus -extern "C" -{ -#endif - -#include - -#ifdef UNITY_EXCLUDE_STDLIB_MALLOC -/* Define this macro to remove the use of stdlib.h, malloc, and free. - * Many embedded systems do not have a heap or malloc/free by default. - * This internal unity_malloc() provides allocated memory deterministically from - * the end of an array only, unity_free() only releases from end-of-array, - * blocks are not coalesced, and memory not freed in LIFO order is stranded. */ - #ifndef UNITY_INTERNAL_HEAP_SIZE_BYTES - #define UNITY_INTERNAL_HEAP_SIZE_BYTES 256 - #endif -#endif - -/* These functions are used by Unity to allocate and release memory - * on the heap and can be overridden with platform-specific implementations. - * For example, when using FreeRTOS UNITY_MALLOC becomes pvPortMalloc() - * and UNITY_FREE becomes vPortFree(). */ -#if !defined(UNITY_MALLOC) || !defined(UNITY_FREE) - #include - #define UNITY_MALLOC(size) malloc(size) - #define UNITY_FREE(ptr) free(ptr) -#else - extern void* UNITY_MALLOC(size_t size); - extern void UNITY_FREE(void* ptr); -#endif - -#define malloc unity_malloc -#define calloc unity_calloc -#define realloc unity_realloc -#define free unity_free - -void* unity_malloc(size_t size); -void* unity_calloc(size_t num, size_t size); -void* unity_realloc(void * oldMem, size_t size); -void unity_free(void * mem); - -/* You must compile with malloc replacement, as defined in unity_fixture_malloc_overrides.h */ -void UnityMalloc_StartTest(void); -void UnityMalloc_EndTest(void); -void UnityMalloc_MakeMallocFailAfterCount(int countdown); - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/subprojects/unity/extras/memory/test/Makefile b/subprojects/unity/extras/memory/test/Makefile deleted file mode 100644 index 790ab393ce..0000000000 --- a/subprojects/unity/extras/memory/test/Makefile +++ /dev/null @@ -1,85 +0,0 @@ -# ========================================================================= -# Unity - A Test Framework for C -# ThrowTheSwitch.org -# Copyright (c) 2007-24 Mike Karlesky, Mark VanderVoord, & Greg Williams -# SPDX-License-Identifier: MIT -# ========================================================================= - -CC = gcc -ifeq ($(shell uname -s), Darwin) -CC = clang -endif -#DEBUG = -O0 -g -CFLAGS += -std=c99 -pedantic -Wall -Wextra -Werror -CFLAGS += $(DEBUG) -DEFINES = -D UNITY_OUTPUT_CHAR=UnityOutputCharSpy_OutputChar -ifeq ($(OS),Windows_NT) - DEFINES += -D UNITY_OUTPUT_CHAR_HEADER_DECLARATION=UnityOutputCharSpy_OutputChar(int) -else - DEFINES += -D UNITY_OUTPUT_CHAR_HEADER_DECLARATION=UnityOutputCharSpy_OutputChar\(int\) -endif -SRC = ../src/unity_memory.c \ - ../../../src/unity.c \ - unity_memory_Test.c \ - unity_memory_TestRunner.c \ - unity_output_Spy.c \ - -INC_DIR = -I../src -I../../../src/ -BUILD_DIR = ../build -TARGET = ../build/memory_tests.exe - -all: default noStdlibMalloc 32bits - -default: $(BUILD_DIR) - $(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -D UNITY_SUPPORT_64 - @ echo "default build" - ./$(TARGET) - -32bits: $(BUILD_DIR) - $(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -m32 - @ echo "32bits build" - ./$(TARGET) - -noStdlibMalloc: $(BUILD_DIR) - $(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -D UNITY_EXCLUDE_STDLIB_MALLOC - @ echo "build with noStdlibMalloc" - ./$(TARGET) - -C89: CFLAGS += -D UNITY_EXCLUDE_STDINT_H # C89 did not have type 'long long', -C89: $(BUILD_DIR) - $(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -std=c89 && ./$(TARGET) - $(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -D UNITY_EXCLUDE_STDLIB_MALLOC -std=c89 - ./$(TARGET) - -$(BUILD_DIR): - mkdir -p $(BUILD_DIR) - -clean: - rm -f $(TARGET) $(BUILD_DIR)/*.gc* - -cov: $(BUILD_DIR) - cd $(BUILD_DIR) && \ - $(CC) $(DEFINES) $(foreach i, $(SRC), ../test/$(i)) $(INC_DIR) -o $(TARGET) -fprofile-arcs -ftest-coverage - rm -f $(BUILD_DIR)/*.gcda - ./$(TARGET) > /dev/null ; ./$(TARGET) -v > /dev/null - cd $(BUILD_DIR) && \ - gcov unity_memory.c | head -3 - grep '###' $(BUILD_DIR)/unity_memory.c.gcov -C2 || true # Show uncovered lines - -# These extended flags DO get included before any target build runs -CFLAGS += -Wbad-function-cast -CFLAGS += -Wcast-qual -CFLAGS += -Wconversion -CFLAGS += -Wformat=2 -CFLAGS += -Wmissing-prototypes -CFLAGS += -Wold-style-definition -CFLAGS += -Wpointer-arith -CFLAGS += -Wshadow -CFLAGS += -Wstrict-overflow=5 -CFLAGS += -Wstrict-prototypes -CFLAGS += -Wswitch-default -CFLAGS += -Wundef -CFLAGS += -Wno-error=undef # Warning only, this should not stop the build -CFLAGS += -Wunreachable-code -CFLAGS += -Wunused -CFLAGS += -fstrict-aliasing diff --git a/subprojects/unity/extras/memory/test/unity_memory_Test.c b/subprojects/unity/extras/memory/test/unity_memory_Test.c deleted file mode 100644 index b66e6deb6d..0000000000 --- a/subprojects/unity/extras/memory/test/unity_memory_Test.c +++ /dev/null @@ -1,326 +0,0 @@ -/* ========================================================================= - Unity - A Test Framework for C - ThrowTheSwitch.org - Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams - SPDX-License-Identifier: MIT -========================================================================= */ - -#include "unity.h" -#include "unity_memory.h" -#include "unity_output_Spy.h" -#include -#include - -/* This test module includes the following tests: */ - -void test_ForceMallocFail(void); -void test_ReallocSmallerIsUnchanged(void); -void test_ReallocSameIsUnchanged(void); -void test_ReallocLargerNeeded(void); -void test_ReallocNullPointerIsLikeMalloc(void); -void test_ReallocSizeZeroFreesMemAndReturnsNullPointer(void); -void test_CallocFillsWithZero(void); -void test_FreeNULLSafety(void); -void test_DetectsLeak(void); -void test_BufferOverrunFoundDuringFree(void); -void test_BufferOverrunFoundDuringRealloc(void); -void test_BufferGuardWriteFoundDuringFree(void); -void test_BufferGuardWriteFoundDuringRealloc(void); -void test_MallocPastBufferFails(void); -void test_CallocPastBufferFails(void); -void test_MallocThenReallocGrowsMemoryInPlace(void); -void test_ReallocFailDoesNotFreeMem(void); - -/* It makes use of the following features */ -void setUp(void); -void tearDown(void); - -/* Let's Go! */ -void setUp(void) -{ -#ifdef UNITY_EXCLUDE_STDLIB_MALLOC - UnityOutputCharSpy_Create(200); -#else - UnityOutputCharSpy_Create(1000); -#endif - UnityMalloc_StartTest(); -} - -void tearDown(void) -{ - UnityMalloc_EndTest(); - UnityOutputCharSpy_Destroy(); -} - -void test_ForceMallocFail(void) -{ - void* m; - void* mfails; - UnityMalloc_MakeMallocFailAfterCount(1); - m = malloc(10); - TEST_ASSERT_NOT_NULL(m); - mfails = malloc(10); - TEST_ASSERT_EQUAL_PTR(0, mfails); - free(m); -} - -void test_ReallocSmallerIsUnchanged(void) -{ - void* m1 = malloc(10); - void* m2 = realloc(m1, 5); - TEST_ASSERT_NOT_NULL(m1); - TEST_ASSERT_EQUAL_PTR(m1, m2); - free(m2); -} - -void test_ReallocSameIsUnchanged(void) -{ - void* m1 = malloc(10); - void* m2 = realloc(m1, 10); - TEST_ASSERT_NOT_NULL(m1); - TEST_ASSERT_EQUAL_PTR(m1, m2); - free(m2); -} - -void test_ReallocLargerNeeded(void) -{ - void* m2; - void* m1 = malloc(10); - TEST_ASSERT_NOT_NULL(m1); - strcpy((char*)m1, "123456789"); - m2 = realloc(m1, 15); - TEST_ASSERT_EQUAL_STRING("123456789", m2); - free(m2); -} - -void test_ReallocNullPointerIsLikeMalloc(void) -{ - void* m = realloc(0, 15); - TEST_ASSERT_NOT_NULL(m); - free(m); -} - -void test_ReallocSizeZeroFreesMemAndReturnsNullPointer(void) -{ - void* m1 = malloc(10); - void* m2 = realloc(m1, 0); - TEST_ASSERT_EQUAL_PTR(0, m2); -} - -void test_CallocFillsWithZero(void) -{ - void* m = calloc(3, sizeof(char)); - char* s = (char*)m; - TEST_ASSERT_NOT_NULL(m); - TEST_ASSERT_EQUAL_HEX8(0, s[0]); - TEST_ASSERT_EQUAL_HEX8(0, s[1]); - TEST_ASSERT_EQUAL_HEX8(0, s[2]); - free(m); -} - -void test_FreeNULLSafety(void) -{ - free(NULL); -} - -/*------------------------------------------------------------ */ - -#define EXPECT_ABORT_BEGIN \ - { \ - jmp_buf TestAbortFrame; \ - memcpy(TestAbortFrame, Unity.AbortFrame, sizeof(jmp_buf)); \ - if (TEST_PROTECT()) \ - { - -#define EXPECT_ABORT_END \ - } \ - memcpy(Unity.AbortFrame, TestAbortFrame, sizeof(jmp_buf)); \ - } - -/* This tricky set of defines lets us see if we are using the Spy, returns 1 if true */ -#ifdef __STDC_VERSION__ - -#ifdef UNITY_SUPPORT_VARIADIC_MACROS -#define USING_SPY_AS(a) EXPAND_AND_USE_2ND(ASSIGN_VALUE(a), 0) -#define ASSIGN_VALUE(a) VAL_##a -#define VAL_UnityOutputCharSpy_OutputChar 0, 1 -#define EXPAND_AND_USE_2ND(a, b) SECOND_PARAM(a, b, throwaway) -#define SECOND_PARAM(a, b, ...) b -#if USING_SPY_AS(UNITY_OUTPUT_CHAR) - #define USING_OUTPUT_SPY /* UNITY_OUTPUT_CHAR = UnityOutputCharSpy_OutputChar */ -#endif -#endif /* UNITY_SUPPORT_VARIADIC_MACROS */ - -#else /* __STDC_VERSION__ else */ - -#define UnityOutputCharSpy_OutputChar 42 -#if UNITY_OUTPUT_CHAR == UnityOutputCharSpy_OutputChar /* Works if no -Wundef -Werror */ - #define USING_OUTPUT_SPY -#endif -#undef UnityOutputCharSpy_OutputChar - -#endif /* __STDC_VERSION__ */ - -void test_DetectsLeak(void) -{ -#ifdef USING_OUTPUT_SPY - void* m = malloc(10); - TEST_ASSERT_NOT_NULL(m); - UnityOutputCharSpy_Enable(1); - EXPECT_ABORT_BEGIN - UnityMalloc_EndTest(); - EXPECT_ABORT_END - UnityOutputCharSpy_Enable(0); - Unity.CurrentTestFailed = 0; - TEST_ASSERT_NOT_NULL(strstr(UnityOutputCharSpy_Get(), "This test leaks!")); - free(m); -#else - TEST_IGNORE_MESSAGE("Enable USING_OUTPUT_SPY To Run This Test"); -#endif -} - -void test_BufferOverrunFoundDuringFree(void) -{ -#ifdef USING_OUTPUT_SPY - void* m = malloc(10); - char* s = (char*)m; - TEST_ASSERT_NOT_NULL(m); - s[10] = (char)0xFF; - UnityOutputCharSpy_Enable(1); - EXPECT_ABORT_BEGIN - free(m); - EXPECT_ABORT_END - UnityOutputCharSpy_Enable(0); - Unity.CurrentTestFailed = 0; - TEST_ASSERT_NOT_NULL(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during free()")); -#else - TEST_IGNORE_MESSAGE("Enable USING_OUTPUT_SPY To Run This Test"); -#endif -} - -void test_BufferOverrunFoundDuringRealloc(void) -{ -#ifdef USING_OUTPUT_SPY - void* m = malloc(10); - char* s = (char*)m; - TEST_ASSERT_NOT_NULL(m); - s[10] = (char)0xFF; - UnityOutputCharSpy_Enable(1); - EXPECT_ABORT_BEGIN - m = realloc(m, 100); - EXPECT_ABORT_END - UnityOutputCharSpy_Enable(0); - Unity.CurrentTestFailed = 0; - TEST_ASSERT_NOT_NULL(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during realloc()")); -#else - TEST_IGNORE_MESSAGE("Enable USING_OUTPUT_SPY To Run This Test"); -#endif -} - -void test_BufferGuardWriteFoundDuringFree(void) -{ -#ifdef USING_OUTPUT_SPY - void* m = malloc(10); - char* s = (char*)m; - TEST_ASSERT_NOT_NULL(m); - s[-1] = (char)0x00; /* Will not detect 0 */ - s[-2] = (char)0x01; - UnityOutputCharSpy_Enable(1); - EXPECT_ABORT_BEGIN - free(m); - EXPECT_ABORT_END - UnityOutputCharSpy_Enable(0); - Unity.CurrentTestFailed = 0; - TEST_ASSERT_NOT_NULL(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during free()")); -#else - TEST_IGNORE_MESSAGE("Enable USING_OUTPUT_SPY To Run This Test"); -#endif -} - -void test_BufferGuardWriteFoundDuringRealloc(void) -{ -#ifdef USING_OUTPUT_SPY - void* m = malloc(10); - char* s = (char*)m; - TEST_ASSERT_NOT_NULL(m); - s[-1] = (char)0x0A; - UnityOutputCharSpy_Enable(1); - EXPECT_ABORT_BEGIN - m = realloc(m, 100); - EXPECT_ABORT_END - UnityOutputCharSpy_Enable(0); - Unity.CurrentTestFailed = 0; - TEST_ASSERT_NOT_NULL(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during realloc()")); -#else - TEST_IGNORE_MESSAGE("Enable USING_OUTPUT_SPY To Run This Test"); -#endif -} - -/*------------------------------------------------------------ */ - -#define TEST_ASSERT_MEMORY_ALL_FREE_LIFO_ORDER(first_mem_ptr, ptr) \ - ptr = malloc(10); free(ptr); \ - TEST_ASSERT_EQUAL_PTR_MESSAGE(first_mem_ptr, ptr, "Memory was stranded, free in LIFO order"); - -void test_MallocPastBufferFails(void) -{ -#ifdef UNITY_EXCLUDE_STDLIB_MALLOC - void* m = malloc(UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 1); - void* n = malloc(UNITY_INTERNAL_HEAP_SIZE_BYTES/2); - free(m); - TEST_ASSERT_NOT_NULL(m); - TEST_ASSERT_NULL(n); - TEST_ASSERT_MEMORY_ALL_FREE_LIFO_ORDER(m, n); -#else - TEST_IGNORE_MESSAGE("Enable UNITY_EXCLUDE_STDLIB_MALLOC to Run This Test"); -#endif -} - -void test_CallocPastBufferFails(void) -{ -#ifdef UNITY_EXCLUDE_STDLIB_MALLOC - void* m = calloc(1, UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 1); - void* n = calloc(1, UNITY_INTERNAL_HEAP_SIZE_BYTES/2); - free(m); - TEST_ASSERT_NOT_NULL(m); - TEST_ASSERT_NULL(n); - TEST_ASSERT_MEMORY_ALL_FREE_LIFO_ORDER(m, n); -#else - TEST_IGNORE_MESSAGE("Enable UNITY_EXCLUDE_STDLIB_MALLOC to Run This Test"); -#endif -} - -void test_MallocThenReallocGrowsMemoryInPlace(void) -{ -#ifdef UNITY_EXCLUDE_STDLIB_MALLOC - void* m = malloc(UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 1); - void* n = realloc(m, UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 9); - free(n); - TEST_ASSERT_NOT_NULL(m); - TEST_ASSERT_EQUAL(m, n); - TEST_ASSERT_MEMORY_ALL_FREE_LIFO_ORDER(m, n); -#else - TEST_IGNORE_MESSAGE("Enable UNITY_EXCLUDE_STDLIB_MALLOC to Run This Test"); -#endif -} - -void test_ReallocFailDoesNotFreeMem(void) -{ -#ifdef UNITY_EXCLUDE_STDLIB_MALLOC - void* m = malloc(UNITY_INTERNAL_HEAP_SIZE_BYTES/2); - void* n1 = malloc(10); - void* out_of_mem = realloc(n1, UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 1); - void* n2 = malloc(10); - - free(n2); - if (out_of_mem == NULL) free(n1); - free(m); - - TEST_ASSERT_NOT_NULL(m); /* Got a real memory location */ - TEST_ASSERT_NULL(out_of_mem); /* The realloc should have failed */ - TEST_ASSERT_NOT_EQUAL(n2, n1); /* If n1 != n2 then realloc did not free n1 */ - TEST_ASSERT_MEMORY_ALL_FREE_LIFO_ORDER(m, n2); -#else - TEST_IGNORE_MESSAGE("Enable UNITY_EXCLUDE_STDLIB_MALLOC to Run This Test"); -#endif -} diff --git a/subprojects/unity/extras/memory/test/unity_memory_TestRunner.c b/subprojects/unity/extras/memory/test/unity_memory_TestRunner.c deleted file mode 100644 index 0a8ed3daa8..0000000000 --- a/subprojects/unity/extras/memory/test/unity_memory_TestRunner.c +++ /dev/null @@ -1,50 +0,0 @@ -/* ========================================================================= - Unity - A Test Framework for C - ThrowTheSwitch.org - Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams - SPDX-License-Identifier: MIT -========================================================================= */ - -#include "unity.h" -#include "unity_memory.h" - -extern void test_ForceMallocFail(void); -extern void test_ReallocSmallerIsUnchanged(void); -extern void test_ReallocSameIsUnchanged(void); -extern void test_ReallocLargerNeeded(void); -extern void test_ReallocNullPointerIsLikeMalloc(void); -extern void test_ReallocSizeZeroFreesMemAndReturnsNullPointer(void); -extern void test_CallocFillsWithZero(void); -extern void test_FreeNULLSafety(void); -extern void test_DetectsLeak(void); -extern void test_BufferOverrunFoundDuringFree(void); -extern void test_BufferOverrunFoundDuringRealloc(void); -extern void test_BufferGuardWriteFoundDuringFree(void); -extern void test_BufferGuardWriteFoundDuringRealloc(void); -extern void test_MallocPastBufferFails(void); -extern void test_CallocPastBufferFails(void); -extern void test_MallocThenReallocGrowsMemoryInPlace(void); -extern void test_ReallocFailDoesNotFreeMem(void); - -int main(void) -{ - UnityBegin("unity_memory_Test.c"); - RUN_TEST(test_ForceMallocFail); - RUN_TEST(test_ReallocSmallerIsUnchanged); - RUN_TEST(test_ReallocSameIsUnchanged); - RUN_TEST(test_ReallocLargerNeeded); - RUN_TEST(test_ReallocNullPointerIsLikeMalloc); - RUN_TEST(test_ReallocSizeZeroFreesMemAndReturnsNullPointer); - RUN_TEST(test_CallocFillsWithZero); - RUN_TEST(test_FreeNULLSafety); - RUN_TEST(test_DetectsLeak); - RUN_TEST(test_BufferOverrunFoundDuringFree); - RUN_TEST(test_BufferOverrunFoundDuringRealloc); - RUN_TEST(test_BufferGuardWriteFoundDuringFree); - RUN_TEST(test_BufferGuardWriteFoundDuringRealloc); - RUN_TEST(test_MallocPastBufferFails); - RUN_TEST(test_CallocPastBufferFails); - RUN_TEST(test_MallocThenReallocGrowsMemoryInPlace); - RUN_TEST(test_ReallocFailDoesNotFreeMem); - return UnityEnd(); -} diff --git a/subprojects/unity/extras/memory/test/unity_output_Spy.c b/subprojects/unity/extras/memory/test/unity_output_Spy.c deleted file mode 100644 index 044c5def22..0000000000 --- a/subprojects/unity/extras/memory/test/unity_output_Spy.c +++ /dev/null @@ -1,57 +0,0 @@ -/* ========================================================================= - Unity - A Test Framework for C - ThrowTheSwitch.org - Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams - SPDX-License-Identifier: MIT -========================================================================= */ - -#include "unity.h" -#include "unity_output_Spy.h" - -#include -#include -#include - -static int size; -static int count; -static char* buffer; -static int spy_enable; - -void UnityOutputCharSpy_Create(int s) -{ - size = (s > 0) ? s : 0; - count = 0; - spy_enable = 0; - buffer = malloc((size_t)size); - TEST_ASSERT_NOT_NULL_MESSAGE(buffer, "Internal malloc failed in Spy Create():" __FILE__); - memset(buffer, 0, (size_t)size); -} - -void UnityOutputCharSpy_Destroy(void) -{ - size = 0; - free(buffer); -} - -void UnityOutputCharSpy_OutputChar(int c) -{ - if (spy_enable) - { - if (count < (size-1)) - buffer[count++] = (char)c; - } - else - { - putchar(c); - } -} - -const char * UnityOutputCharSpy_Get(void) -{ - return buffer; -} - -void UnityOutputCharSpy_Enable(int enable) -{ - spy_enable = enable; -} diff --git a/subprojects/unity/extras/memory/test/unity_output_Spy.h b/subprojects/unity/extras/memory/test/unity_output_Spy.h deleted file mode 100644 index 3c2e9b97ef..0000000000 --- a/subprojects/unity/extras/memory/test/unity_output_Spy.h +++ /dev/null @@ -1,17 +0,0 @@ -/* ========================================================================= - Unity - A Test Framework for C - ThrowTheSwitch.org - Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams - SPDX-License-Identifier: MIT -========================================================================= */ - -#ifndef UNITY_OUTPUT_SPY_H -#define UNITY_OUTPUT_SPY_H - -void UnityOutputCharSpy_Create(int s); -void UnityOutputCharSpy_Destroy(void); -void UnityOutputCharSpy_OutputChar(int c); -const char * UnityOutputCharSpy_Get(void); -void UnityOutputCharSpy_Enable(int enable); - -#endif diff --git a/subprojects/unity/library.json b/subprojects/unity/library.json deleted file mode 100644 index 839b5abd35..0000000000 --- a/subprojects/unity/library.json +++ /dev/null @@ -1,25 +0,0 @@ -# ========================================================================= -# Unity - A Test Framework for C -# ThrowTheSwitch.org -# Copyright (c) 2007-24 Mike Karlesky, Mark VanderVoord, & Greg Williams -# SPDX-License-Identifier: MIT -# ========================================================================= - -{ - "name": "Unity", - "version": "2.6.0", - "keywords": "unit-testing, testing, tdd, testing-framework", - "description": "Simple Unit Testing for C", - "homepage": "http://www.throwtheswitch.org/unity", - "license": "MIT", - "repository": { - "type": "git", - "url": "https://github.com/ThrowTheSwitch/Unity.git" - }, - "frameworks": "*", - "platforms": "*", - "headers": "unity.h", - "build": { - "extraScript": "platformio-build.py" - } -} diff --git a/subprojects/unity/meson.build b/subprojects/unity/meson.build deleted file mode 100644 index 6585129c9a..0000000000 --- a/subprojects/unity/meson.build +++ /dev/null @@ -1,80 +0,0 @@ -# -# build script written by : Michael Gene Brockus. -# github repo author: Mike Karlesky, Mark VanderVoord, Greg Williams. -# -# license: MIT -# -project('unity', 'c', - license: 'MIT', - - # Set project version to value extracted from unity.h header - version: run_command( - [ - 'auto/extract_version.py', - 'src/unity.h' - ], - check: true - ).stdout().strip(), - - meson_version: '>=0.47.0', - default_options: [ - 'werror=true', - 'c_std=c11' - ] -) - -build_fixture = get_option('extension_fixture') -build_memory = get_option('extension_memory') -support_double = get_option('support_double') - -unity_args = [] -unity_src = [] -unity_inc = [] - -subdir('src') - -if build_fixture - # Building the fixture extension implies building the memory - # extension. - build_memory = true - subdir('extras/fixture/src') -endif - -if build_memory - subdir('extras/memory/src') -endif - -if support_double - unity_args += '-DUNITY_INCLUDE_DOUBLE' -endif - -unity_lib = static_library(meson.project_name(), - sources: unity_src, - c_args: unity_args, - include_directories: unity_inc, - install: not meson.is_subproject(), -) - -unity_dep = declare_dependency( - link_with: unity_lib, - include_directories: unity_inc -) - -# Generate pkg-config file. -if not meson.is_subproject() - pkg = import('pkgconfig') - pkg.generate( - name: meson.project_name(), - version: meson.project_version(), - libraries: [ unity_lib ], - description: 'C Unit testing framework.' - ) -endif - -# Create a generator that can be used by consumers of our build system to generate -# test runners. -gen_test_runner = generator( - find_program('auto/generate_test_runner.rb'), - output: '@BASENAME@_Runner.c', - arguments: ['@INPUT@', '@OUTPUT@'] -) diff --git a/subprojects/unity/meson_options.txt b/subprojects/unity/meson_options.txt deleted file mode 100644 index 8e66784b80..0000000000 --- a/subprojects/unity/meson_options.txt +++ /dev/null @@ -1,3 +0,0 @@ -option('extension_fixture', type: 'boolean', value: 'false', description: 'Whether to enable the fixture extension.') -option('extension_memory', type: 'boolean', value: 'false', description: 'Whether to enable the memory extension.') -option('support_double', type: 'boolean', value: 'false', description: 'Whether to enable double precision floating point assertions.') diff --git a/subprojects/unity/platformio-build.py b/subprojects/unity/platformio-build.py deleted file mode 100644 index 51251ddd6d..0000000000 --- a/subprojects/unity/platformio-build.py +++ /dev/null @@ -1,24 +0,0 @@ -# ========================================================================= -# Unity - A Test Framework for C -# ThrowTheSwitch.org -# Copyright (c) 2007-24 Mike Karlesky, Mark VanderVoord, & Greg Williams -# SPDX-License-Identifier: MIT -# ========================================================================= - -import os - -Import("env") - -env.Append(CPPDEFINES=["UNITY_INCLUDE_CONFIG_H"]) - -# import "unity_config.h" folder to the library builder -try: - Import("projenv") - - projenv.Append(CPPDEFINES=["UNITY_INCLUDE_CONFIG_H"]) - for p in projenv["CPPPATH"]: - p = projenv.subst(p) - if os.path.isfile(os.path.join(p, "unity_config.h")): - env.Prepend(CPPPATH=[p]) -except: - pass diff --git a/subprojects/unity/src/meson.build b/subprojects/unity/src/meson.build deleted file mode 100644 index 5365227fcc..0000000000 --- a/subprojects/unity/src/meson.build +++ /dev/null @@ -1,17 +0,0 @@ -# -# build script written by : Michael Gene Brockus. -# github repo author: Mike Karlesky, Mark VanderVoord, Greg Williams. -# -# license: MIT -# - -unity_inc += include_directories('.') -unity_src += files('unity.c') - -if not meson.is_subproject() - install_headers( - 'unity.h', - 'unity_internals.h', - subdir: meson.project_name() - ) -endif diff --git a/subprojects/unity/src/unity.c b/subprojects/unity/src/unity.c deleted file mode 100644 index 7fa2dc6306..0000000000 --- a/subprojects/unity/src/unity.c +++ /dev/null @@ -1,2501 +0,0 @@ -/* ========================================================================= - Unity - A Test Framework for C - ThrowTheSwitch.org - Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams - SPDX-License-Identifier: MIT -========================================================================= */ - -#include "unity.h" - -#ifndef UNITY_PROGMEM -#define UNITY_PROGMEM -#endif - -/* If omitted from header, declare overrideable prototypes here so they're ready for use */ -#ifdef UNITY_OMIT_OUTPUT_CHAR_HEADER_DECLARATION -void UNITY_OUTPUT_CHAR(int); -#endif - -/* Helpful macros for us to use here in Assert functions */ -#define UNITY_FAIL_AND_BAIL do { Unity.CurrentTestFailed = 1; UNITY_OUTPUT_FLUSH(); TEST_ABORT(); } while (0) -#define UNITY_IGNORE_AND_BAIL do { Unity.CurrentTestIgnored = 1; UNITY_OUTPUT_FLUSH(); TEST_ABORT(); } while (0) -#define RETURN_IF_FAIL_OR_IGNORE do { if (Unity.CurrentTestFailed || Unity.CurrentTestIgnored) { TEST_ABORT(); } } while (0) - -struct UNITY_STORAGE_T Unity; - -#ifdef UNITY_OUTPUT_COLOR -const char UNITY_PROGMEM UnityStrOk[] = "\033[42mOK\033[0m"; -const char UNITY_PROGMEM UnityStrPass[] = "\033[42mPASS\033[0m"; -const char UNITY_PROGMEM UnityStrFail[] = "\033[41mFAIL\033[0m"; -const char UNITY_PROGMEM UnityStrIgnore[] = "\033[43mIGNORE\033[0m"; -#else -const char UNITY_PROGMEM UnityStrOk[] = "OK"; -const char UNITY_PROGMEM UnityStrPass[] = "PASS"; -const char UNITY_PROGMEM UnityStrFail[] = "FAIL"; -const char UNITY_PROGMEM UnityStrIgnore[] = "IGNORE"; -#endif -static const char UNITY_PROGMEM UnityStrNull[] = "NULL"; -static const char UNITY_PROGMEM UnityStrSpacer[] = ". "; -static const char UNITY_PROGMEM UnityStrExpected[] = " Expected "; -static const char UNITY_PROGMEM UnityStrWas[] = " Was "; -static const char UNITY_PROGMEM UnityStrGt[] = " to be greater than "; -static const char UNITY_PROGMEM UnityStrLt[] = " to be less than "; -static const char UNITY_PROGMEM UnityStrOrEqual[] = "or equal to "; -static const char UNITY_PROGMEM UnityStrNotEqual[] = " to be not equal to "; -static const char UNITY_PROGMEM UnityStrElement[] = " Element "; -static const char UNITY_PROGMEM UnityStrByte[] = " Byte "; -static const char UNITY_PROGMEM UnityStrMemory[] = " Memory Mismatch."; -static const char UNITY_PROGMEM UnityStrDelta[] = " Values Not Within Delta "; -static const char UNITY_PROGMEM UnityStrPointless[] = " You Asked Me To Compare Nothing, Which Was Pointless."; -static const char UNITY_PROGMEM UnityStrNullPointerForExpected[] = " Expected pointer to be NULL"; -static const char UNITY_PROGMEM UnityStrNullPointerForActual[] = " Actual pointer was NULL"; -#ifndef UNITY_EXCLUDE_FLOAT -static const char UNITY_PROGMEM UnityStrNot[] = "Not "; -static const char UNITY_PROGMEM UnityStrInf[] = "Infinity"; -static const char UNITY_PROGMEM UnityStrNegInf[] = "Negative Infinity"; -static const char UNITY_PROGMEM UnityStrNaN[] = "NaN"; -static const char UNITY_PROGMEM UnityStrDet[] = "Determinate"; -static const char UNITY_PROGMEM UnityStrInvalidFloatTrait[] = "Invalid Float Trait"; -#endif -const char UNITY_PROGMEM UnityStrErrShorthand[] = "Unity Shorthand Support Disabled"; -const char UNITY_PROGMEM UnityStrErrFloat[] = "Unity Floating Point Disabled"; -const char UNITY_PROGMEM UnityStrErrDouble[] = "Unity Double Precision Disabled"; -const char UNITY_PROGMEM UnityStrErr64[] = "Unity 64-bit Support Disabled"; -static const char UNITY_PROGMEM UnityStrBreaker[] = "-----------------------"; -static const char UNITY_PROGMEM UnityStrResultsTests[] = " Tests "; -static const char UNITY_PROGMEM UnityStrResultsFailures[] = " Failures "; -static const char UNITY_PROGMEM UnityStrResultsIgnored[] = " Ignored "; -#ifndef UNITY_EXCLUDE_DETAILS -static const char UNITY_PROGMEM UnityStrDetail1Name[] = UNITY_DETAIL1_NAME " "; -static const char UNITY_PROGMEM UnityStrDetail2Name[] = " " UNITY_DETAIL2_NAME " "; -#endif -/*----------------------------------------------- - * Pretty Printers & Test Result Output Handlers - *-----------------------------------------------*/ - -/*-----------------------------------------------*/ -/* Local helper function to print characters. */ -static void UnityPrintChar(const char* pch) -{ - /* printable characters plus CR & LF are printed */ - if ((*pch <= 126) && (*pch >= 32)) - { - UNITY_OUTPUT_CHAR(*pch); - } - /* write escaped carriage returns */ - else if (*pch == 13) - { - UNITY_OUTPUT_CHAR('\\'); - UNITY_OUTPUT_CHAR('r'); - } - /* write escaped line feeds */ - else if (*pch == 10) - { - UNITY_OUTPUT_CHAR('\\'); - UNITY_OUTPUT_CHAR('n'); - } - /* unprintable characters are shown as codes */ - else - { - UNITY_OUTPUT_CHAR('\\'); - UNITY_OUTPUT_CHAR('x'); - UnityPrintNumberHex((UNITY_UINT)*pch, 2); - } -} - -/*-----------------------------------------------*/ -/* Local helper function to print ANSI escape strings e.g. "\033[42m". */ -#ifdef UNITY_OUTPUT_COLOR -static UNITY_UINT UnityPrintAnsiEscapeString(const char* string) -{ - const char* pch = string; - UNITY_UINT count = 0; - - while (*pch && (*pch != 'm')) - { - UNITY_OUTPUT_CHAR(*pch); - pch++; - count++; - } - UNITY_OUTPUT_CHAR('m'); - count++; - - return count; -} -#endif - -/*-----------------------------------------------*/ -void UnityPrint(const char* string) -{ - const char* pch = string; - - if (pch != NULL) - { - while (*pch) - { -#ifdef UNITY_OUTPUT_COLOR - /* print ANSI escape code */ - if ((*pch == 27) && (*(pch + 1) == '[')) - { - pch += UnityPrintAnsiEscapeString(pch); - continue; - } -#endif - UnityPrintChar(pch); - pch++; - } - } -} -/*-----------------------------------------------*/ -void UnityPrintLen(const char* string, const UNITY_UINT32 length) -{ - const char* pch = string; - - if (pch != NULL) - { - while (*pch && ((UNITY_UINT32)(pch - string) < length)) - { - /* printable characters plus CR & LF are printed */ - if ((*pch <= 126) && (*pch >= 32)) - { - UNITY_OUTPUT_CHAR(*pch); - } - /* write escaped carriage returns */ - else if (*pch == 13) - { - UNITY_OUTPUT_CHAR('\\'); - UNITY_OUTPUT_CHAR('r'); - } - /* write escaped line feeds */ - else if (*pch == 10) - { - UNITY_OUTPUT_CHAR('\\'); - UNITY_OUTPUT_CHAR('n'); - } - /* unprintable characters are shown as codes */ - else - { - UNITY_OUTPUT_CHAR('\\'); - UNITY_OUTPUT_CHAR('x'); - UnityPrintNumberHex((UNITY_UINT)*pch, 2); - } - pch++; - } - } -} - -/*-----------------------------------------------*/ -void UnityPrintNumberByStyle(const UNITY_INT number, const UNITY_DISPLAY_STYLE_T style) -{ - if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) - { - if (style == UNITY_DISPLAY_STYLE_CHAR) - { - /* printable characters plus CR & LF are printed */ - UNITY_OUTPUT_CHAR('\''); - if ((number <= 126) && (number >= 32)) - { - UNITY_OUTPUT_CHAR((int)number); - } - /* write escaped carriage returns */ - else if (number == 13) - { - UNITY_OUTPUT_CHAR('\\'); - UNITY_OUTPUT_CHAR('r'); - } - /* write escaped line feeds */ - else if (number == 10) - { - UNITY_OUTPUT_CHAR('\\'); - UNITY_OUTPUT_CHAR('n'); - } - /* unprintable characters are shown as codes */ - else - { - UNITY_OUTPUT_CHAR('\\'); - UNITY_OUTPUT_CHAR('x'); - UnityPrintNumberHex((UNITY_UINT)number, 2); - } - UNITY_OUTPUT_CHAR('\''); - } - else - { - UnityPrintNumber(number); - } - } - else if ((style & UNITY_DISPLAY_RANGE_UINT) == UNITY_DISPLAY_RANGE_UINT) - { - UnityPrintNumberUnsigned((UNITY_UINT)number); - } - else - { - UNITY_OUTPUT_CHAR('0'); - UNITY_OUTPUT_CHAR('x'); - UnityPrintNumberHex((UNITY_UINT)number, (char)((style & 0xF) * 2)); - } -} - -/*-----------------------------------------------*/ -void UnityPrintNumber(const UNITY_INT number_to_print) -{ - UNITY_UINT number = (UNITY_UINT)number_to_print; - - if (number_to_print < 0) - { - /* A negative number, including MIN negative */ - UNITY_OUTPUT_CHAR('-'); - number = (~number) + 1; - } - UnityPrintNumberUnsigned(number); -} - -/*----------------------------------------------- - * basically do an itoa using as little ram as possible */ -void UnityPrintNumberUnsigned(const UNITY_UINT number) -{ - UNITY_UINT divisor = 1; - - /* figure out initial divisor */ - while (number / divisor > 9) - { - divisor *= 10; - } - - /* now mod and print, then divide divisor */ - do - { - UNITY_OUTPUT_CHAR((char)('0' + (number / divisor % 10))); - divisor /= 10; - } while (divisor > 0); -} - -/*-----------------------------------------------*/ -void UnityPrintNumberHex(const UNITY_UINT number, const char nibbles_to_print) -{ - int nibble; - char nibbles = nibbles_to_print; - - if ((unsigned)nibbles > UNITY_MAX_NIBBLES) - { - nibbles = UNITY_MAX_NIBBLES; - } - - while (nibbles > 0) - { - nibbles--; - nibble = (int)(number >> (nibbles * 4)) & 0x0F; - if (nibble <= 9) - { - UNITY_OUTPUT_CHAR((char)('0' + nibble)); - } - else - { - UNITY_OUTPUT_CHAR((char)('A' - 10 + nibble)); - } - } -} - -/*-----------------------------------------------*/ -void UnityPrintMask(const UNITY_UINT mask, const UNITY_UINT number) -{ - UNITY_UINT current_bit = (UNITY_UINT)1 << (UNITY_INT_WIDTH - 1); - UNITY_INT32 i; - - for (i = 0; i < UNITY_INT_WIDTH; i++) - { - if (current_bit & mask) - { - if (current_bit & number) - { - UNITY_OUTPUT_CHAR('1'); - } - else - { - UNITY_OUTPUT_CHAR('0'); - } - } - else - { - UNITY_OUTPUT_CHAR('X'); - } - current_bit = current_bit >> 1; - } -} - -/*-----------------------------------------------*/ -#ifndef UNITY_EXCLUDE_FLOAT_PRINT -/* - * This function prints a floating-point value in a format similar to - * printf("%.7g") on a single-precision machine or printf("%.9g") on a - * double-precision machine. The 7th digit won't always be totally correct - * in single-precision operation (for that level of accuracy, a more - * complicated algorithm would be needed). - */ -void UnityPrintFloat(const UNITY_DOUBLE input_number) -{ -#ifdef UNITY_INCLUDE_DOUBLE - static const int sig_digits = 9; - static const UNITY_INT32 min_scaled = 100000000; - static const UNITY_INT32 max_scaled = 1000000000; -#else - static const int sig_digits = 7; - static const UNITY_INT32 min_scaled = 1000000; - static const UNITY_INT32 max_scaled = 10000000; -#endif - - UNITY_DOUBLE number = input_number; - - /* print minus sign (does not handle negative zero) */ - if (number < 0.0f) - { - UNITY_OUTPUT_CHAR('-'); - number = -number; - } - - /* handle zero, NaN, and +/- infinity */ - if (number == 0.0f) - { - UnityPrint("0"); - } - else if (UNITY_IS_NAN(number)) - { - UnityPrint("nan"); - } - else if (UNITY_IS_INF(number)) - { - UnityPrint("inf"); - } - else - { - UNITY_INT32 n_int = 0; - UNITY_INT32 n; - int exponent = 0; - int decimals; - int digits; - char buf[16] = {0}; - - /* - * Scale up or down by powers of 10. To minimize rounding error, - * start with a factor/divisor of 10^10, which is the largest - * power of 10 that can be represented exactly. Finally, compute - * (exactly) the remaining power of 10 and perform one more - * multiplication or division. - */ - if (number < 1.0f) - { - UNITY_DOUBLE factor = 1.0f; - - while (number < (UNITY_DOUBLE)max_scaled / 1e10f) { number *= 1e10f; exponent -= 10; } - while (number * factor < (UNITY_DOUBLE)min_scaled) { factor *= 10.0f; exponent--; } - - number *= factor; - } - else if (number > (UNITY_DOUBLE)max_scaled) - { - UNITY_DOUBLE divisor = 1.0f; - - while (number > (UNITY_DOUBLE)min_scaled * 1e10f) { number /= 1e10f; exponent += 10; } - while (number / divisor > (UNITY_DOUBLE)max_scaled) { divisor *= 10.0f; exponent++; } - - number /= divisor; - } - else - { - /* - * In this range, we can split off the integer part before - * doing any multiplications. This reduces rounding error by - * freeing up significant bits in the fractional part. - */ - UNITY_DOUBLE factor = 1.0f; - n_int = (UNITY_INT32)number; - number -= (UNITY_DOUBLE)n_int; - - while (n_int < min_scaled) { n_int *= 10; factor *= 10.0f; exponent--; } - - number *= factor; - } - - /* round to nearest integer */ - n = ((UNITY_INT32)(number + number) + 1) / 2; - -#ifndef UNITY_ROUND_TIES_AWAY_FROM_ZERO - /* round to even if exactly between two integers */ - if ((n & 1) && (((UNITY_DOUBLE)n - number) == 0.5f)) - n--; -#endif - - n += n_int; - - if (n >= max_scaled) - { - n = min_scaled; - exponent++; - } - - /* determine where to place decimal point */ - decimals = ((exponent <= 0) && (exponent >= -(sig_digits + 3))) ? (-exponent) : (sig_digits - 1); - exponent += decimals; - - /* truncate trailing zeroes after decimal point */ - while ((decimals > 0) && ((n % 10) == 0)) - { - n /= 10; - decimals--; - } - - /* build up buffer in reverse order */ - digits = 0; - while ((n != 0) || (digits <= decimals)) - { - buf[digits++] = (char)('0' + n % 10); - n /= 10; - } - - /* print out buffer (backwards) */ - 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 */ - -/*-----------------------------------------------*/ -static void UnityTestResultsBegin(const char* file, const UNITY_LINE_TYPE line) -{ -#ifdef UNITY_OUTPUT_FOR_ECLIPSE - UNITY_OUTPUT_CHAR('('); - UnityPrint(file); - UNITY_OUTPUT_CHAR(':'); - UnityPrintNumber((UNITY_INT)line); - UNITY_OUTPUT_CHAR(')'); - UNITY_OUTPUT_CHAR(' '); - UnityPrint(Unity.CurrentTestName); - UNITY_OUTPUT_CHAR(':'); -#else -#ifdef UNITY_OUTPUT_FOR_IAR_WORKBENCH - UnityPrint("'); - UnityPrint(Unity.CurrentTestName); - UnityPrint(" "); -#else -#ifdef UNITY_OUTPUT_FOR_QT_CREATOR - UnityPrint("file://"); - UnityPrint(file); - UNITY_OUTPUT_CHAR(':'); - UnityPrintNumber((UNITY_INT)line); - UNITY_OUTPUT_CHAR(' '); - UnityPrint(Unity.CurrentTestName); - UNITY_OUTPUT_CHAR(':'); -#else - UnityPrint(file); - UNITY_OUTPUT_CHAR(':'); - UnityPrintNumber((UNITY_INT)line); - UNITY_OUTPUT_CHAR(':'); - UnityPrint(Unity.CurrentTestName); - UNITY_OUTPUT_CHAR(':'); -#endif -#endif -#endif -} - -/*-----------------------------------------------*/ -static void UnityTestResultsFailBegin(const UNITY_LINE_TYPE line) -{ - UnityTestResultsBegin(Unity.TestFile, line); - UnityPrint(UnityStrFail); - UNITY_OUTPUT_CHAR(':'); -} - -/*-----------------------------------------------*/ -void UnityConcludeTest(void) -{ - if (Unity.CurrentTestIgnored) - { - Unity.TestIgnores++; - } - else if (!Unity.CurrentTestFailed) - { - UnityTestResultsBegin(Unity.TestFile, Unity.CurrentTestLineNumber); - UnityPrint(UnityStrPass); - } - else - { - Unity.TestFailures++; - } - - Unity.CurrentTestFailed = 0; - Unity.CurrentTestIgnored = 0; - UNITY_PRINT_EXEC_TIME(); - UNITY_PRINT_EOL(); - UNITY_FLUSH_CALL(); -} - -/*-----------------------------------------------*/ -static void UnityAddMsgIfSpecified(const char* msg) -{ -#ifdef UNITY_PRINT_TEST_CONTEXT - UnityPrint(UnityStrSpacer); - UNITY_PRINT_TEST_CONTEXT(); -#endif -#ifndef UNITY_EXCLUDE_DETAILS - if (Unity.CurrentDetail1) - { - UnityPrint(UnityStrSpacer); - UnityPrint(UnityStrDetail1Name); - UnityPrint(Unity.CurrentDetail1); - if (Unity.CurrentDetail2) - { - UnityPrint(UnityStrDetail2Name); - UnityPrint(Unity.CurrentDetail2); - } - } -#endif - if (msg) - { - UnityPrint(UnityStrSpacer); - UnityPrint(msg); - } -} - -/*-----------------------------------------------*/ -static void UnityPrintExpectedAndActualStrings(const char* expected, const char* actual) -{ - UnityPrint(UnityStrExpected); - if (expected != NULL) - { - UNITY_OUTPUT_CHAR('\''); - UnityPrint(expected); - UNITY_OUTPUT_CHAR('\''); - } - else - { - UnityPrint(UnityStrNull); - } - UnityPrint(UnityStrWas); - if (actual != NULL) - { - UNITY_OUTPUT_CHAR('\''); - UnityPrint(actual); - UNITY_OUTPUT_CHAR('\''); - } - else - { - UnityPrint(UnityStrNull); - } -} - -/*-----------------------------------------------*/ -static void UnityPrintExpectedAndActualStringsLen(const char* expected, - const char* actual, - const UNITY_UINT32 length) -{ - UnityPrint(UnityStrExpected); - if (expected != NULL) - { - UNITY_OUTPUT_CHAR('\''); - UnityPrintLen(expected, length); - UNITY_OUTPUT_CHAR('\''); - } - else - { - UnityPrint(UnityStrNull); - } - UnityPrint(UnityStrWas); - if (actual != NULL) - { - UNITY_OUTPUT_CHAR('\''); - UnityPrintLen(actual, length); - UNITY_OUTPUT_CHAR('\''); - } - else - { - UnityPrint(UnityStrNull); - } -} - -/*----------------------------------------------- - * Assertion & Control Helpers - *-----------------------------------------------*/ - -/*-----------------------------------------------*/ -static int UnityIsOneArrayNull(UNITY_INTERNAL_PTR expected, - UNITY_INTERNAL_PTR actual, - const UNITY_LINE_TYPE lineNumber, - const char* msg) -{ - /* Both are NULL or same pointer */ - if (expected == actual) { return 0; } - - /* print and return true if just expected is NULL */ - if (expected == NULL) - { - UnityTestResultsFailBegin(lineNumber); - UnityPrint(UnityStrNullPointerForExpected); - UnityAddMsgIfSpecified(msg); - return 1; - } - - /* print and return true if just actual is NULL */ - if (actual == NULL) - { - UnityTestResultsFailBegin(lineNumber); - UnityPrint(UnityStrNullPointerForActual); - UnityAddMsgIfSpecified(msg); - return 1; - } - - return 0; /* return false if neither is NULL */ -} - -/*----------------------------------------------- - * Assertion Functions - *-----------------------------------------------*/ - -/*-----------------------------------------------*/ -void UnityAssertBits(const UNITY_INT mask, - const UNITY_INT expected, - const UNITY_INT actual, - const char* msg, - const UNITY_LINE_TYPE lineNumber) -{ - RETURN_IF_FAIL_OR_IGNORE; - - if ((mask & expected) != (mask & actual)) - { - UnityTestResultsFailBegin(lineNumber); - UnityPrint(UnityStrExpected); - UnityPrintMask((UNITY_UINT)mask, (UNITY_UINT)expected); - UnityPrint(UnityStrWas); - UnityPrintMask((UNITY_UINT)mask, (UNITY_UINT)actual); - UnityAddMsgIfSpecified(msg); - UNITY_FAIL_AND_BAIL; - } -} - -/*-----------------------------------------------*/ -void UnityAssertEqualNumber(const UNITY_INT expected, - const UNITY_INT actual, - const char* msg, - const UNITY_LINE_TYPE lineNumber, - const UNITY_DISPLAY_STYLE_T style) -{ - RETURN_IF_FAIL_OR_IGNORE; - - if (expected != actual) - { - UnityTestResultsFailBegin(lineNumber); - UnityPrint(UnityStrExpected); - UnityPrintNumberByStyle(expected, style); - UnityPrint(UnityStrWas); - UnityPrintNumberByStyle(actual, style); - UnityAddMsgIfSpecified(msg); - UNITY_FAIL_AND_BAIL; - } -} - -/*-----------------------------------------------*/ -void UnityAssertGreaterOrLessOrEqualNumber(const UNITY_INT threshold, - const UNITY_INT actual, - const UNITY_COMPARISON_T compare, - const char *msg, - const UNITY_LINE_TYPE lineNumber, - const UNITY_DISPLAY_STYLE_T style) -{ - int failed = 0; - RETURN_IF_FAIL_OR_IGNORE; - - if ((threshold == actual) && (compare & UNITY_EQUAL_TO)) { return; } - if ((threshold == actual)) { failed = 1; } - - if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) - { - if ((actual > threshold) && (compare & UNITY_SMALLER_THAN)) { failed = 1; } - if ((actual < threshold) && (compare & UNITY_GREATER_THAN)) { failed = 1; } - } - else /* UINT or HEX */ - { - if (((UNITY_UINT)actual > (UNITY_UINT)threshold) && (compare & UNITY_SMALLER_THAN)) { failed = 1; } - if (((UNITY_UINT)actual < (UNITY_UINT)threshold) && (compare & UNITY_GREATER_THAN)) { failed = 1; } - } - - if (failed) - { - UnityTestResultsFailBegin(lineNumber); - UnityPrint(UnityStrExpected); - UnityPrintNumberByStyle(actual, style); - if (compare & UNITY_GREATER_THAN) { UnityPrint(UnityStrGt); } - if (compare & UNITY_SMALLER_THAN) { UnityPrint(UnityStrLt); } - if (compare & UNITY_EQUAL_TO) { UnityPrint(UnityStrOrEqual); } - if (compare == UNITY_NOT_EQUAL) { UnityPrint(UnityStrNotEqual); } - UnityPrintNumberByStyle(threshold, style); - UnityAddMsgIfSpecified(msg); - UNITY_FAIL_AND_BAIL; - } -} - -#define UnityPrintPointlessAndBail() \ -do { \ - UnityTestResultsFailBegin(lineNumber); \ - UnityPrint(UnityStrPointless); \ - UnityAddMsgIfSpecified(msg); \ - UNITY_FAIL_AND_BAIL; \ -} while (0) - -/*-----------------------------------------------*/ -void UnityAssertEqualIntArray(UNITY_INTERNAL_PTR expected, - UNITY_INTERNAL_PTR actual, - const UNITY_UINT32 num_elements, - const char* msg, - const UNITY_LINE_TYPE lineNumber, - const UNITY_DISPLAY_STYLE_T style, - const UNITY_FLAGS_T flags) -{ - UNITY_UINT32 elements = num_elements; - unsigned int length = style & 0xF; - unsigned int increment = 0; - - RETURN_IF_FAIL_OR_IGNORE; - - if (num_elements == 0) - { -#ifdef UNITY_COMPARE_PTRS_ON_ZERO_ARRAY - UNITY_TEST_ASSERT_EQUAL_PTR(expected, actual, lineNumber, msg); -#else - UnityPrintPointlessAndBail(); -#endif - } - - if (expected == actual) - { - return; /* Both are NULL or same pointer */ - } - - if (UnityIsOneArrayNull(expected, actual, lineNumber, msg)) - { - UNITY_FAIL_AND_BAIL; - } - - while ((elements > 0) && (elements--)) - { - UNITY_INT expect_val; - UNITY_INT actual_val; - - switch (length) - { - case 1: - expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT8*)expected; - actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT8*)actual; - if (style & (UNITY_DISPLAY_RANGE_UINT | UNITY_DISPLAY_RANGE_HEX)) - { - expect_val &= 0x000000FF; - actual_val &= 0x000000FF; - } - increment = sizeof(UNITY_INT8); - break; - - case 2: - expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT16*)expected; - actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT16*)actual; - if (style & (UNITY_DISPLAY_RANGE_UINT | UNITY_DISPLAY_RANGE_HEX)) - { - expect_val &= 0x0000FFFF; - actual_val &= 0x0000FFFF; - } - increment = sizeof(UNITY_INT16); - break; - -#ifdef UNITY_SUPPORT_64 - case 8: - expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT64*)expected; - actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT64*)actual; - increment = sizeof(UNITY_INT64); - break; -#endif - - default: /* default is length 4 bytes */ - case 4: - expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT32*)expected; - actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT32*)actual; -#ifdef UNITY_SUPPORT_64 - if (style & (UNITY_DISPLAY_RANGE_UINT | UNITY_DISPLAY_RANGE_HEX)) - { - expect_val &= 0x00000000FFFFFFFF; - actual_val &= 0x00000000FFFFFFFF; - } -#endif - increment = sizeof(UNITY_INT32); - length = 4; - break; - } - - if (expect_val != actual_val) - { - if ((style & UNITY_DISPLAY_RANGE_UINT) && (length < (UNITY_INT_WIDTH / 8))) - { /* For UINT, remove sign extension (padding 1's) from signed type casts above */ - UNITY_INT mask = 1; - mask = (mask << 8 * length) - 1; - expect_val &= mask; - actual_val &= mask; - } - UnityTestResultsFailBegin(lineNumber); - UnityPrint(UnityStrElement); - UnityPrintNumberUnsigned(num_elements - elements - 1); - UnityPrint(UnityStrExpected); - UnityPrintNumberByStyle(expect_val, style); - UnityPrint(UnityStrWas); - UnityPrintNumberByStyle(actual_val, style); - UnityAddMsgIfSpecified(msg); - UNITY_FAIL_AND_BAIL; - } - /* Walk through array by incrementing the pointers */ - if (flags == UNITY_ARRAY_TO_ARRAY) - { - expected = (UNITY_INTERNAL_PTR)((const char*)expected + increment); - } - actual = (UNITY_INTERNAL_PTR)((const char*)actual + increment); - } -} - -/*-----------------------------------------------*/ -#ifndef UNITY_EXCLUDE_FLOAT -/* Wrap this define in a function with variable types as float or double */ -#define UNITY_FLOAT_OR_DOUBLE_WITHIN(delta, expected, actual, diff) \ - if (UNITY_IS_INF(expected) && UNITY_IS_INF(actual) && (((expected) < 0) == ((actual) < 0))) return 1; \ - if (UNITY_NAN_CHECK) return 1; \ - (diff) = (actual) - (expected); \ - if ((diff) < 0) (diff) = -(diff); \ - if ((delta) < 0) (delta) = -(delta); \ - return !(UNITY_IS_NAN(diff) || UNITY_IS_INF(diff) || ((diff) > (delta))) - /* This first part of this condition will catch any NaN or Infinite values */ -#ifndef UNITY_NAN_NOT_EQUAL_NAN - #define UNITY_NAN_CHECK UNITY_IS_NAN(expected) && UNITY_IS_NAN(actual) -#else - #define UNITY_NAN_CHECK 0 -#endif - -#ifndef UNITY_EXCLUDE_FLOAT_PRINT - #define UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT(expected, actual) \ - do { \ - UnityPrint(UnityStrExpected); \ - UnityPrintFloat(expected); \ - UnityPrint(UnityStrWas); \ - UnityPrintFloat(actual); \ - } while (0) -#else - #define UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT(expected, actual) \ - UnityPrint(UnityStrDelta) -#endif /* UNITY_EXCLUDE_FLOAT_PRINT */ - -/*-----------------------------------------------*/ -static int UnityFloatsWithin(UNITY_FLOAT delta, UNITY_FLOAT expected, UNITY_FLOAT actual) -{ - UNITY_FLOAT diff; - UNITY_FLOAT_OR_DOUBLE_WITHIN(delta, expected, actual, diff); -} - -/*-----------------------------------------------*/ -void UnityAssertWithinFloatArray(const UNITY_FLOAT delta, - UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* expected, - UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* actual, - const UNITY_UINT32 num_elements, - const char* msg, - const UNITY_LINE_TYPE lineNumber, - const UNITY_FLAGS_T flags) -{ - UNITY_UINT32 elements = num_elements; - UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* ptr_expected = expected; - UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* ptr_actual = actual; - UNITY_FLOAT in_delta = delta; - UNITY_FLOAT current_element_delta = delta; - - RETURN_IF_FAIL_OR_IGNORE; - - if (elements == 0) - { -#ifdef UNITY_COMPARE_PTRS_ON_ZERO_ARRAY - UNITY_TEST_ASSERT_EQUAL_PTR(expected, actual, lineNumber, msg); -#else - UnityPrintPointlessAndBail(); -#endif - } - - if (UNITY_IS_INF(in_delta)) - { - return; /* Arrays will be force equal with infinite delta */ - } - - if (UNITY_IS_NAN(in_delta)) - { - /* Delta must be correct number */ - UnityPrintPointlessAndBail(); - } - - if (expected == actual) - { - return; /* Both are NULL or same pointer */ - } - - if (UnityIsOneArrayNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg)) - { - UNITY_FAIL_AND_BAIL; - } - - /* fix delta sign if need */ - if (in_delta < 0) - { - in_delta = -in_delta; - } - - while (elements--) - { - current_element_delta = *ptr_expected * UNITY_FLOAT_PRECISION; - - if (current_element_delta < 0) - { - /* fix delta sign for correct calculations */ - current_element_delta = -current_element_delta; - } - - if (!UnityFloatsWithin(in_delta + current_element_delta, *ptr_expected, *ptr_actual)) - { - UnityTestResultsFailBegin(lineNumber); - UnityPrint(UnityStrElement); - UnityPrintNumberUnsigned(num_elements - elements - 1); - UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT((UNITY_DOUBLE)*ptr_expected, (UNITY_DOUBLE)*ptr_actual); - UnityAddMsgIfSpecified(msg); - UNITY_FAIL_AND_BAIL; - } - if (flags == UNITY_ARRAY_TO_ARRAY) - { - ptr_expected++; - } - ptr_actual++; - } -} - -/*-----------------------------------------------*/ -void UnityAssertFloatsWithin(const UNITY_FLOAT delta, - const UNITY_FLOAT expected, - const UNITY_FLOAT actual, - const char* msg, - const UNITY_LINE_TYPE lineNumber) -{ - RETURN_IF_FAIL_OR_IGNORE; - - - if (!UnityFloatsWithin(delta, expected, actual)) - { - UnityTestResultsFailBegin(lineNumber); - UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT((UNITY_DOUBLE)expected, (UNITY_DOUBLE)actual); - UnityAddMsgIfSpecified(msg); - UNITY_FAIL_AND_BAIL; - } -} - -/*-----------------------------------------------*/ -void UnityAssertFloatsNotWithin(const UNITY_FLOAT delta, - const UNITY_FLOAT expected, - const UNITY_FLOAT actual, - const char* msg, - const UNITY_LINE_TYPE lineNumber) -{ - RETURN_IF_FAIL_OR_IGNORE; - - if (UnityFloatsWithin(delta, expected, actual)) - { - UnityTestResultsFailBegin(lineNumber); - UnityPrint(UnityStrExpected); - UnityPrintFloat((UNITY_DOUBLE)expected); - UnityPrint(UnityStrNotEqual); - UnityPrintFloat((UNITY_DOUBLE)actual); - UnityAddMsgIfSpecified(msg); - UNITY_FAIL_AND_BAIL; - } -} - -/*-----------------------------------------------*/ -void UnityAssertGreaterOrLessFloat(const UNITY_FLOAT threshold, - const UNITY_FLOAT actual, - const UNITY_COMPARISON_T compare, - const char* msg, - const UNITY_LINE_TYPE lineNumber) -{ - int failed; - - RETURN_IF_FAIL_OR_IGNORE; - - failed = 0; - - /* Checking for "not success" rather than failure to get the right result for NaN */ - if (!(actual < threshold) && (compare & UNITY_SMALLER_THAN)) { failed = 1; } - if (!(actual > threshold) && (compare & UNITY_GREATER_THAN)) { failed = 1; } - - if ((compare & UNITY_EQUAL_TO) && UnityFloatsWithin(threshold * UNITY_FLOAT_PRECISION, threshold, actual)) { failed = 0; } - - if (failed) - { - UnityTestResultsFailBegin(lineNumber); - UnityPrint(UnityStrExpected); - UnityPrintFloat(actual); - if (compare & UNITY_GREATER_THAN) { UnityPrint(UnityStrGt); } - if (compare & UNITY_SMALLER_THAN) { UnityPrint(UnityStrLt); } - if (compare & UNITY_EQUAL_TO) { UnityPrint(UnityStrOrEqual); } - UnityPrintFloat(threshold); - UnityAddMsgIfSpecified(msg); - UNITY_FAIL_AND_BAIL; - } -} - -/*-----------------------------------------------*/ -void UnityAssertFloatSpecial(const UNITY_FLOAT actual, - const char* msg, - const UNITY_LINE_TYPE lineNumber, - const UNITY_FLOAT_TRAIT_T style) -{ - const char* trait_names[] = {UnityStrInf, UnityStrNegInf, UnityStrNaN, UnityStrDet}; - UNITY_INT should_be_trait = ((UNITY_INT)style & 1); - UNITY_INT is_trait = !should_be_trait; - UNITY_INT trait_index = (UNITY_INT)(style >> 1); - - RETURN_IF_FAIL_OR_IGNORE; - - switch (style) - { - case UNITY_FLOAT_IS_INF: - case UNITY_FLOAT_IS_NOT_INF: - is_trait = UNITY_IS_INF(actual) && (actual > 0); - break; - case UNITY_FLOAT_IS_NEG_INF: - case UNITY_FLOAT_IS_NOT_NEG_INF: - is_trait = UNITY_IS_INF(actual) && (actual < 0); - break; - - case UNITY_FLOAT_IS_NAN: - case UNITY_FLOAT_IS_NOT_NAN: - is_trait = UNITY_IS_NAN(actual) ? 1 : 0; - break; - - case UNITY_FLOAT_IS_DET: /* A determinate number is non infinite and not NaN. */ - case UNITY_FLOAT_IS_NOT_DET: - is_trait = !UNITY_IS_INF(actual) && !UNITY_IS_NAN(actual); - break; - - case UNITY_FLOAT_INVALID_TRAIT: /* Supress warning */ - default: /* including UNITY_FLOAT_INVALID_TRAIT */ - trait_index = 0; - trait_names[0] = UnityStrInvalidFloatTrait; - break; - } - - if (is_trait != should_be_trait) - { - UnityTestResultsFailBegin(lineNumber); - UnityPrint(UnityStrExpected); - if (!should_be_trait) - { - UnityPrint(UnityStrNot); - } - UnityPrint(trait_names[trait_index]); - UnityPrint(UnityStrWas); -#ifndef UNITY_EXCLUDE_FLOAT_PRINT - UnityPrintFloat((UNITY_DOUBLE)actual); -#else - if (should_be_trait) - { - UnityPrint(UnityStrNot); - } - UnityPrint(trait_names[trait_index]); -#endif - UnityAddMsgIfSpecified(msg); - UNITY_FAIL_AND_BAIL; - } -} - -#endif /* not UNITY_EXCLUDE_FLOAT */ - -/*-----------------------------------------------*/ -#ifndef UNITY_EXCLUDE_DOUBLE -static int UnityDoublesWithin(UNITY_DOUBLE delta, UNITY_DOUBLE expected, UNITY_DOUBLE actual) -{ - UNITY_DOUBLE diff; - UNITY_FLOAT_OR_DOUBLE_WITHIN(delta, expected, actual, diff); -} - -/*-----------------------------------------------*/ -void UnityAssertWithinDoubleArray(const UNITY_DOUBLE delta, - UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* expected, - UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* actual, - const UNITY_UINT32 num_elements, - const char* msg, - const UNITY_LINE_TYPE lineNumber, - const UNITY_FLAGS_T flags) -{ - UNITY_UINT32 elements = num_elements; - UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* ptr_expected = expected; - UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* ptr_actual = actual; - UNITY_DOUBLE in_delta = delta; - UNITY_DOUBLE current_element_delta = delta; - - RETURN_IF_FAIL_OR_IGNORE; - - if (elements == 0) - { -#ifdef UNITY_COMPARE_PTRS_ON_ZERO_ARRAY - UNITY_TEST_ASSERT_EQUAL_PTR(expected, actual, lineNumber, msg); -#else - UnityPrintPointlessAndBail(); -#endif - } - - if (UNITY_IS_INF(in_delta)) - { - return; /* Arrays will be force equal with infinite delta */ - } - - if (UNITY_IS_NAN(in_delta)) - { - /* Delta must be correct number */ - UnityPrintPointlessAndBail(); - } - - if (expected == actual) - { - return; /* Both are NULL or same pointer */ - } - - if (UnityIsOneArrayNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg)) - { - UNITY_FAIL_AND_BAIL; - } - - /* fix delta sign if need */ - if (in_delta < 0) - { - in_delta = -in_delta; - } - - while (elements--) - { - current_element_delta = *ptr_expected * UNITY_DOUBLE_PRECISION; - - if (current_element_delta < 0) - { - /* fix delta sign for correct calculations */ - current_element_delta = -current_element_delta; - } - - if (!UnityDoublesWithin(in_delta + current_element_delta, *ptr_expected, *ptr_actual)) - { - UnityTestResultsFailBegin(lineNumber); - UnityPrint(UnityStrElement); - UnityPrintNumberUnsigned(num_elements - elements - 1); - UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT(*ptr_expected, *ptr_actual); - UnityAddMsgIfSpecified(msg); - UNITY_FAIL_AND_BAIL; - } - if (flags == UNITY_ARRAY_TO_ARRAY) - { - ptr_expected++; - } - ptr_actual++; - } -} - -/*-----------------------------------------------*/ -void UnityAssertDoublesWithin(const UNITY_DOUBLE delta, - const UNITY_DOUBLE expected, - const UNITY_DOUBLE actual, - const char* msg, - const UNITY_LINE_TYPE lineNumber) -{ - RETURN_IF_FAIL_OR_IGNORE; - - if (!UnityDoublesWithin(delta, expected, actual)) - { - UnityTestResultsFailBegin(lineNumber); - UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT(expected, actual); - UnityAddMsgIfSpecified(msg); - UNITY_FAIL_AND_BAIL; - } -} - -/*-----------------------------------------------*/ -void UnityAssertDoublesNotWithin(const UNITY_DOUBLE delta, - const UNITY_DOUBLE expected, - const UNITY_DOUBLE actual, - const char* msg, - const UNITY_LINE_TYPE lineNumber) -{ - RETURN_IF_FAIL_OR_IGNORE; - - if (UnityDoublesWithin(delta, expected, actual)) - { - UnityTestResultsFailBegin(lineNumber); - UnityPrint(UnityStrExpected); - UnityPrintFloat((UNITY_DOUBLE)expected); - UnityPrint(UnityStrNotEqual); - UnityPrintFloat((UNITY_DOUBLE)actual); - UnityAddMsgIfSpecified(msg); - UNITY_FAIL_AND_BAIL; - } -} - -/*-----------------------------------------------*/ -void UnityAssertGreaterOrLessDouble(const UNITY_DOUBLE threshold, - const UNITY_DOUBLE actual, - const UNITY_COMPARISON_T compare, - const char* msg, - const UNITY_LINE_TYPE lineNumber) -{ - int failed; - - RETURN_IF_FAIL_OR_IGNORE; - - failed = 0; - - /* Checking for "not success" rather than failure to get the right result for NaN */ - if (!(actual < threshold) && (compare & UNITY_SMALLER_THAN)) { failed = 1; } - if (!(actual > threshold) && (compare & UNITY_GREATER_THAN)) { failed = 1; } - - if ((compare & UNITY_EQUAL_TO) && UnityDoublesWithin(threshold * UNITY_DOUBLE_PRECISION, threshold, actual)) { failed = 0; } - - if (failed) - { - UnityTestResultsFailBegin(lineNumber); - UnityPrint(UnityStrExpected); - UnityPrintFloat(actual); - if (compare & UNITY_GREATER_THAN) { UnityPrint(UnityStrGt); } - if (compare & UNITY_SMALLER_THAN) { UnityPrint(UnityStrLt); } - if (compare & UNITY_EQUAL_TO) { UnityPrint(UnityStrOrEqual); } - UnityPrintFloat(threshold); - UnityAddMsgIfSpecified(msg); - UNITY_FAIL_AND_BAIL; - } -} - -/*-----------------------------------------------*/ -void UnityAssertDoubleSpecial(const UNITY_DOUBLE actual, - const char* msg, - const UNITY_LINE_TYPE lineNumber, - const UNITY_FLOAT_TRAIT_T style) -{ - const char* trait_names[] = {UnityStrInf, UnityStrNegInf, UnityStrNaN, UnityStrDet}; - UNITY_INT should_be_trait = ((UNITY_INT)style & 1); - UNITY_INT is_trait = !should_be_trait; - UNITY_INT trait_index = (UNITY_INT)(style >> 1); - - RETURN_IF_FAIL_OR_IGNORE; - - switch (style) - { - case UNITY_FLOAT_IS_INF: - case UNITY_FLOAT_IS_NOT_INF: - is_trait = UNITY_IS_INF(actual) && (actual > 0); - break; - case UNITY_FLOAT_IS_NEG_INF: - case UNITY_FLOAT_IS_NOT_NEG_INF: - is_trait = UNITY_IS_INF(actual) && (actual < 0); - break; - - case UNITY_FLOAT_IS_NAN: - case UNITY_FLOAT_IS_NOT_NAN: - is_trait = UNITY_IS_NAN(actual) ? 1 : 0; - break; - - case UNITY_FLOAT_IS_DET: /* A determinate number is non infinite and not NaN. */ - case UNITY_FLOAT_IS_NOT_DET: - is_trait = !UNITY_IS_INF(actual) && !UNITY_IS_NAN(actual); - break; - - case UNITY_FLOAT_INVALID_TRAIT: /* Supress warning */ - default: /* including UNITY_FLOAT_INVALID_TRAIT */ - trait_index = 0; - trait_names[0] = UnityStrInvalidFloatTrait; - break; - } - - if (is_trait != should_be_trait) - { - UnityTestResultsFailBegin(lineNumber); - UnityPrint(UnityStrExpected); - if (!should_be_trait) - { - UnityPrint(UnityStrNot); - } - UnityPrint(trait_names[trait_index]); - UnityPrint(UnityStrWas); -#ifndef UNITY_EXCLUDE_FLOAT_PRINT - UnityPrintFloat(actual); -#else - if (should_be_trait) - { - UnityPrint(UnityStrNot); - } - UnityPrint(trait_names[trait_index]); -#endif - UnityAddMsgIfSpecified(msg); - UNITY_FAIL_AND_BAIL; - } -} - -#endif /* not UNITY_EXCLUDE_DOUBLE */ - -/*-----------------------------------------------*/ -void UnityAssertNumbersWithin(const UNITY_UINT delta, - const UNITY_INT expected, - const UNITY_INT actual, - const char* msg, - const UNITY_LINE_TYPE lineNumber, - const UNITY_DISPLAY_STYLE_T style) -{ - RETURN_IF_FAIL_OR_IGNORE; - - if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) - { - if (actual > expected) - { - Unity.CurrentTestFailed = (((UNITY_UINT)actual - (UNITY_UINT)expected) > delta); - } - else - { - Unity.CurrentTestFailed = (((UNITY_UINT)expected - (UNITY_UINT)actual) > delta); - } - } - else - { - if ((UNITY_UINT)actual > (UNITY_UINT)expected) - { - Unity.CurrentTestFailed = (((UNITY_UINT)actual - (UNITY_UINT)expected) > delta); - } - else - { - Unity.CurrentTestFailed = (((UNITY_UINT)expected - (UNITY_UINT)actual) > delta); - } - } - - if (Unity.CurrentTestFailed) - { - UnityTestResultsFailBegin(lineNumber); - UnityPrint(UnityStrDelta); - UnityPrintNumberByStyle((UNITY_INT)delta, style); - UnityPrint(UnityStrExpected); - UnityPrintNumberByStyle(expected, style); - UnityPrint(UnityStrWas); - UnityPrintNumberByStyle(actual, style); - UnityAddMsgIfSpecified(msg); - UNITY_FAIL_AND_BAIL; - } -} - -/*-----------------------------------------------*/ -void UnityAssertNumbersArrayWithin(const UNITY_UINT delta, - UNITY_INTERNAL_PTR expected, - UNITY_INTERNAL_PTR actual, - const UNITY_UINT32 num_elements, - const char* msg, - const UNITY_LINE_TYPE lineNumber, - const UNITY_DISPLAY_STYLE_T style, - const UNITY_FLAGS_T flags) -{ - UNITY_UINT32 elements = num_elements; - unsigned int length = style & 0xF; - unsigned int increment = 0; - - RETURN_IF_FAIL_OR_IGNORE; - - if (num_elements == 0) - { -#ifdef UNITY_COMPARE_PTRS_ON_ZERO_ARRAY - UNITY_TEST_ASSERT_EQUAL_PTR(expected, actual, lineNumber, msg); -#else - UnityPrintPointlessAndBail(); -#endif - } - - if (expected == actual) - { - return; /* Both are NULL or same pointer */ - } - - if (UnityIsOneArrayNull(expected, actual, lineNumber, msg)) - { - UNITY_FAIL_AND_BAIL; - } - - while ((elements > 0) && (elements--)) - { - UNITY_INT expect_val; - UNITY_INT actual_val; - - switch (length) - { - case 1: - /* fixing problems with signed overflow on unsigned numbers */ - if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) - { - expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT8*)expected; - actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT8*)actual; - increment = sizeof(UNITY_INT8); - } - else - { - expect_val = (UNITY_INT)*(UNITY_PTR_ATTRIBUTE const UNITY_UINT8*)expected; - actual_val = (UNITY_INT)*(UNITY_PTR_ATTRIBUTE const UNITY_UINT8*)actual; - increment = sizeof(UNITY_UINT8); - } - break; - - case 2: - /* fixing problems with signed overflow on unsigned numbers */ - if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) - { - expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT16*)expected; - actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT16*)actual; - increment = sizeof(UNITY_INT16); - } - else - { - expect_val = (UNITY_INT)*(UNITY_PTR_ATTRIBUTE const UNITY_UINT16*)expected; - actual_val = (UNITY_INT)*(UNITY_PTR_ATTRIBUTE const UNITY_UINT16*)actual; - increment = sizeof(UNITY_UINT16); - } - break; - -#ifdef UNITY_SUPPORT_64 - case 8: - /* fixing problems with signed overflow on unsigned numbers */ - if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) - { - expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT64*)expected; - actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT64*)actual; - increment = sizeof(UNITY_INT64); - } - else - { - expect_val = (UNITY_INT)*(UNITY_PTR_ATTRIBUTE const UNITY_UINT64*)expected; - actual_val = (UNITY_INT)*(UNITY_PTR_ATTRIBUTE const UNITY_UINT64*)actual; - increment = sizeof(UNITY_UINT64); - } - break; -#endif - - default: /* default is length 4 bytes */ - case 4: - /* fixing problems with signed overflow on unsigned numbers */ - if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) - { - expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT32*)expected; - actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT32*)actual; - increment = sizeof(UNITY_INT32); - } - else - { - expect_val = (UNITY_INT)*(UNITY_PTR_ATTRIBUTE const UNITY_UINT32*)expected; - actual_val = (UNITY_INT)*(UNITY_PTR_ATTRIBUTE const UNITY_UINT32*)actual; - increment = sizeof(UNITY_UINT32); - } - length = 4; - break; - } - - if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) - { - if (actual_val > expect_val) - { - Unity.CurrentTestFailed = (((UNITY_UINT)actual_val - (UNITY_UINT)expect_val) > delta); - } - else - { - Unity.CurrentTestFailed = (((UNITY_UINT)expect_val - (UNITY_UINT)actual_val) > delta); - } - } - else - { - if ((UNITY_UINT)actual_val > (UNITY_UINT)expect_val) - { - Unity.CurrentTestFailed = (((UNITY_UINT)actual_val - (UNITY_UINT)expect_val) > delta); - } - else - { - Unity.CurrentTestFailed = (((UNITY_UINT)expect_val - (UNITY_UINT)actual_val) > delta); - } - } - - if (Unity.CurrentTestFailed) - { - if ((style & UNITY_DISPLAY_RANGE_UINT) && (length < (UNITY_INT_WIDTH / 8))) - { /* For UINT, remove sign extension (padding 1's) from signed type casts above */ - UNITY_INT mask = 1; - mask = (mask << 8 * length) - 1; - expect_val &= mask; - actual_val &= mask; - } - UnityTestResultsFailBegin(lineNumber); - UnityPrint(UnityStrDelta); - UnityPrintNumberByStyle((UNITY_INT)delta, style); - UnityPrint(UnityStrElement); - UnityPrintNumberUnsigned(num_elements - elements - 1); - UnityPrint(UnityStrExpected); - UnityPrintNumberByStyle(expect_val, style); - UnityPrint(UnityStrWas); - UnityPrintNumberByStyle(actual_val, style); - UnityAddMsgIfSpecified(msg); - UNITY_FAIL_AND_BAIL; - } - /* Walk through array by incrementing the pointers */ - if (flags == UNITY_ARRAY_TO_ARRAY) - { - expected = (UNITY_INTERNAL_PTR)((const char*)expected + increment); - } - actual = (UNITY_INTERNAL_PTR)((const char*)actual + increment); - } -} - -/*-----------------------------------------------*/ -void UnityAssertEqualString(const char* expected, - const char* actual, - const char* msg, - const UNITY_LINE_TYPE lineNumber) -{ - UNITY_UINT32 i; - - RETURN_IF_FAIL_OR_IGNORE; - - /* if both pointers not null compare the strings */ - if (expected && actual) - { - for (i = 0; expected[i] || actual[i]; i++) - { - if (expected[i] != actual[i]) - { - Unity.CurrentTestFailed = 1; - break; - } - } - } - else - { /* fail if either null but not if both */ - if (expected || actual) - { - Unity.CurrentTestFailed = 1; - } - } - - if (Unity.CurrentTestFailed) - { - UnityTestResultsFailBegin(lineNumber); - UnityPrintExpectedAndActualStrings(expected, actual); - UnityAddMsgIfSpecified(msg); - UNITY_FAIL_AND_BAIL; - } -} - -/*-----------------------------------------------*/ -void UnityAssertEqualStringLen(const char* expected, - const char* actual, - const UNITY_UINT32 length, - const char* msg, - const UNITY_LINE_TYPE lineNumber) -{ - UNITY_UINT32 i; - - RETURN_IF_FAIL_OR_IGNORE; - - /* if both pointers not null compare the strings */ - if (expected && actual) - { - for (i = 0; (i < length) && (expected[i] || actual[i]); i++) - { - if (expected[i] != actual[i]) - { - Unity.CurrentTestFailed = 1; - break; - } - } - } - else - { /* fail if either null but not if both */ - if (expected || actual) - { - Unity.CurrentTestFailed = 1; - } - } - - if (Unity.CurrentTestFailed) - { - UnityTestResultsFailBegin(lineNumber); - UnityPrintExpectedAndActualStringsLen(expected, actual, length); - UnityAddMsgIfSpecified(msg); - UNITY_FAIL_AND_BAIL; - } -} - -/*-----------------------------------------------*/ -void UnityAssertEqualStringArray(UNITY_INTERNAL_PTR expected, - const char** actual, - const UNITY_UINT32 num_elements, - const char* msg, - const UNITY_LINE_TYPE lineNumber, - const UNITY_FLAGS_T flags) -{ - UNITY_UINT32 i = 0; - UNITY_UINT32 j = 0; - const char* expd = NULL; - const char* act = NULL; - - RETURN_IF_FAIL_OR_IGNORE; - - /* if no elements, it's an error */ - if (num_elements == 0) - { -#ifdef UNITY_COMPARE_PTRS_ON_ZERO_ARRAY - UNITY_TEST_ASSERT_EQUAL_PTR(expected, actual, lineNumber, msg); -#else - UnityPrintPointlessAndBail(); -#endif - } - - if ((const void*)expected == (const void*)actual) - { - return; /* Both are NULL or same pointer */ - } - - if (UnityIsOneArrayNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg)) - { - UNITY_FAIL_AND_BAIL; - } - - if (flags != UNITY_ARRAY_TO_ARRAY) - { - expd = (const char*)expected; - } - - do - { - act = actual[j]; - if (flags == UNITY_ARRAY_TO_ARRAY) - { - expd = ((const char* const*)expected)[j]; - } - - /* if both pointers not null compare the strings */ - if (expd && act) - { - for (i = 0; expd[i] || act[i]; i++) - { - if (expd[i] != act[i]) - { - Unity.CurrentTestFailed = 1; - break; - } - } - } - else - { /* handle case of one pointers being null (if both null, test should pass) */ - if (expd != act) - { - Unity.CurrentTestFailed = 1; - } - } - - if (Unity.CurrentTestFailed) - { - UnityTestResultsFailBegin(lineNumber); - if (num_elements > 1) - { - UnityPrint(UnityStrElement); - UnityPrintNumberUnsigned(j); - } - UnityPrintExpectedAndActualStrings(expd, act); - UnityAddMsgIfSpecified(msg); - UNITY_FAIL_AND_BAIL; - } - } while (++j < num_elements); -} - -/*-----------------------------------------------*/ -void UnityAssertEqualMemory(UNITY_INTERNAL_PTR expected, - UNITY_INTERNAL_PTR actual, - const UNITY_UINT32 length, - const UNITY_UINT32 num_elements, - const char* msg, - const UNITY_LINE_TYPE lineNumber, - const UNITY_FLAGS_T flags) -{ - UNITY_PTR_ATTRIBUTE const unsigned char* ptr_exp = (UNITY_PTR_ATTRIBUTE const unsigned char*)expected; - UNITY_PTR_ATTRIBUTE const unsigned char* ptr_act = (UNITY_PTR_ATTRIBUTE const unsigned char*)actual; - UNITY_UINT32 elements = num_elements; - UNITY_UINT32 bytes; - - RETURN_IF_FAIL_OR_IGNORE; - - if (elements == 0) - { -#ifdef UNITY_COMPARE_PTRS_ON_ZERO_ARRAY - UNITY_TEST_ASSERT_EQUAL_PTR(expected, actual, lineNumber, msg); -#else - UnityPrintPointlessAndBail(); -#endif - } - if (length == 0) - { - UnityPrintPointlessAndBail(); - } - - if (expected == actual) - { - return; /* Both are NULL or same pointer */ - } - - if (UnityIsOneArrayNull(expected, actual, lineNumber, msg)) - { - UNITY_FAIL_AND_BAIL; - } - - while (elements--) - { - bytes = length; - while (bytes--) - { - if (*ptr_exp != *ptr_act) - { - UnityTestResultsFailBegin(lineNumber); - UnityPrint(UnityStrMemory); - if (num_elements > 1) - { - UnityPrint(UnityStrElement); - UnityPrintNumberUnsigned(num_elements - elements - 1); - } - UnityPrint(UnityStrByte); - UnityPrintNumberUnsigned(length - bytes - 1); - UnityPrint(UnityStrExpected); - UnityPrintNumberByStyle(*ptr_exp, UNITY_DISPLAY_STYLE_HEX8); - UnityPrint(UnityStrWas); - UnityPrintNumberByStyle(*ptr_act, UNITY_DISPLAY_STYLE_HEX8); - UnityAddMsgIfSpecified(msg); - UNITY_FAIL_AND_BAIL; - } - ptr_exp++; - ptr_act++; - } - if (flags == UNITY_ARRAY_TO_VAL) - { - ptr_exp = (UNITY_PTR_ATTRIBUTE const unsigned char*)expected; - } - } -} - -/*-----------------------------------------------*/ - -static union -{ - UNITY_INT8 i8; - UNITY_INT16 i16; - UNITY_INT32 i32; -#ifdef UNITY_SUPPORT_64 - UNITY_INT64 i64; -#endif -#ifndef UNITY_EXCLUDE_FLOAT - float f; -#endif -#ifndef UNITY_EXCLUDE_DOUBLE - double d; -#endif -} UnityQuickCompare; - -UNITY_INTERNAL_PTR UnityNumToPtr(const UNITY_INT num, const UNITY_UINT8 size) -{ - switch(size) - { - case 1: - UnityQuickCompare.i8 = (UNITY_INT8)num; - return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.i8); - - case 2: - UnityQuickCompare.i16 = (UNITY_INT16)num; - return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.i16); - -#ifdef UNITY_SUPPORT_64 - case 8: - UnityQuickCompare.i64 = (UNITY_INT64)num; - return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.i64); -#endif - - default: /* 4 bytes */ - UnityQuickCompare.i32 = (UNITY_INT32)num; - return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.i32); - } -} - -#ifndef UNITY_EXCLUDE_FLOAT -/*-----------------------------------------------*/ -UNITY_INTERNAL_PTR UnityFloatToPtr(const float num) -{ - UnityQuickCompare.f = num; - return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.f); -} -#endif - -#ifndef UNITY_EXCLUDE_DOUBLE -/*-----------------------------------------------*/ -UNITY_INTERNAL_PTR UnityDoubleToPtr(const double num) -{ - UnityQuickCompare.d = num; - return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.d); -} -#endif - -#ifdef UNITY_INCLUDE_PRINT_FORMATTED - -/*----------------------------------------------- - * printf length modifier helpers - *-----------------------------------------------*/ - -enum UnityLengthModifier { - UNITY_LENGTH_MODIFIER_NONE, - UNITY_LENGTH_MODIFIER_LONG_LONG, - UNITY_LENGTH_MODIFIER_LONG, -}; - -#define UNITY_EXTRACT_ARG(NUMBER_T, NUMBER, LENGTH_MOD, VA, ARG_T) \ -do { \ - switch (LENGTH_MOD) \ - { \ - case UNITY_LENGTH_MODIFIER_LONG_LONG: \ - { \ - NUMBER = (NUMBER_T)va_arg(VA, long long ARG_T); \ - break; \ - } \ - case UNITY_LENGTH_MODIFIER_LONG: \ - { \ - NUMBER = (NUMBER_T)va_arg(VA, long ARG_T); \ - break; \ - } \ - case UNITY_LENGTH_MODIFIER_NONE: \ - default: \ - { \ - NUMBER = (NUMBER_T)va_arg(VA, ARG_T); \ - break; \ - } \ - } \ -} while (0) - -static enum UnityLengthModifier UnityLengthModifierGet(const char *pch, int *length) -{ - enum UnityLengthModifier length_mod; - switch (pch[0]) - { - case 'l': - { - if (pch[1] == 'l') - { - *length = 2; - length_mod = UNITY_LENGTH_MODIFIER_LONG_LONG; - } - else - { - *length = 1; - length_mod = UNITY_LENGTH_MODIFIER_LONG; - } - break; - } - case 'h': - { - // short and char are converted to int - length_mod = UNITY_LENGTH_MODIFIER_NONE; - if (pch[1] == 'h') - { - *length = 2; - } - else - { - *length = 1; - } - break; - } - case 'j': - case 'z': - case 't': - case 'L': - { - // Not supported, but should gobble up the length specifier anyway - length_mod = UNITY_LENGTH_MODIFIER_NONE; - *length = 1; - break; - } - default: - { - length_mod = UNITY_LENGTH_MODIFIER_NONE; - *length = 0; - } - } - return length_mod; -} - -/*----------------------------------------------- - * printf helper function - *-----------------------------------------------*/ -static void UnityPrintFVA(const char* format, va_list va) -{ - const char* pch = format; - if (pch != NULL) - { - while (*pch) - { - /* format identification character */ - if (*pch == '%') - { - pch++; - - if (pch != NULL) - { - int length_mod_size; - enum UnityLengthModifier length_mod = UnityLengthModifierGet(pch, &length_mod_size); - pch += length_mod_size; - - switch (*pch) - { - case 'd': - case 'i': - { - UNITY_INT number; - UNITY_EXTRACT_ARG(UNITY_INT, number, length_mod, va, int); - UnityPrintNumber((UNITY_INT)number); - break; - } -#ifndef UNITY_EXCLUDE_FLOAT_PRINT - case 'f': - case 'g': - { - const double number = va_arg(va, double); - UnityPrintFloat((UNITY_DOUBLE)number); - break; - } -#endif - case 'u': - { - UNITY_UINT number; - UNITY_EXTRACT_ARG(UNITY_UINT, number, length_mod, va, unsigned int); - UnityPrintNumberUnsigned(number); - break; - } - case 'b': - { - UNITY_UINT number; - UNITY_EXTRACT_ARG(UNITY_UINT, number, length_mod, va, unsigned int); - const UNITY_UINT mask = (UNITY_UINT)0 - (UNITY_UINT)1; - UNITY_OUTPUT_CHAR('0'); - UNITY_OUTPUT_CHAR('b'); - UnityPrintMask(mask, number); - break; - } - case 'x': - case 'X': - { - UNITY_UINT number; - UNITY_EXTRACT_ARG(UNITY_UINT, number, length_mod, va, unsigned int); - UNITY_OUTPUT_CHAR('0'); - UNITY_OUTPUT_CHAR('x'); - UnityPrintNumberHex(number, UNITY_MAX_NIBBLES); - break; - } - case 'p': - { - UNITY_UINT number; - char nibbles_to_print = 8; - if (UNITY_POINTER_WIDTH == 64) - { - length_mod = UNITY_LENGTH_MODIFIER_LONG_LONG; - nibbles_to_print = 16; - } - UNITY_EXTRACT_ARG(UNITY_UINT, number, length_mod, va, unsigned int); - UNITY_OUTPUT_CHAR('0'); - UNITY_OUTPUT_CHAR('x'); - UnityPrintNumberHex((UNITY_UINT)number, nibbles_to_print); - break; - } - case 'c': - { - const int ch = va_arg(va, int); - UnityPrintChar((const char *)&ch); - break; - } - case 's': - { - const char * string = va_arg(va, const char *); - UnityPrint(string); - break; - } - case '%': - { - UnityPrintChar(pch); - break; - } - default: - { - /* print the unknown format character */ - UNITY_OUTPUT_CHAR('%'); - UnityPrintChar(pch); - break; - } - } - } - } -#ifdef UNITY_OUTPUT_COLOR - /* print ANSI escape code */ - else if ((*pch == 27) && (*(pch + 1) == '[')) - { - pch += UnityPrintAnsiEscapeString(pch); - continue; - } -#endif - else if (*pch == '\n') - { - UNITY_PRINT_EOL(); - } - else - { - UnityPrintChar(pch); - } - - pch++; - } - } -} - -void UnityPrintF(const UNITY_LINE_TYPE line, const char* format, ...) -{ - UnityTestResultsBegin(Unity.TestFile, line); - UnityPrint("INFO"); - if(format != NULL) - { - UnityPrint(": "); - va_list va; - va_start(va, format); - UnityPrintFVA(format, va); - va_end(va); - } - UNITY_PRINT_EOL(); -} -#endif /* ! UNITY_INCLUDE_PRINT_FORMATTED */ - - -/*----------------------------------------------- - * Control Functions - *-----------------------------------------------*/ - -/*-----------------------------------------------*/ -void UnityFail(const char* msg, const UNITY_LINE_TYPE line) -{ - RETURN_IF_FAIL_OR_IGNORE; - - UnityTestResultsBegin(Unity.TestFile, line); - UnityPrint(UnityStrFail); - if (msg != NULL) - { - UNITY_OUTPUT_CHAR(':'); - -#ifdef UNITY_PRINT_TEST_CONTEXT - UNITY_PRINT_TEST_CONTEXT(); -#endif -#ifndef UNITY_EXCLUDE_DETAILS - if (Unity.CurrentDetail1) - { - UnityPrint(UnityStrDetail1Name); - UnityPrint(Unity.CurrentDetail1); - if (Unity.CurrentDetail2) - { - UnityPrint(UnityStrDetail2Name); - UnityPrint(Unity.CurrentDetail2); - } - UnityPrint(UnityStrSpacer); - } -#endif - if (msg[0] != ' ') - { - UNITY_OUTPUT_CHAR(' '); - } - UnityPrint(msg); - } - - UNITY_FAIL_AND_BAIL; -} - -/*-----------------------------------------------*/ -void UnityIgnore(const char* msg, const UNITY_LINE_TYPE line) -{ - RETURN_IF_FAIL_OR_IGNORE; - - UnityTestResultsBegin(Unity.TestFile, line); - UnityPrint(UnityStrIgnore); - if (msg != NULL) - { - UNITY_OUTPUT_CHAR(':'); - UNITY_OUTPUT_CHAR(' '); - UnityPrint(msg); - } - UNITY_IGNORE_AND_BAIL; -} - -/*-----------------------------------------------*/ -void UnityMessage(const char* msg, const UNITY_LINE_TYPE line) -{ - UnityTestResultsBegin(Unity.TestFile, line); - UnityPrint("INFO"); - if (msg != NULL) - { - UNITY_OUTPUT_CHAR(':'); - UNITY_OUTPUT_CHAR(' '); - UnityPrint(msg); - } - UNITY_PRINT_EOL(); -} - -/*-----------------------------------------------*/ -/* If we have not defined our own test runner, then include our default test runner to make life easier */ -#ifndef UNITY_SKIP_DEFAULT_RUNNER -void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int FuncLineNum) -{ - Unity.CurrentTestName = FuncName; - Unity.CurrentTestLineNumber = (UNITY_LINE_TYPE)FuncLineNum; - Unity.NumberOfTests++; - UNITY_CLR_DETAILS(); - UNITY_EXEC_TIME_START(); - if (TEST_PROTECT()) - { - setUp(); - Func(); - } - if (TEST_PROTECT()) - { - tearDown(); - } - UNITY_EXEC_TIME_STOP(); - UnityConcludeTest(); -} -#endif - -/*-----------------------------------------------*/ -void UnitySetTestFile(const char* filename) -{ - Unity.TestFile = filename; -} - -/*-----------------------------------------------*/ -void UnityBegin(const char* filename) -{ - Unity.TestFile = filename; - Unity.CurrentTestName = NULL; - Unity.CurrentTestLineNumber = 0; - Unity.NumberOfTests = 0; - Unity.TestFailures = 0; - Unity.TestIgnores = 0; - Unity.CurrentTestFailed = 0; - Unity.CurrentTestIgnored = 0; - - UNITY_CLR_DETAILS(); - UNITY_OUTPUT_START(); -} - -/*-----------------------------------------------*/ -int UnityEnd(void) -{ - UNITY_PRINT_EOL(); - UnityPrint(UnityStrBreaker); - UNITY_PRINT_EOL(); - UnityPrintNumber((UNITY_INT)(Unity.NumberOfTests)); - UnityPrint(UnityStrResultsTests); - UnityPrintNumber((UNITY_INT)(Unity.TestFailures)); - UnityPrint(UnityStrResultsFailures); - UnityPrintNumber((UNITY_INT)(Unity.TestIgnores)); - UnityPrint(UnityStrResultsIgnored); - UNITY_PRINT_EOL(); - if (Unity.TestFailures == 0U) - { - UnityPrint(UnityStrOk); - } - else - { - UnityPrint(UnityStrFail); -#ifdef UNITY_DIFFERENTIATE_FINAL_FAIL - UNITY_OUTPUT_CHAR('E'); UNITY_OUTPUT_CHAR('D'); -#endif - } - UNITY_PRINT_EOL(); - UNITY_FLUSH_CALL(); - UNITY_OUTPUT_COMPLETE(); - return (int)(Unity.TestFailures); -} - -/*----------------------------------------------- - * Command Line Argument Support - *-----------------------------------------------*/ -#ifdef UNITY_USE_COMMAND_LINE_ARGS - -char* UnityOptionIncludeNamed = NULL; -char* UnityOptionExcludeNamed = NULL; -int UnityVerbosity = 1; -int UnityStrictMatch = 0; - -/*-----------------------------------------------*/ -int UnityParseOptions(int argc, char** argv) -{ - int i; - UnityOptionIncludeNamed = NULL; - UnityOptionExcludeNamed = NULL; - UnityStrictMatch = 0; - - for (i = 1; i < argc; i++) - { - if (argv[i][0] == '-') - { - switch (argv[i][1]) - { - case 'l': /* list tests */ - return -1; - case 'n': /* include tests with name including this string */ - case 'f': /* an alias for -n */ - UnityStrictMatch = (argv[i][1] == 'n'); /* strictly match this string if -n */ - if (argv[i][2] == '=') - { - UnityOptionIncludeNamed = &argv[i][3]; - } - else if (++i < argc) - { - UnityOptionIncludeNamed = argv[i]; - } - else - { - UnityPrint("ERROR: No Test String to Include Matches For"); - UNITY_PRINT_EOL(); - return 1; - } - break; - case 'q': /* quiet */ - UnityVerbosity = 0; - break; - case 'v': /* verbose */ - UnityVerbosity = 2; - break; - case 'x': /* exclude tests with name including this string */ - if (argv[i][2] == '=') - { - UnityOptionExcludeNamed = &argv[i][3]; - } - else if (++i < argc) - { - UnityOptionExcludeNamed = argv[i]; - } - else - { - UnityPrint("ERROR: No Test String to Exclude Matches For"); - UNITY_PRINT_EOL(); - return 1; - } - break; - default: - UnityPrint("ERROR: Unknown Option "); - UNITY_OUTPUT_CHAR(argv[i][1]); - UNITY_PRINT_EOL(); - /* Now display help */ - /* FALLTHRU */ - case 'h': - UnityPrint("Options: "); UNITY_PRINT_EOL(); - UnityPrint("-l List all tests and exit"); UNITY_PRINT_EOL(); - UnityPrint("-f NAME Filter to run only tests whose name includes NAME"); UNITY_PRINT_EOL(); - UnityPrint("-n NAME Run only the test named NAME"); UNITY_PRINT_EOL(); - UnityPrint("-h show this Help menu"); UNITY_PRINT_EOL(); - UnityPrint("-q Quiet/decrease verbosity"); UNITY_PRINT_EOL(); - UnityPrint("-v increase Verbosity"); UNITY_PRINT_EOL(); - UnityPrint("-x NAME eXclude tests whose name includes NAME"); UNITY_PRINT_EOL(); - UNITY_OUTPUT_FLUSH(); - return 1; - } - } - } - - return 0; -} - -/*-----------------------------------------------*/ -static int IsStringInBiggerString(const char* longstring, const char* shortstring) -{ - const char* lptr = longstring; - const char* sptr = shortstring; - const char* lnext = lptr; - - if (*sptr == '*') - { - return UnityStrictMatch ? 0 : 1; - } - - while (*lptr) - { - lnext = lptr + 1; - - /* If they current bytes match, go on to the next bytes */ - while (*lptr && *sptr && (*lptr == *sptr)) - { - lptr++; - sptr++; - - switch (*sptr) - { - case '*': /* we encountered a wild-card */ - return UnityStrictMatch ? 0 : 1; - - case ',': /* we encountered the end of match string */ - case '"': - case '\'': - case 0: - return (!UnityStrictMatch || (*lptr == 0)) ? 1 : 0; - - case ':': /* we encountered the end of a partial match */ - return 2; - - default: - break; - } - } - - // If we didn't match and we're on strict matching, we already know we failed - if (UnityStrictMatch) - { - return 0; - } - - /* Otherwise we start in the long pointer 1 character further and try again */ - lptr = lnext; - sptr = shortstring; - } - - return 0; -} - -/*-----------------------------------------------*/ -static int UnityStringArgumentMatches(const char* str) -{ - int retval; - const char* ptr1; - const char* ptr2; - const char* ptrf; - - /* Go through the options and get the substrings for matching one at a time */ - ptr1 = str; - while (ptr1[0] != 0) - { - if ((ptr1[0] == '"') || (ptr1[0] == '\'')) - { - ptr1++; - } - - /* look for the start of the next partial */ - ptr2 = ptr1; - ptrf = 0; - do - { - ptr2++; - if ((ptr2[0] == ':') && (ptr2[1] != 0) && (ptr2[0] != '\'') && (ptr2[0] != '"') && (ptr2[0] != ',')) - { - ptrf = &ptr2[1]; - } - } while ((ptr2[0] != 0) && (ptr2[0] != '\'') && (ptr2[0] != '"') && (ptr2[0] != ',')); - - while ((ptr2[0] != 0) && ((ptr2[0] == ':') || (ptr2[0] == '\'') || (ptr2[0] == '"') || (ptr2[0] == ','))) - { - ptr2++; - } - - /* done if complete filename match */ - retval = IsStringInBiggerString(Unity.TestFile, ptr1); - if (retval == 1) - { - return retval; - } - - /* done if testname match after filename partial match */ - if ((retval == 2) && (ptrf != 0)) - { - if (IsStringInBiggerString(Unity.CurrentTestName, ptrf)) - { - return 1; - } - } - - /* done if complete testname match */ - if (IsStringInBiggerString(Unity.CurrentTestName, ptr1) == 1) - { - return 1; - } - - ptr1 = ptr2; - } - - /* we couldn't find a match for any substrings */ - return 0; -} - -/*-----------------------------------------------*/ -int UnityTestMatches(void) -{ - /* Check if this test name matches the included test pattern */ - int retval; - if (UnityOptionIncludeNamed) - { - retval = UnityStringArgumentMatches(UnityOptionIncludeNamed); - } - else - { - retval = 1; - } - - /* Check if this test name matches the excluded test pattern */ - if (UnityOptionExcludeNamed) - { - if (UnityStringArgumentMatches(UnityOptionExcludeNamed)) - { - retval = 0; - } - } - - return retval; -} - -#endif /* UNITY_USE_COMMAND_LINE_ARGS */ -/*-----------------------------------------------*/ diff --git a/subprojects/unity/src/unity.h b/subprojects/unity/src/unity.h deleted file mode 100644 index 9e2a97b791..0000000000 --- a/subprojects/unity/src/unity.h +++ /dev/null @@ -1,698 +0,0 @@ -/* ========================================================================= - Unity - A Test Framework for C - ThrowTheSwitch.org - Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams - SPDX-License-Identifier: MIT -========================================================================= */ - -#ifndef UNITY_FRAMEWORK_H -#define UNITY_FRAMEWORK_H -#define UNITY - -#define UNITY_VERSION_MAJOR 2 -#define UNITY_VERSION_MINOR 6 -#define UNITY_VERSION_BUILD 1 -#define UNITY_VERSION ((UNITY_VERSION_MAJOR << 16) | (UNITY_VERSION_MINOR << 8) | UNITY_VERSION_BUILD) - -#ifdef __cplusplus -extern "C" -{ -#endif - -#include "unity_internals.h" - -/*------------------------------------------------------- - * Test Setup / Teardown - *-------------------------------------------------------*/ - -/* These functions are intended to be called before and after each test. - * If using unity directly, these will need to be provided for each test - * executable built. If you are using the test runner generator and/or - * Ceedling, these are optional. */ -void setUp(void); -void tearDown(void); - -/* These functions are intended to be called at the beginning and end of an - * entire test suite. suiteTearDown() is passed the number of tests that - * failed, and its return value becomes the exit code of main(). If using - * Unity directly, you're in charge of calling these if they are desired. - * If using Ceedling or the test runner generator, these will be called - * automatically if they exist. */ -void suiteSetUp(void); -int suiteTearDown(int num_failures); - -/*------------------------------------------------------- - * Test Reset and Verify - *-------------------------------------------------------*/ - -/* These functions are intended to be called before during tests in order - * to support complex test loops, etc. Both are NOT built into Unity. Instead - * the test runner generator will create them. resetTest will run teardown and - * setup again, verifying any end-of-test needs between. verifyTest will only - * run the verification. */ -void resetTest(void); -void verifyTest(void); - -/*------------------------------------------------------- - * Configuration Options - *------------------------------------------------------- - * All options described below should be passed as a compiler flag to all files using Unity. If you must add #defines, place them BEFORE the #include above. - - * Integers/longs/pointers - * - Unity attempts to automatically discover your integer sizes - * - define UNITY_EXCLUDE_STDINT_H to stop attempting to look in - * - define UNITY_EXCLUDE_LIMITS_H to stop attempting to look in - * - If you cannot use the automatic methods above, you can force Unity by using these options: - * - define UNITY_SUPPORT_64 - * - set UNITY_INT_WIDTH - * - set UNITY_LONG_WIDTH - * - set UNITY_POINTER_WIDTH - - * Floats - * - define UNITY_EXCLUDE_FLOAT to disallow floating point comparisons - * - define UNITY_FLOAT_PRECISION to specify the precision to use when doing TEST_ASSERT_EQUAL_FLOAT - * - define UNITY_FLOAT_TYPE to specify doubles instead of single precision floats - * - define UNITY_INCLUDE_DOUBLE to allow double floating point comparisons - * - define UNITY_EXCLUDE_DOUBLE to disallow double floating point comparisons (default) - * - define UNITY_DOUBLE_PRECISION to specify the precision to use when doing TEST_ASSERT_EQUAL_DOUBLE - * - define UNITY_DOUBLE_TYPE to specify something other than double - * - define UNITY_EXCLUDE_FLOAT_PRINT to trim binary size, won't print floating point values in errors - - * Output - * - by default, Unity prints to standard out with putchar. define UNITY_OUTPUT_CHAR(a) with a different function if desired - * - define UNITY_DIFFERENTIATE_FINAL_FAIL to print FAILED (vs. FAIL) at test end summary - for automated search for failure - - * Optimization - * - by default, line numbers are stored in unsigned shorts. Define UNITY_LINE_TYPE with a different type if your files are huge - * - by default, test and failure counters are unsigned shorts. Define UNITY_COUNTER_TYPE with a different type if you want to save space or have more than 65535 Tests. - - * Test Cases - * - define UNITY_SUPPORT_TEST_CASES to include the TEST_CASE macro, though really it's mostly about the runner generator script - - * Parameterized Tests - * - you'll want to create a define of TEST_CASE(...), TEST_RANGE(...) and/or TEST_MATRIX(...) which basically evaluates to nothing - - * Tests with Arguments - * - you'll want to define UNITY_USE_COMMAND_LINE_ARGS if you have the test runner passing arguments to Unity - - *------------------------------------------------------- - * Basic Fail and Ignore - *-------------------------------------------------------*/ - -#define TEST_FAIL_MESSAGE(message) UNITY_TEST_FAIL(__LINE__, (message)) -#define TEST_FAIL() UNITY_TEST_FAIL(__LINE__, NULL) -#define TEST_IGNORE_MESSAGE(message) UNITY_TEST_IGNORE(__LINE__, (message)) -#define TEST_IGNORE() UNITY_TEST_IGNORE(__LINE__, NULL) -#define TEST_MESSAGE(message) UnityMessage((message), __LINE__) -#define TEST_ONLY() -#ifdef UNITY_INCLUDE_PRINT_FORMATTED -#define TEST_PRINTF(message, ...) UnityPrintF(__LINE__, (message), ##__VA_ARGS__) -#endif - -/* It is not necessary for you to call PASS. A PASS condition is assumed if nothing fails. - * This method allows you to abort a test immediately with a PASS state, ignoring the remainder of the test. */ -#define TEST_PASS() TEST_ABORT() -#define TEST_PASS_MESSAGE(message) do { UnityMessage((message), __LINE__); TEST_ABORT(); } while (0) - -/*------------------------------------------------------- - * Build Directives - *------------------------------------------------------- - - * These macros do nothing, but they are useful for additional build context. - * Tools (like Ceedling) can scan for these directives and make use of them for - * per-test-executable #include search paths and linking. */ - -/* Add source files to a test executable's compilation and linking. Ex: TEST_SOURCE_FILE("sandwiches.c") */ -#define TEST_SOURCE_FILE(a) - -/* Customize #include search paths for a test executable's compilation. Ex: TEST_INCLUDE_PATH("src/module_a/inc") */ -#define TEST_INCLUDE_PATH(a) - -/*------------------------------------------------------- - * Test Asserts (simple) - *-------------------------------------------------------*/ - -/* Boolean */ -#define TEST_ASSERT(condition) UNITY_TEST_ASSERT( (condition), __LINE__, " Expression Evaluated To FALSE") -#define TEST_ASSERT_TRUE(condition) UNITY_TEST_ASSERT( (condition), __LINE__, " Expected TRUE Was FALSE") -#define TEST_ASSERT_UNLESS(condition) UNITY_TEST_ASSERT( !(condition), __LINE__, " Expression Evaluated To TRUE") -#define TEST_ASSERT_FALSE(condition) UNITY_TEST_ASSERT( !(condition), __LINE__, " Expected FALSE Was TRUE") -#define TEST_ASSERT_NULL(pointer) UNITY_TEST_ASSERT_NULL( (pointer), __LINE__, " Expected NULL") -#define TEST_ASSERT_NOT_NULL(pointer) UNITY_TEST_ASSERT_NOT_NULL((pointer), __LINE__, " Expected Non-NULL") -#define TEST_ASSERT_EMPTY(pointer) UNITY_TEST_ASSERT_EMPTY( (pointer), __LINE__, " Expected Empty") -#define TEST_ASSERT_NOT_EMPTY(pointer) UNITY_TEST_ASSERT_NOT_EMPTY((pointer), __LINE__, " Expected Non-Empty") - -/* Integers (of all sizes) */ -#define TEST_ASSERT_EQUAL_INT(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_INT8(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT8((expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_INT16(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT16((expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_INT32(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT32((expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_INT64(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT64((expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_UINT(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT( (expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_UINT8(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT8( (expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_UINT16(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT16( (expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_UINT32(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT32( (expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_UINT64(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT64( (expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_size_t(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT((expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_HEX(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_HEX8(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX8( (expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_HEX16(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX16((expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_HEX32(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_HEX64(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX64((expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_CHAR(expected, actual) UNITY_TEST_ASSERT_EQUAL_CHAR((expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_BITS(mask, expected, actual) UNITY_TEST_ASSERT_BITS((mask), (expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_BITS_HIGH(mask, actual) UNITY_TEST_ASSERT_BITS((mask), (UNITY_UINT)(-1), (actual), __LINE__, NULL) -#define TEST_ASSERT_BITS_LOW(mask, actual) UNITY_TEST_ASSERT_BITS((mask), (UNITY_UINT)(0), (actual), __LINE__, NULL) -#define TEST_ASSERT_BIT_HIGH(bit, actual) UNITY_TEST_ASSERT_BITS(((UNITY_UINT)1 << (bit)), (UNITY_UINT)(-1), (actual), __LINE__, NULL) -#define TEST_ASSERT_BIT_LOW(bit, actual) UNITY_TEST_ASSERT_BITS(((UNITY_UINT)1 << (bit)), (UNITY_UINT)(0), (actual), __LINE__, NULL) - -/* Integer Not Equal To (of all sizes) */ -#define TEST_ASSERT_NOT_EQUAL_INT(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_INT((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_NOT_EQUAL_INT8(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_INT8((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_NOT_EQUAL_INT16(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_INT16((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_NOT_EQUAL_INT32(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_INT32((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_NOT_EQUAL_INT64(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_INT64((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_NOT_EQUAL_UINT(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_NOT_EQUAL_UINT8(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT8((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_NOT_EQUAL_UINT16(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT16((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_NOT_EQUAL_UINT32(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT32((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_NOT_EQUAL_UINT64(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT64((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_NOT_EQUAL_size_t(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_NOT_EQUAL_HEX8(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_HEX8((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_NOT_EQUAL_HEX16(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_HEX16((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_NOT_EQUAL_HEX32(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_HEX32((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_NOT_EQUAL_HEX64(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_HEX64((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_NOT_EQUAL_CHAR(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_CHAR((threshold), (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_INT64(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_INT64((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_UINT64(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_UINT64((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_GREATER_THAN_size_t(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_UINT((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_GREATER_THAN_HEX64(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_HEX64((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_GREATER_THAN_CHAR(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_CHAR((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_INT64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_INT64((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_UINT64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_UINT64((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_LESS_THAN_size_t(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_UINT((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) -#define TEST_ASSERT_LESS_THAN_HEX64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_HEX64((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_LESS_THAN_CHAR(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_CHAR((threshold), (actual), __LINE__, NULL) - -#define TEST_ASSERT_GREATER_OR_EQUAL(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_GREATER_OR_EQUAL_INT(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_GREATER_OR_EQUAL_INT8(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT8((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_GREATER_OR_EQUAL_INT16(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT16((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_GREATER_OR_EQUAL_INT32(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT32((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_GREATER_OR_EQUAL_INT64(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT64((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_GREATER_OR_EQUAL_UINT(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_GREATER_OR_EQUAL_UINT8(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT8((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_GREATER_OR_EQUAL_UINT16(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT16((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_GREATER_OR_EQUAL_UINT32(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT32((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_GREATER_OR_EQUAL_UINT64(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT64((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_GREATER_OR_EQUAL_size_t(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_GREATER_OR_EQUAL_HEX8(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX8((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_GREATER_OR_EQUAL_HEX16(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX16((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_GREATER_OR_EQUAL_HEX32(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX32((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_GREATER_OR_EQUAL_HEX64(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX64((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_GREATER_OR_EQUAL_CHAR(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_CHAR((threshold), (actual), __LINE__, NULL) - -#define TEST_ASSERT_LESS_OR_EQUAL(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_LESS_OR_EQUAL_INT(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_LESS_OR_EQUAL_INT8(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT8((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_LESS_OR_EQUAL_INT16(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT16((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_LESS_OR_EQUAL_INT32(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT32((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_LESS_OR_EQUAL_INT64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT64((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_LESS_OR_EQUAL_UINT(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_LESS_OR_EQUAL_UINT8(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT8((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_LESS_OR_EQUAL_UINT16(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT16((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_LESS_OR_EQUAL_UINT32(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT32((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_LESS_OR_EQUAL_UINT64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT64((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_LESS_OR_EQUAL_size_t(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_LESS_OR_EQUAL_HEX8(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX8((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_LESS_OR_EQUAL_HEX16(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX16((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_LESS_OR_EQUAL_HEX32(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX32((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_LESS_OR_EQUAL_HEX64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX64((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_LESS_OR_EQUAL_CHAR(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_CHAR((threshold), (actual), __LINE__, NULL) - -/* 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_INT8_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT8_WITHIN((delta), (expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_INT16_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT16_WITHIN((delta), (expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_INT32_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT32_WITHIN((delta), (expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_INT64_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT64_WITHIN((delta), (expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_UINT_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT_WITHIN((delta), (expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_UINT8_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT8_WITHIN((delta), (expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_UINT16_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT16_WITHIN((delta), (expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_UINT32_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT32_WITHIN((delta), (expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_UINT64_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT64_WITHIN((delta), (expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_size_t_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT_WITHIN((delta), (expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_HEX_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_HEX8_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX8_WITHIN((delta), (expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_HEX16_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX16_WITHIN((delta), (expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_HEX32_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_HEX64_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX64_WITHIN((delta), (expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_CHAR_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_CHAR_WITHIN((delta), (expected), (actual), __LINE__, NULL) - -/* Integer Array Ranges (of all sizes) */ -#define TEST_ASSERT_INT_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_INT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) -#define TEST_ASSERT_INT8_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_INT8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) -#define TEST_ASSERT_INT16_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_INT16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) -#define TEST_ASSERT_INT32_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_INT32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) -#define TEST_ASSERT_INT64_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_INT64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) -#define TEST_ASSERT_UINT_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) -#define TEST_ASSERT_UINT8_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) -#define TEST_ASSERT_UINT16_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) -#define TEST_ASSERT_UINT32_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) -#define TEST_ASSERT_UINT64_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) -#define TEST_ASSERT_size_t_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) -#define TEST_ASSERT_HEX_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) -#define TEST_ASSERT_HEX8_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_HEX8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) -#define TEST_ASSERT_HEX16_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_HEX16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) -#define TEST_ASSERT_HEX32_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) -#define TEST_ASSERT_HEX64_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_HEX64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) -#define TEST_ASSERT_CHAR_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_CHAR_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) - - -/* Structs and Strings */ -#define TEST_ASSERT_EQUAL_PTR(expected, actual) UNITY_TEST_ASSERT_EQUAL_PTR((expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_STRING(expected, actual) UNITY_TEST_ASSERT_EQUAL_STRING((expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_STRING_LEN(expected, actual, len) UNITY_TEST_ASSERT_EQUAL_STRING_LEN((expected), (actual), (len), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_MEMORY(expected, actual, len) UNITY_TEST_ASSERT_EQUAL_MEMORY((expected), (actual), (len), __LINE__, NULL) - -/* Arrays */ -#define TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_INT8_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT8_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_INT16_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT16_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_INT32_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT32_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_INT64_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT64_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_UINT_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_UINT8_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT8_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_UINT16_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_UINT32_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT32_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_size_t_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_HEX_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_HEX16_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX16_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_HEX32_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_HEX64_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_PTR_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_PTR_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_CHAR_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_CHAR_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) - -/* 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_INT8(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_INT8((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EACH_EQUAL_INT16(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_INT16((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EACH_EQUAL_INT32(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_INT32((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EACH_EQUAL_INT64(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_INT64((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EACH_EQUAL_UINT(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EACH_EQUAL_UINT8(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT8((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EACH_EQUAL_UINT16(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT16((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EACH_EQUAL_UINT32(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT32((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EACH_EQUAL_UINT64(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT64((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EACH_EQUAL_size_t(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EACH_EQUAL_HEX(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_HEX32((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EACH_EQUAL_HEX8(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_HEX8((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EACH_EQUAL_HEX16(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_HEX16((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EACH_EQUAL_HEX32(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_HEX32((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EACH_EQUAL_HEX64(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_HEX64((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EACH_EQUAL_PTR(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_PTR((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EACH_EQUAL_STRING(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_STRING((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EACH_EQUAL_MEMORY(expected, actual, len, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_MEMORY((expected), (actual), (len), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EACH_EQUAL_CHAR(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_CHAR((expected), (actual), (num_elements), __LINE__, NULL) - -/* Floating Point (If Enabled) */ -#define TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_FLOAT_WITHIN((delta), (expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_FLOAT_NOT_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_FLOAT_NOT_WITHIN((delta), (expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_FLOAT(expected, actual) UNITY_TEST_ASSERT_EQUAL_FLOAT((expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_NOT_EQUAL_FLOAT(expected, actual) UNITY_TEST_ASSERT_NOT_EQUAL_FLOAT((expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_FLOAT_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_FLOAT_ARRAY_WITHIN((delta), (expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EACH_EQUAL_FLOAT(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_GREATER_THAN_FLOAT(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_FLOAT((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_FLOAT((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_LESS_THAN_FLOAT(threshold, actual) UNITY_TEST_ASSERT_LESS_THAN_FLOAT((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_LESS_OR_EQUAL_FLOAT(threshold, actual) UNITY_TEST_ASSERT_LESS_OR_EQUAL_FLOAT((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_FLOAT_IS_INF(actual) UNITY_TEST_ASSERT_FLOAT_IS_INF((actual), __LINE__, NULL) -#define TEST_ASSERT_FLOAT_IS_NEG_INF(actual) UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF((actual), __LINE__, NULL) -#define TEST_ASSERT_FLOAT_IS_NAN(actual) UNITY_TEST_ASSERT_FLOAT_IS_NAN((actual), __LINE__, NULL) -#define TEST_ASSERT_FLOAT_IS_DETERMINATE(actual) UNITY_TEST_ASSERT_FLOAT_IS_DETERMINATE((actual), __LINE__, NULL) -#define TEST_ASSERT_FLOAT_IS_NOT_INF(actual) UNITY_TEST_ASSERT_FLOAT_IS_NOT_INF((actual), __LINE__, NULL) -#define TEST_ASSERT_FLOAT_IS_NOT_NEG_INF(actual) UNITY_TEST_ASSERT_FLOAT_IS_NOT_NEG_INF((actual), __LINE__, NULL) -#define TEST_ASSERT_FLOAT_IS_NOT_NAN(actual) UNITY_TEST_ASSERT_FLOAT_IS_NOT_NAN((actual), __LINE__, NULL) -#define TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(actual) UNITY_TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE((actual), __LINE__, NULL) - -/* Double (If Enabled) */ -#define TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_DOUBLE_WITHIN((delta), (expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_DOUBLE_NOT_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_DOUBLE_NOT_WITHIN((delta), (expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_DOUBLE(expected, actual) UNITY_TEST_ASSERT_EQUAL_DOUBLE((expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_NOT_EQUAL_DOUBLE(expected, actual) UNITY_TEST_ASSERT_NOT_EQUAL_DOUBLE((expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_DOUBLE_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_DOUBLE_ARRAY_WITHIN((delta), (expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_EACH_EQUAL_DOUBLE(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE((expected), (actual), (num_elements), __LINE__, NULL) -#define TEST_ASSERT_GREATER_THAN_DOUBLE(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_DOUBLE((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_LESS_THAN_DOUBLE(threshold, actual) UNITY_TEST_ASSERT_LESS_THAN_DOUBLE((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(threshold, actual) UNITY_TEST_ASSERT_LESS_OR_EQUAL_DOUBLE((threshold), (actual), __LINE__, NULL) -#define TEST_ASSERT_DOUBLE_IS_INF(actual) UNITY_TEST_ASSERT_DOUBLE_IS_INF((actual), __LINE__, NULL) -#define TEST_ASSERT_DOUBLE_IS_NEG_INF(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF((actual), __LINE__, NULL) -#define TEST_ASSERT_DOUBLE_IS_NAN(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NAN((actual), __LINE__, NULL) -#define TEST_ASSERT_DOUBLE_IS_DETERMINATE(actual) UNITY_TEST_ASSERT_DOUBLE_IS_DETERMINATE((actual), __LINE__, NULL) -#define TEST_ASSERT_DOUBLE_IS_NOT_INF(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_INF((actual), __LINE__, NULL) -#define TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF((actual), __LINE__, NULL) -#define TEST_ASSERT_DOUBLE_IS_NOT_NAN(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NAN((actual), __LINE__, NULL) -#define TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE((actual), __LINE__, NULL) - -/* Shorthand */ -#ifdef UNITY_SHORTHAND_AS_OLD -#define TEST_ASSERT_EQUAL(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_NOT_EQUAL(expected, actual) UNITY_TEST_ASSERT(((expected) != (actual)), __LINE__, " Expected Not-Equal") -#endif -#ifdef UNITY_SHORTHAND_AS_INT -#define TEST_ASSERT_EQUAL(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, NULL) -#define TEST_ASSERT_NOT_EQUAL(expected, actual) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand) -#endif -#ifdef UNITY_SHORTHAND_AS_MEM -#define TEST_ASSERT_EQUAL(expected, actual) UNITY_TEST_ASSERT_EQUAL_MEMORY((&expected), (&actual), sizeof(expected), __LINE__, NULL) -#define TEST_ASSERT_NOT_EQUAL(expected, actual) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand) -#endif -#ifdef UNITY_SHORTHAND_AS_RAW -#define TEST_ASSERT_EQUAL(expected, actual) UNITY_TEST_ASSERT(((expected) == (actual)), __LINE__, " Expected Equal") -#define TEST_ASSERT_NOT_EQUAL(expected, actual) UNITY_TEST_ASSERT(((expected) != (actual)), __LINE__, " Expected Not-Equal") -#endif -#ifdef UNITY_SHORTHAND_AS_NONE -#define TEST_ASSERT_EQUAL(expected, actual) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand) -#define TEST_ASSERT_NOT_EQUAL(expected, actual) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand) -#endif - -/*------------------------------------------------------- - * Test Asserts (with additional messages) - *-------------------------------------------------------*/ - -/* Boolean */ -#define TEST_ASSERT_MESSAGE(condition, message) UNITY_TEST_ASSERT( (condition), __LINE__, (message)) -#define TEST_ASSERT_TRUE_MESSAGE(condition, message) UNITY_TEST_ASSERT( (condition), __LINE__, (message)) -#define TEST_ASSERT_UNLESS_MESSAGE(condition, message) UNITY_TEST_ASSERT( !(condition), __LINE__, (message)) -#define TEST_ASSERT_FALSE_MESSAGE(condition, message) UNITY_TEST_ASSERT( !(condition), __LINE__, (message)) -#define TEST_ASSERT_NULL_MESSAGE(pointer, message) UNITY_TEST_ASSERT_NULL( (pointer), __LINE__, (message)) -#define TEST_ASSERT_NOT_NULL_MESSAGE(pointer, message) UNITY_TEST_ASSERT_NOT_NULL((pointer), __LINE__, (message)) -#define TEST_ASSERT_EMPTY_MESSAGE(pointer, message) UNITY_TEST_ASSERT_EMPTY( (pointer), __LINE__, (message)) -#define TEST_ASSERT_NOT_EMPTY_MESSAGE(pointer, message) UNITY_TEST_ASSERT_NOT_EMPTY((pointer), __LINE__, (message)) - -/* Integers (of all sizes) */ -#define TEST_ASSERT_EQUAL_INT_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_INT8_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT8((expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_INT16_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT16((expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_INT32_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT32((expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_INT64_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT64((expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_UINT_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT( (expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_UINT8_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT8( (expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_UINT16_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT16( (expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_UINT32_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT32( (expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_UINT64_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT64( (expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_size_t_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT( (expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_HEX_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_HEX8_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX8( (expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_HEX16_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX16((expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_HEX32_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_HEX64_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX64((expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_BITS_MESSAGE(mask, expected, actual, message) UNITY_TEST_ASSERT_BITS((mask), (expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_BITS_HIGH_MESSAGE(mask, actual, message) UNITY_TEST_ASSERT_BITS((mask), (UNITY_UINT32)(-1), (actual), __LINE__, (message)) -#define TEST_ASSERT_BITS_LOW_MESSAGE(mask, actual, message) UNITY_TEST_ASSERT_BITS((mask), (UNITY_UINT32)(0), (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_EQUAL_CHAR_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_CHAR((expected), (actual), __LINE__, (message)) - -/* Integer Not Equal To (of all sizes) */ -#define TEST_ASSERT_NOT_EQUAL_INT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_INT((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_NOT_EQUAL_INT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_INT8((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_NOT_EQUAL_INT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_INT16((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_NOT_EQUAL_INT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_INT32((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_NOT_EQUAL_INT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_INT64((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_NOT_EQUAL_UINT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_NOT_EQUAL_UINT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT8((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_NOT_EQUAL_UINT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT16((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_NOT_EQUAL_UINT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT32((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_NOT_EQUAL_UINT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT64((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_NOT_EQUAL_size_t_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_NOT_EQUAL_HEX8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_HEX8((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_NOT_EQUAL_HEX16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_HEX16((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_NOT_EQUAL_HEX32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_HEX32((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_NOT_EQUAL_HEX64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_HEX64((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_NOT_EQUAL_CHAR_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_CHAR((threshold), (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_INT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_INT64((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_UINT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_UINT64((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_GREATER_THAN_size_t_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_UINT((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_GREATER_THAN_HEX64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_HEX64((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_GREATER_THAN_CHAR_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_CHAR((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_INT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_INT64((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_UINT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_UINT64((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_LESS_THAN_size_t_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_UINT((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)) -#define TEST_ASSERT_LESS_THAN_HEX64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_HEX64((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_LESS_THAN_CHAR_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_CHAR((threshold), (actual), __LINE__, (message)) - -#define TEST_ASSERT_GREATER_OR_EQUAL_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_GREATER_OR_EQUAL_INT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_GREATER_OR_EQUAL_INT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT8((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_GREATER_OR_EQUAL_INT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT16((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_GREATER_OR_EQUAL_INT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT32((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_GREATER_OR_EQUAL_INT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT64((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_GREATER_OR_EQUAL_UINT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_GREATER_OR_EQUAL_UINT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT8((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_GREATER_OR_EQUAL_UINT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT16((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_GREATER_OR_EQUAL_UINT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT32((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_GREATER_OR_EQUAL_UINT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT64((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_GREATER_OR_EQUAL_size_t_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_GREATER_OR_EQUAL_HEX8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX8((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_GREATER_OR_EQUAL_HEX16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX16((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_GREATER_OR_EQUAL_HEX32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX32((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_GREATER_OR_EQUAL_HEX64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX64((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_GREATER_OR_EQUAL_CHAR_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_CHAR((threshold), (actual), __LINE__, (message)) - -#define TEST_ASSERT_LESS_OR_EQUAL_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_LESS_OR_EQUAL_INT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_LESS_OR_EQUAL_INT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT8((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_LESS_OR_EQUAL_INT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT16((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_LESS_OR_EQUAL_INT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT32((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_LESS_OR_EQUAL_INT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT64((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_LESS_OR_EQUAL_UINT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_LESS_OR_EQUAL_UINT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT8((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_LESS_OR_EQUAL_UINT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT16((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_LESS_OR_EQUAL_UINT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT32((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_LESS_OR_EQUAL_UINT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT64((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_LESS_OR_EQUAL_size_t_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_LESS_OR_EQUAL_HEX8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX8((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_LESS_OR_EQUAL_HEX16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX16((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_LESS_OR_EQUAL_HEX32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX32((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_LESS_OR_EQUAL_HEX64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX64((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_LESS_OR_EQUAL_CHAR_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_CHAR((threshold), (actual), __LINE__, (message)) - -/* 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_INT8_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT8_WITHIN((delta), (expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_INT16_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT16_WITHIN((delta), (expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_INT32_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT32_WITHIN((delta), (expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_INT64_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT64_WITHIN((delta), (expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_UINT_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT_WITHIN((delta), (expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_UINT8_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT8_WITHIN((delta), (expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_UINT16_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT16_WITHIN((delta), (expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_UINT32_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT32_WITHIN((delta), (expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_UINT64_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT64_WITHIN((delta), (expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_size_t_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT_WITHIN((delta), (expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_HEX_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_HEX8_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX8_WITHIN((delta), (expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_HEX16_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX16_WITHIN((delta), (expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_HEX32_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_HEX64_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX64_WITHIN((delta), (expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_CHAR_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_CHAR_WITHIN((delta), (expected), (actual), __LINE__, (message)) - -/* Integer Array Ranges (of all sizes) */ -#define TEST_ASSERT_INT_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_INT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) -#define TEST_ASSERT_INT8_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_INT8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) -#define TEST_ASSERT_INT16_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_INT16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) -#define TEST_ASSERT_INT32_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_INT32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) -#define TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_INT64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) -#define TEST_ASSERT_UINT_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) -#define TEST_ASSERT_UINT8_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) -#define TEST_ASSERT_UINT16_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) -#define TEST_ASSERT_UINT32_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) -#define TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) -#define TEST_ASSERT_size_t_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) -#define TEST_ASSERT_HEX_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) -#define TEST_ASSERT_HEX8_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_HEX8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) -#define TEST_ASSERT_HEX16_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_HEX16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) -#define TEST_ASSERT_HEX32_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) -#define TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_HEX64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) -#define TEST_ASSERT_CHAR_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_CHAR_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) - - -/* Structs and Strings */ -#define TEST_ASSERT_EQUAL_PTR_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_PTR((expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_STRING_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_STRING((expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_STRING_LEN_MESSAGE(expected, actual, len, message) UNITY_TEST_ASSERT_EQUAL_STRING_LEN((expected), (actual), (len), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_MEMORY_MESSAGE(expected, actual, len, message) UNITY_TEST_ASSERT_EQUAL_MEMORY((expected), (actual), (len), __LINE__, (message)) - -/* Arrays */ -#define TEST_ASSERT_EQUAL_INT_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_INT8_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT8_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_INT16_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT16_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_INT32_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT32_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_INT64_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT64_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_UINT_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT8_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_UINT16_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_UINT32_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT32_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_UINT64_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_size_t_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_HEX_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_HEX8_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_HEX16_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX16_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_HEX32_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_HEX64_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_PTR_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_PTR_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_STRING_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_STRING_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_MEMORY_ARRAY_MESSAGE(expected, actual, len, num_elements, message) UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((expected), (actual), (len), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_CHAR_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_CHAR_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) - -/* Arrays Compared To Single Value*/ -#define TEST_ASSERT_EACH_EQUAL_INT_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_INT((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EACH_EQUAL_INT8_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_INT8((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EACH_EQUAL_INT16_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_INT16((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EACH_EQUAL_INT32_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_INT32((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EACH_EQUAL_INT64_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_INT64((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EACH_EQUAL_UINT_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EACH_EQUAL_UINT8_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT8((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EACH_EQUAL_UINT16_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT16((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EACH_EQUAL_UINT32_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT32((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EACH_EQUAL_UINT64_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT64((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EACH_EQUAL_size_t_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EACH_EQUAL_HEX_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_HEX32((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EACH_EQUAL_HEX8_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_HEX8((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EACH_EQUAL_HEX16_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_HEX16((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EACH_EQUAL_HEX32_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_HEX32((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EACH_EQUAL_HEX64_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_HEX64((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EACH_EQUAL_PTR_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_PTR((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EACH_EQUAL_STRING_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_STRING((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EACH_EQUAL_MEMORY_MESSAGE(expected, actual, len, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_MEMORY((expected), (actual), (len), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EACH_EQUAL_CHAR_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_CHAR((expected), (actual), (num_elements), __LINE__, (message)) - -/* Floating Point (If Enabled) */ -#define TEST_ASSERT_FLOAT_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_FLOAT_WITHIN((delta), (expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_FLOAT_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_FLOAT((expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_NOT_EQUAL_FLOAT_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_FLOAT((expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_FLOAT_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_FLOAT_ARRAY_WITHIN((delta), (expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_FLOAT_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EACH_EQUAL_FLOAT_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_GREATER_THAN_FLOAT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_FLOAT((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_GREATER_OR_EQUAL_FLOAT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_FLOAT((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_LESS_THAN_FLOAT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_LESS_THAN_FLOAT((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_LESS_OR_EQUAL_FLOAT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_LESS_OR_EQUAL_FLOAT((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_FLOAT_IS_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_INF((actual), __LINE__, (message)) -#define TEST_ASSERT_FLOAT_IS_NEG_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF((actual), __LINE__, (message)) -#define TEST_ASSERT_FLOAT_IS_NAN_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NAN((actual), __LINE__, (message)) -#define TEST_ASSERT_FLOAT_IS_DETERMINATE_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_DETERMINATE((actual), __LINE__, (message)) -#define TEST_ASSERT_FLOAT_IS_NOT_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NOT_INF((actual), __LINE__, (message)) -#define TEST_ASSERT_FLOAT_IS_NOT_NEG_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NOT_NEG_INF((actual), __LINE__, (message)) -#define TEST_ASSERT_FLOAT_IS_NOT_NAN_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NOT_NAN((actual), __LINE__, (message)) -#define TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE((actual), __LINE__, (message)) - -/* Double (If Enabled) */ -#define TEST_ASSERT_DOUBLE_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_DOUBLE_WITHIN((delta), (expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_DOUBLE_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_DOUBLE((expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_NOT_EQUAL_DOUBLE_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_DOUBLE((expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_DOUBLE_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_DOUBLE_ARRAY_WITHIN((delta), (expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EQUAL_DOUBLE_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_EACH_EQUAL_DOUBLE_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE((expected), (actual), (num_elements), __LINE__, (message)) -#define TEST_ASSERT_GREATER_THAN_DOUBLE_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_DOUBLE((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_LESS_THAN_DOUBLE_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_LESS_THAN_DOUBLE((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_LESS_OR_EQUAL_DOUBLE_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_LESS_OR_EQUAL_DOUBLE((threshold), (actual), __LINE__, (message)) -#define TEST_ASSERT_DOUBLE_IS_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_INF((actual), __LINE__, (message)) -#define TEST_ASSERT_DOUBLE_IS_NEG_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF((actual), __LINE__, (message)) -#define TEST_ASSERT_DOUBLE_IS_NAN_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NAN((actual), __LINE__, (message)) -#define TEST_ASSERT_DOUBLE_IS_DETERMINATE_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_DETERMINATE((actual), __LINE__, (message)) -#define TEST_ASSERT_DOUBLE_IS_NOT_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_INF((actual), __LINE__, (message)) -#define TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF((actual), __LINE__, (message)) -#define TEST_ASSERT_DOUBLE_IS_NOT_NAN_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NAN((actual), __LINE__, (message)) -#define TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE((actual), __LINE__, (message)) - -/* Shorthand */ -#ifdef UNITY_SHORTHAND_AS_OLD -#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, (message)) -#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT(((expected) != (actual)), __LINE__, (message)) -#endif -#ifdef UNITY_SHORTHAND_AS_INT -#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, message) -#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand) -#endif -#ifdef UNITY_SHORTHAND_AS_MEM -#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_MEMORY((&expected), (&actual), sizeof(expected), __LINE__, message) -#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand) -#endif -#ifdef UNITY_SHORTHAND_AS_RAW -#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT(((expected) == (actual)), __LINE__, message) -#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT(((expected) != (actual)), __LINE__, message) -#endif -#ifdef UNITY_SHORTHAND_AS_NONE -#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand) -#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand) -#endif - -/* end of UNITY_FRAMEWORK_H */ -#ifdef __cplusplus -} -#endif -#endif diff --git a/subprojects/unity/src/unity_internals.h b/subprojects/unity/src/unity_internals.h deleted file mode 100644 index 562f5b6da6..0000000000 --- a/subprojects/unity/src/unity_internals.h +++ /dev/null @@ -1,1183 +0,0 @@ -/* ========================================================================= - Unity - A Test Framework for C - ThrowTheSwitch.org - Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams - SPDX-License-Identifier: MIT -========================================================================= */ - -#ifndef UNITY_INTERNALS_H -#define UNITY_INTERNALS_H - -#ifdef UNITY_INCLUDE_CONFIG_H -#include "unity_config.h" -#endif - -#ifndef UNITY_EXCLUDE_SETJMP_H -#include -#endif - -#ifndef UNITY_EXCLUDE_MATH_H -#include -#endif - -#ifndef UNITY_EXCLUDE_STDDEF_H -#include -#endif - -#ifdef UNITY_INCLUDE_PRINT_FORMATTED -#include -#endif - -/* Unity Attempts to Auto-Detect Integer Types - * Attempt 1: UINT_MAX, ULONG_MAX in , or default to 32 bits - * Attempt 2: UINTPTR_MAX in , or default to same size as long - * The user may override any of these derived constants: - * UNITY_INT_WIDTH, UNITY_LONG_WIDTH, UNITY_POINTER_WIDTH */ -#ifndef UNITY_EXCLUDE_STDINT_H -#include -#endif - -#ifndef UNITY_EXCLUDE_LIMITS_H -#include -#endif - -#if defined(__GNUC__) || defined(__clang__) - #define UNITY_FUNCTION_ATTR(a) __attribute__((a)) -#else - #define UNITY_FUNCTION_ATTR(a) /* ignore */ -#endif - -/* UNITY_NORETURN is only required if we have setjmp.h. */ -#ifndef UNITY_EXCLUDE_SETJMP_H - #ifndef UNITY_NORETURN - #if defined(__cplusplus) - #if __cplusplus >= 201103L - #define UNITY_NORETURN [[ noreturn ]] - #endif - #elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && __STDC_VERSION__ < 202311L - /* _Noreturn keyword is used from C11 but deprecated in C23. */ - #if defined(_WIN32) && defined(_MSC_VER) - /* We are using MSVC compiler on Windows platform. */ - /* Not all Windows SDKs supports , but compiler can support C11: */ - /* https://devblogs.microsoft.com/cppblog/c11-and-c17-standard-support-arriving-in-msvc/ */ - /* Not sure, that Mingw compilers has Windows SDK headers at all. */ - #include - #endif - - /* Using Windows SDK predefined macro for detecting supported SDK with MSVC compiler. */ - /* Mingw GCC should work without that fixes. */ - /* Based on: */ - /* https://docs.microsoft.com/en-us/cpp/porting/modifying-winver-and-win32-winnt?view=msvc-170 */ - /* NTDDI_WIN10_FE is equal to Windows 10 SDK 2104 */ - #if defined(_MSC_VER) && ((!defined(NTDDI_WIN10_FE)) || WDK_NTDDI_VERSION < NTDDI_WIN10_FE) - /* Based on tests and: */ - /* https://docs.microsoft.com/en-us/cpp/c-language/noreturn?view=msvc-170 */ - /* https://en.cppreference.com/w/c/language/_Noreturn */ - #define UNITY_NORETURN _Noreturn - #else /* Using newer Windows SDK or not MSVC compiler */ - #if defined(__GNUC__) - /* The header collides with __attribute(noreturn)__ from GCC. */ - #define UNITY_NORETURN _Noreturn - #else - #include - #define UNITY_NORETURN noreturn - #endif - #endif - #elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L - /* Since C23, the keyword _Noreturn has been replaced by the attribute noreturn, based on: */ - /* https://en.cppreference.com/w/c/language/attributes/noreturn */ - #define UNITY_NORETURN [[ noreturn ]] - #endif - #endif - #ifndef UNITY_NORETURN - #define UNITY_NORETURN UNITY_FUNCTION_ATTR(__noreturn__) - #endif -#endif - -/*------------------------------------------------------- - * Guess Widths If Not Specified - *-------------------------------------------------------*/ - -/* Determine the size of an int, if not already specified. - * We cannot use sizeof(int), because it is not yet defined - * at this stage in the translation of the C program. - * Also sizeof(int) does return the size in addressable units on all platforms, - * which may not necessarily be the size in bytes. - * Therefore, infer it from UINT_MAX if possible. */ -#ifndef UNITY_INT_WIDTH - #ifdef UINT_MAX - #if (UINT_MAX == 0xFFFF) - #define UNITY_INT_WIDTH (16) - #elif (UINT_MAX == 0xFFFFFFFF) - #define UNITY_INT_WIDTH (32) - #elif (UINT_MAX == 0xFFFFFFFFFFFFFFFF) - #define UNITY_INT_WIDTH (64) - #endif - #else /* Set to default */ - #define UNITY_INT_WIDTH (32) - #endif /* UINT_MAX */ -#endif - -/* Determine the size of a long, if not already specified. */ -#ifndef UNITY_LONG_WIDTH - #ifdef ULONG_MAX - #if (ULONG_MAX == 0xFFFF) - #define UNITY_LONG_WIDTH (16) - #elif (ULONG_MAX == 0xFFFFFFFF) - #define UNITY_LONG_WIDTH (32) - #elif (ULONG_MAX == 0xFFFFFFFFFFFFFFFF) - #define UNITY_LONG_WIDTH (64) - #endif - #else /* Set to default */ - #define UNITY_LONG_WIDTH (32) - #endif /* ULONG_MAX */ -#endif - -/* Determine the size of a pointer, if not already specified. */ -#ifndef UNITY_POINTER_WIDTH - #ifdef UINTPTR_MAX - #if (UINTPTR_MAX <= 0xFFFF) - #define UNITY_POINTER_WIDTH (16) - #elif (UINTPTR_MAX <= 0xFFFFFFFF) - #define UNITY_POINTER_WIDTH (32) - #elif (UINTPTR_MAX <= 0xFFFFFFFFFFFFFFFF) - #define UNITY_POINTER_WIDTH (64) - #endif - #else /* Set to default */ - #define UNITY_POINTER_WIDTH UNITY_LONG_WIDTH - #endif /* UINTPTR_MAX */ -#endif - -/*------------------------------------------------------- - * Int Support (Define types based on detected sizes) - *-------------------------------------------------------*/ - -#if (UNITY_INT_WIDTH == 32) - typedef unsigned char UNITY_UINT8; - typedef unsigned short UNITY_UINT16; - typedef unsigned int UNITY_UINT32; - typedef signed char UNITY_INT8; - typedef signed short UNITY_INT16; - typedef signed int UNITY_INT32; -#elif (UNITY_INT_WIDTH == 16) - typedef unsigned char UNITY_UINT8; - typedef unsigned int UNITY_UINT16; - typedef unsigned long UNITY_UINT32; - typedef signed char UNITY_INT8; - typedef signed int UNITY_INT16; - typedef signed long UNITY_INT32; -#else - #error Invalid UNITY_INT_WIDTH specified! (16 or 32 are supported) -#endif - -/*------------------------------------------------------- - * 64-bit Support - *-------------------------------------------------------*/ - -/* Auto-detect 64 Bit Support */ -#ifndef UNITY_SUPPORT_64 - #if UNITY_LONG_WIDTH == 64 || UNITY_POINTER_WIDTH == 64 - #define UNITY_SUPPORT_64 - #endif -#endif - -/* 64-Bit Support Dependent Configuration */ -#ifndef UNITY_SUPPORT_64 - /* No 64-bit Support */ - typedef UNITY_UINT32 UNITY_UINT; - typedef UNITY_INT32 UNITY_INT; - #define UNITY_MAX_NIBBLES (8) /* Maximum number of nibbles in a UNITY_(U)INT */ -#else - /* 64-bit Support */ - #if (UNITY_LONG_WIDTH == 32) - typedef unsigned long long UNITY_UINT64; - typedef signed long long UNITY_INT64; - #elif (UNITY_LONG_WIDTH == 64) - typedef unsigned long UNITY_UINT64; - typedef signed long UNITY_INT64; - #else - #error Invalid UNITY_LONG_WIDTH specified! (32 or 64 are supported) - #endif - typedef UNITY_UINT64 UNITY_UINT; - typedef UNITY_INT64 UNITY_INT; - #define UNITY_MAX_NIBBLES (16) /* Maximum number of nibbles in a UNITY_(U)INT */ -#endif - -/*------------------------------------------------------- - * Pointer Support - *-------------------------------------------------------*/ - -#if (UNITY_POINTER_WIDTH == 32) - #define UNITY_PTR_TO_INT UNITY_INT32 - #define UNITY_DISPLAY_STYLE_POINTER UNITY_DISPLAY_STYLE_HEX32 -#elif (UNITY_POINTER_WIDTH == 64) - #define UNITY_PTR_TO_INT UNITY_INT64 - #define UNITY_DISPLAY_STYLE_POINTER UNITY_DISPLAY_STYLE_HEX64 -#elif (UNITY_POINTER_WIDTH == 16) - #define UNITY_PTR_TO_INT UNITY_INT16 - #define UNITY_DISPLAY_STYLE_POINTER UNITY_DISPLAY_STYLE_HEX16 -#else - #error Invalid UNITY_POINTER_WIDTH specified! (16, 32 or 64 are supported) -#endif - -#ifndef UNITY_PTR_ATTRIBUTE - #define UNITY_PTR_ATTRIBUTE -#endif - -#ifndef UNITY_INTERNAL_PTR - #define UNITY_INTERNAL_PTR UNITY_PTR_ATTRIBUTE const void* -#endif - -/* optionally define UNITY_COMPARE_PTRS_ON_ZERO_ARRAY */ - -/*------------------------------------------------------- - * Float Support - *-------------------------------------------------------*/ - -#ifdef UNITY_EXCLUDE_FLOAT - -/* No Floating Point Support */ -#ifndef UNITY_EXCLUDE_DOUBLE -#define UNITY_EXCLUDE_DOUBLE /* Remove double when excluding float support */ -#endif -#ifndef UNITY_EXCLUDE_FLOAT_PRINT -#define UNITY_EXCLUDE_FLOAT_PRINT -#endif - -#else - -/* Floating Point Support */ -#ifndef UNITY_FLOAT_PRECISION -#define UNITY_FLOAT_PRECISION (0.00001f) -#endif -#ifndef UNITY_FLOAT_TYPE -#define UNITY_FLOAT_TYPE float -#endif -typedef UNITY_FLOAT_TYPE UNITY_FLOAT; - -/* isnan macro should be provided by math.h. Override if not macro */ -#ifndef UNITY_IS_NAN -#ifndef isnan -/* NaN is the only floating point value that does NOT equal itself. - * Therefore if n != n, then it is NaN. */ -#define UNITY_IS_NAN(n) ((n != n) ? 1 : 0) -#else -#define UNITY_IS_NAN(n) isnan(n) -#endif -#endif - -/* isinf macro should be provided by math.h. Override if not macro */ -#ifndef UNITY_IS_INF -#ifndef isinf -/* The value of Inf - Inf is NaN */ -#define UNITY_IS_INF(n) (UNITY_IS_NAN((n) - (n)) && !UNITY_IS_NAN(n)) -#else -#define UNITY_IS_INF(n) isinf(n) -#endif -#endif - -#endif - -/*------------------------------------------------------- - * Double Float Support - *-------------------------------------------------------*/ - -/* unlike float, we DON'T include by default */ -#if defined(UNITY_EXCLUDE_DOUBLE) || !defined(UNITY_INCLUDE_DOUBLE) - - /* No Floating Point Support */ - #ifndef UNITY_EXCLUDE_DOUBLE - #define UNITY_EXCLUDE_DOUBLE - #else - #undef UNITY_INCLUDE_DOUBLE - #endif - - #ifndef UNITY_EXCLUDE_FLOAT - #ifndef UNITY_DOUBLE_TYPE - #define UNITY_DOUBLE_TYPE double - #endif - typedef UNITY_FLOAT UNITY_DOUBLE; - /* For parameter in UnityPrintFloat(UNITY_DOUBLE), which aliases to double or float */ - #endif - -#else - - /* Double Floating Point Support */ - #ifndef UNITY_DOUBLE_PRECISION - #define UNITY_DOUBLE_PRECISION (1e-12) - #endif - - #ifndef UNITY_DOUBLE_TYPE - #define UNITY_DOUBLE_TYPE double - #endif - typedef UNITY_DOUBLE_TYPE UNITY_DOUBLE; - -#endif - -/*------------------------------------------------------- - * Output Method: stdout (DEFAULT) - *-------------------------------------------------------*/ -#ifndef UNITY_OUTPUT_CHAR - /* Default to using putchar, which is defined in stdio.h */ - #include - #define UNITY_OUTPUT_CHAR(a) (void)putchar(a) -#else - /* If defined as something else, make sure we declare it here so it's ready for use */ - #ifdef UNITY_OUTPUT_CHAR_HEADER_DECLARATION - extern void UNITY_OUTPUT_CHAR_HEADER_DECLARATION; - #endif -#endif - -#ifndef UNITY_OUTPUT_FLUSH - #ifdef UNITY_USE_FLUSH_STDOUT - /* We want to use the stdout flush utility */ - #include - #define UNITY_OUTPUT_FLUSH() (void)fflush(stdout) - #else - /* We've specified nothing, therefore flush should just be ignored */ - #define UNITY_OUTPUT_FLUSH() (void)0 - #endif -#else - /* If defined as something else, make sure we declare it here so it's ready for use */ - #ifdef UNITY_OUTPUT_FLUSH_HEADER_DECLARATION - extern void UNITY_OUTPUT_FLUSH_HEADER_DECLARATION; - #endif -#endif - -#ifndef UNITY_OUTPUT_FLUSH -#define UNITY_FLUSH_CALL() -#else -#define UNITY_FLUSH_CALL() UNITY_OUTPUT_FLUSH() -#endif - -#ifndef UNITY_PRINT_EOL -#define UNITY_PRINT_EOL() UNITY_OUTPUT_CHAR('\n') -#endif - -#ifndef UNITY_OUTPUT_START -#define UNITY_OUTPUT_START() -#endif - -#ifndef UNITY_OUTPUT_COMPLETE -#define UNITY_OUTPUT_COMPLETE() -#endif - -#ifdef UNITY_INCLUDE_EXEC_TIME - #if !defined(UNITY_EXEC_TIME_START) && \ - !defined(UNITY_EXEC_TIME_STOP) && \ - !defined(UNITY_PRINT_EXEC_TIME) && \ - !defined(UNITY_TIME_TYPE) - /* If none any of these macros are defined then try to provide a default implementation */ - - #if defined(UNITY_CLOCK_MS) - /* This is a simple way to get a default implementation on platforms that support getting a millisecond counter */ - #define UNITY_TIME_TYPE UNITY_UINT - #define UNITY_EXEC_TIME_START() Unity.CurrentTestStartTime = UNITY_CLOCK_MS() - #define UNITY_EXEC_TIME_STOP() Unity.CurrentTestStopTime = UNITY_CLOCK_MS() - #define UNITY_PRINT_EXEC_TIME() { \ - UNITY_UINT execTimeMs = (Unity.CurrentTestStopTime - Unity.CurrentTestStartTime); \ - UnityPrint(" ("); \ - UnityPrintNumberUnsigned(execTimeMs); \ - UnityPrint(" ms)"); \ - } - #elif defined(_WIN32) - #include - #define UNITY_TIME_TYPE clock_t - #define UNITY_GET_TIME(t) t = (clock_t)((clock() * 1000) / CLOCKS_PER_SEC) - #define UNITY_EXEC_TIME_START() UNITY_GET_TIME(Unity.CurrentTestStartTime) - #define UNITY_EXEC_TIME_STOP() UNITY_GET_TIME(Unity.CurrentTestStopTime) - #define UNITY_PRINT_EXEC_TIME() { \ - UNITY_UINT execTimeMs = (Unity.CurrentTestStopTime - Unity.CurrentTestStartTime); \ - UnityPrint(" ("); \ - UnityPrintNumberUnsigned(execTimeMs); \ - UnityPrint(" ms)"); \ - } - #elif defined(__unix__) || defined(__APPLE__) - #include - #define UNITY_TIME_TYPE struct timespec - #define UNITY_GET_TIME(t) clock_gettime(CLOCK_MONOTONIC, &t) - #define UNITY_EXEC_TIME_START() UNITY_GET_TIME(Unity.CurrentTestStartTime) - #define UNITY_EXEC_TIME_STOP() UNITY_GET_TIME(Unity.CurrentTestStopTime) - #define UNITY_PRINT_EXEC_TIME() { \ - UNITY_UINT execTimeMs = ((Unity.CurrentTestStopTime.tv_sec - Unity.CurrentTestStartTime.tv_sec) * 1000L); \ - execTimeMs += ((Unity.CurrentTestStopTime.tv_nsec - Unity.CurrentTestStartTime.tv_nsec) / 1000000L); \ - UnityPrint(" ("); \ - UnityPrintNumberUnsigned(execTimeMs); \ - UnityPrint(" ms)"); \ - } - #endif - #endif -#endif - -#ifndef UNITY_EXEC_TIME_START -#define UNITY_EXEC_TIME_START() do { /* nothing*/ } while (0) -#endif - -#ifndef UNITY_EXEC_TIME_STOP -#define UNITY_EXEC_TIME_STOP() do { /* nothing*/ } while (0) -#endif - -#ifndef UNITY_TIME_TYPE -#define UNITY_TIME_TYPE UNITY_UINT -#endif - -#ifndef UNITY_PRINT_EXEC_TIME -#define UNITY_PRINT_EXEC_TIME() do { /* nothing*/ } while (0) -#endif - -/*------------------------------------------------------- - * Footprint - *-------------------------------------------------------*/ - -#ifndef UNITY_LINE_TYPE -#define UNITY_LINE_TYPE UNITY_UINT -#endif - -#ifndef UNITY_COUNTER_TYPE -#define UNITY_COUNTER_TYPE UNITY_UINT -#endif - -/*------------------------------------------------------- - * Internal Structs Needed - *-------------------------------------------------------*/ - -typedef void (*UnityTestFunction)(void); - -#define UNITY_DISPLAY_RANGE_INT (0x10) -#define UNITY_DISPLAY_RANGE_UINT (0x20) -#define UNITY_DISPLAY_RANGE_HEX (0x40) -#define UNITY_DISPLAY_RANGE_CHAR (0x80) - -typedef enum -{ - UNITY_DISPLAY_STYLE_INT = (UNITY_INT_WIDTH / 8) + UNITY_DISPLAY_RANGE_INT, - UNITY_DISPLAY_STYLE_INT8 = 1 + UNITY_DISPLAY_RANGE_INT, - UNITY_DISPLAY_STYLE_INT16 = 2 + UNITY_DISPLAY_RANGE_INT, - UNITY_DISPLAY_STYLE_INT32 = 4 + UNITY_DISPLAY_RANGE_INT, -#ifdef UNITY_SUPPORT_64 - UNITY_DISPLAY_STYLE_INT64 = 8 + UNITY_DISPLAY_RANGE_INT, -#endif - - UNITY_DISPLAY_STYLE_UINT = (UNITY_INT_WIDTH / 8) + UNITY_DISPLAY_RANGE_UINT, - UNITY_DISPLAY_STYLE_UINT8 = 1 + UNITY_DISPLAY_RANGE_UINT, - UNITY_DISPLAY_STYLE_UINT16 = 2 + UNITY_DISPLAY_RANGE_UINT, - UNITY_DISPLAY_STYLE_UINT32 = 4 + UNITY_DISPLAY_RANGE_UINT, -#ifdef UNITY_SUPPORT_64 - UNITY_DISPLAY_STYLE_UINT64 = 8 + UNITY_DISPLAY_RANGE_UINT, -#endif - - UNITY_DISPLAY_STYLE_HEX8 = 1 + UNITY_DISPLAY_RANGE_HEX, - UNITY_DISPLAY_STYLE_HEX16 = 2 + UNITY_DISPLAY_RANGE_HEX, - UNITY_DISPLAY_STYLE_HEX32 = 4 + UNITY_DISPLAY_RANGE_HEX, -#ifdef UNITY_SUPPORT_64 - UNITY_DISPLAY_STYLE_HEX64 = 8 + UNITY_DISPLAY_RANGE_HEX, -#endif - - UNITY_DISPLAY_STYLE_CHAR = 1 + UNITY_DISPLAY_RANGE_CHAR + UNITY_DISPLAY_RANGE_INT, - - UNITY_DISPLAY_STYLE_UNKNOWN -} UNITY_DISPLAY_STYLE_T; - -typedef enum -{ - UNITY_WITHIN = 0x0, - UNITY_EQUAL_TO = 0x1, - UNITY_GREATER_THAN = 0x2, - UNITY_GREATER_OR_EQUAL = 0x2 + UNITY_EQUAL_TO, - UNITY_SMALLER_THAN = 0x4, - UNITY_SMALLER_OR_EQUAL = 0x4 + UNITY_EQUAL_TO, - UNITY_NOT_EQUAL = 0x0, - UNITY_UNKNOWN -} UNITY_COMPARISON_T; - -#ifndef UNITY_EXCLUDE_FLOAT -typedef enum UNITY_FLOAT_TRAIT -{ - UNITY_FLOAT_IS_NOT_INF = 0, - UNITY_FLOAT_IS_INF, - UNITY_FLOAT_IS_NOT_NEG_INF, - UNITY_FLOAT_IS_NEG_INF, - UNITY_FLOAT_IS_NOT_NAN, - UNITY_FLOAT_IS_NAN, - UNITY_FLOAT_IS_NOT_DET, - UNITY_FLOAT_IS_DET, - UNITY_FLOAT_INVALID_TRAIT -} UNITY_FLOAT_TRAIT_T; -#endif - -typedef enum -{ - UNITY_ARRAY_TO_VAL = 0, - UNITY_ARRAY_TO_ARRAY, - UNITY_ARRAY_UNKNOWN -} UNITY_FLAGS_T; - -struct UNITY_STORAGE_T -{ - const char* TestFile; - const char* CurrentTestName; -#ifndef UNITY_EXCLUDE_DETAILS - const char* CurrentDetail1; - const char* CurrentDetail2; -#endif - UNITY_LINE_TYPE CurrentTestLineNumber; - UNITY_COUNTER_TYPE NumberOfTests; - UNITY_COUNTER_TYPE TestFailures; - UNITY_COUNTER_TYPE TestIgnores; - UNITY_COUNTER_TYPE CurrentTestFailed; - UNITY_COUNTER_TYPE CurrentTestIgnored; -#ifdef UNITY_INCLUDE_EXEC_TIME - UNITY_TIME_TYPE CurrentTestStartTime; - UNITY_TIME_TYPE CurrentTestStopTime; -#endif -#ifndef UNITY_EXCLUDE_SETJMP_H - jmp_buf AbortFrame; -#endif -}; - -extern struct UNITY_STORAGE_T Unity; - -/*------------------------------------------------------- - * Test Suite Management - *-------------------------------------------------------*/ - -void UnityBegin(const char* filename); -int UnityEnd(void); -void UnitySetTestFile(const char* filename); -void UnityConcludeTest(void); - -#ifndef RUN_TEST -void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int FuncLineNum); -#else -#define UNITY_SKIP_DEFAULT_RUNNER -#endif - -/*------------------------------------------------------- - * Details Support - *-------------------------------------------------------*/ - -#ifdef UNITY_EXCLUDE_DETAILS -#define UNITY_CLR_DETAILS() -#define UNITY_SET_DETAIL(d1) -#define UNITY_SET_DETAILS(d1,d2) -#else -#define UNITY_CLR_DETAILS() do { Unity.CurrentDetail1 = 0; Unity.CurrentDetail2 = 0; } while (0) -#define UNITY_SET_DETAIL(d1) do { Unity.CurrentDetail1 = (d1); Unity.CurrentDetail2 = 0; } while (0) -#define UNITY_SET_DETAILS(d1,d2) do { Unity.CurrentDetail1 = (d1); Unity.CurrentDetail2 = (d2); } while (0) - -#ifndef UNITY_DETAIL1_NAME -#define UNITY_DETAIL1_NAME "Function" -#endif - -#ifndef UNITY_DETAIL2_NAME -#define UNITY_DETAIL2_NAME "Argument" -#endif -#endif - -#ifdef UNITY_PRINT_TEST_CONTEXT -void UNITY_PRINT_TEST_CONTEXT(void); -#endif - -/*------------------------------------------------------- - * Test Output - *-------------------------------------------------------*/ - -void UnityPrint(const char* string); - -#ifdef UNITY_INCLUDE_PRINT_FORMATTED -void UnityPrintF(const UNITY_LINE_TYPE line, const char* format, ...); -#endif - -void UnityPrintLen(const char* string, const UNITY_UINT32 length); -void UnityPrintMask(const UNITY_UINT mask, const UNITY_UINT number); -void UnityPrintNumberByStyle(const UNITY_INT number, const UNITY_DISPLAY_STYLE_T style); -void UnityPrintNumber(const UNITY_INT number_to_print); -void UnityPrintNumberUnsigned(const UNITY_UINT number); -void UnityPrintNumberHex(const UNITY_UINT number, const char nibbles_to_print); - -#ifndef UNITY_EXCLUDE_FLOAT_PRINT -void UnityPrintFloat(const UNITY_DOUBLE input_number); -#endif - -/*------------------------------------------------------- - * Test Assertion Functions - *------------------------------------------------------- - * Use the macros below this section instead of calling - * these directly. The macros have a consistent naming - * convention and will pull in file and line information - * for you. */ - -void UnityAssertEqualNumber(const UNITY_INT expected, - const UNITY_INT actual, - const char* msg, - const UNITY_LINE_TYPE lineNumber, - const UNITY_DISPLAY_STYLE_T style); - -void UnityAssertGreaterOrLessOrEqualNumber(const UNITY_INT threshold, - const UNITY_INT actual, - const UNITY_COMPARISON_T compare, - const char *msg, - const UNITY_LINE_TYPE lineNumber, - const UNITY_DISPLAY_STYLE_T style); - -void UnityAssertEqualIntArray(UNITY_INTERNAL_PTR expected, - UNITY_INTERNAL_PTR actual, - const UNITY_UINT32 num_elements, - const char* msg, - const UNITY_LINE_TYPE lineNumber, - const UNITY_DISPLAY_STYLE_T style, - const UNITY_FLAGS_T flags); - -void UnityAssertBits(const UNITY_INT mask, - const UNITY_INT expected, - const UNITY_INT actual, - const char* msg, - const UNITY_LINE_TYPE lineNumber); - -void UnityAssertEqualString(const char* expected, - const char* actual, - const char* msg, - const UNITY_LINE_TYPE lineNumber); - -void UnityAssertEqualStringLen(const char* expected, - const char* actual, - const UNITY_UINT32 length, - const char* msg, - const UNITY_LINE_TYPE lineNumber); - -void UnityAssertEqualStringArray( UNITY_INTERNAL_PTR expected, - const char** actual, - const UNITY_UINT32 num_elements, - const char* msg, - const UNITY_LINE_TYPE lineNumber, - const UNITY_FLAGS_T flags); - -void UnityAssertEqualMemory( UNITY_INTERNAL_PTR expected, - UNITY_INTERNAL_PTR actual, - const UNITY_UINT32 length, - const UNITY_UINT32 num_elements, - const char* msg, - const UNITY_LINE_TYPE lineNumber, - const UNITY_FLAGS_T flags); - -void UnityAssertNumbersWithin(const UNITY_UINT delta, - const UNITY_INT expected, - const UNITY_INT actual, - const char* msg, - const UNITY_LINE_TYPE lineNumber, - const UNITY_DISPLAY_STYLE_T style); - -void UnityAssertNumbersArrayWithin(const UNITY_UINT delta, - UNITY_INTERNAL_PTR expected, - UNITY_INTERNAL_PTR actual, - const UNITY_UINT32 num_elements, - const char* msg, - const UNITY_LINE_TYPE lineNumber, - const UNITY_DISPLAY_STYLE_T style, - const UNITY_FLAGS_T flags); - -#ifndef UNITY_EXCLUDE_SETJMP_H -UNITY_NORETURN void UnityFail(const char* message, const UNITY_LINE_TYPE line); -UNITY_NORETURN void UnityIgnore(const char* message, const UNITY_LINE_TYPE line); -#else -void UnityFail(const char* message, const UNITY_LINE_TYPE line); -void UnityIgnore(const char* message, const UNITY_LINE_TYPE line); -#endif - -void UnityMessage(const char* message, const UNITY_LINE_TYPE line); - -#ifndef UNITY_EXCLUDE_FLOAT -void UnityAssertFloatsWithin(const UNITY_FLOAT delta, - const UNITY_FLOAT expected, - const UNITY_FLOAT actual, - const char* msg, - const UNITY_LINE_TYPE lineNumber); - -void UnityAssertFloatsNotWithin(const UNITY_FLOAT delta, - const UNITY_FLOAT expected, - const UNITY_FLOAT actual, - const char* msg, - const UNITY_LINE_TYPE lineNumber); - -void UnityAssertGreaterOrLessFloat(const UNITY_FLOAT threshold, - const UNITY_FLOAT actual, - const UNITY_COMPARISON_T compare, - const char* msg, - const UNITY_LINE_TYPE linenumber); - -void UnityAssertWithinFloatArray(const UNITY_FLOAT delta, - UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* expected, - UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* actual, - const UNITY_UINT32 num_elements, - const char* msg, - const UNITY_LINE_TYPE lineNumber, - const UNITY_FLAGS_T flags); - -void UnityAssertFloatSpecial(const UNITY_FLOAT actual, - const char* msg, - const UNITY_LINE_TYPE lineNumber, - const UNITY_FLOAT_TRAIT_T style); -#endif - -#ifndef UNITY_EXCLUDE_DOUBLE -void UnityAssertDoublesWithin(const UNITY_DOUBLE delta, - const UNITY_DOUBLE expected, - const UNITY_DOUBLE actual, - const char* msg, - const UNITY_LINE_TYPE lineNumber); - -void UnityAssertDoublesNotWithin(const UNITY_DOUBLE delta, - const UNITY_DOUBLE expected, - const UNITY_DOUBLE actual, - const char* msg, - const UNITY_LINE_TYPE lineNumber); - -void UnityAssertGreaterOrLessDouble(const UNITY_DOUBLE threshold, - const UNITY_DOUBLE actual, - const UNITY_COMPARISON_T compare, - const char* msg, - const UNITY_LINE_TYPE linenumber); - -void UnityAssertWithinDoubleArray(const UNITY_DOUBLE delta, - UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* expected, - UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* actual, - const UNITY_UINT32 num_elements, - const char* msg, - const UNITY_LINE_TYPE lineNumber, - const UNITY_FLAGS_T flags); - -void UnityAssertDoubleSpecial(const UNITY_DOUBLE actual, - const char* msg, - const UNITY_LINE_TYPE lineNumber, - const UNITY_FLOAT_TRAIT_T style); -#endif - -/*------------------------------------------------------- - * Helpers - *-------------------------------------------------------*/ - -UNITY_INTERNAL_PTR UnityNumToPtr(const UNITY_INT num, const UNITY_UINT8 size); -#ifndef UNITY_EXCLUDE_FLOAT -UNITY_INTERNAL_PTR UnityFloatToPtr(const float num); -#endif -#ifndef UNITY_EXCLUDE_DOUBLE -UNITY_INTERNAL_PTR UnityDoubleToPtr(const double num); -#endif - -/*------------------------------------------------------- - * Error Strings We Might Need - *-------------------------------------------------------*/ - -extern const char UnityStrOk[]; -extern const char UnityStrPass[]; -extern const char UnityStrFail[]; -extern const char UnityStrIgnore[]; - -extern const char UnityStrErrFloat[]; -extern const char UnityStrErrDouble[]; -extern const char UnityStrErr64[]; -extern const char UnityStrErrShorthand[]; - -/*------------------------------------------------------- - * Test Running Macros - *-------------------------------------------------------*/ - -#ifdef UNITY_TEST_PROTECT -#define TEST_PROTECT() UNITY_TEST_PROTECT() -#else -#ifndef UNITY_EXCLUDE_SETJMP_H -#define TEST_PROTECT() (setjmp(Unity.AbortFrame) == 0) -#else -#define TEST_PROTECT() 1 -#endif -#endif - -#ifdef UNITY_TEST_ABORT -#define TEST_ABORT() UNITY_TEST_ABORT() -#else -#ifndef UNITY_EXCLUDE_SETJMP_H -#define TEST_ABORT() longjmp(Unity.AbortFrame, 1) -#else -#define TEST_ABORT() return -#endif -#endif - -/* Automatically enable variadic macros support, if it not enabled before */ -#ifndef UNITY_SUPPORT_VARIADIC_MACROS - #ifdef __STDC_VERSION__ - #if __STDC_VERSION__ >= 199901L - #define UNITY_SUPPORT_VARIADIC_MACROS - #endif - #endif -#endif - -/* This tricky series of macros gives us an optional line argument to treat it as RUN_TEST(func, num=__LINE__) */ -#ifndef RUN_TEST -#ifdef UNITY_SUPPORT_VARIADIC_MACROS -#define RUN_TEST(...) RUN_TEST_AT_LINE(__VA_ARGS__, __LINE__, throwaway) -#define RUN_TEST_AT_LINE(func, line, ...) UnityDefaultTestRun(func, #func, line) -#endif -#endif - -/* Enable default macros for masking param tests test cases */ -#ifdef UNITY_SUPPORT_TEST_CASES - #ifdef UNITY_SUPPORT_VARIADIC_MACROS - #if !defined(TEST_CASE) && !defined(UNITY_EXCLUDE_TEST_CASE) - #define TEST_CASE(...) - #endif - #if !defined(TEST_RANGE) && !defined(UNITY_EXCLUDE_TEST_RANGE) - #define TEST_RANGE(...) - #endif - #if !defined(TEST_MATRIX) && !defined(UNITY_EXCLUDE_TEST_MATRIX) - #define TEST_MATRIX(...) - #endif - #endif -#endif - -/* If we can't do the tricky version, we'll just have to require them to always include the line number */ -#ifndef RUN_TEST -#ifdef CMOCK -#define RUN_TEST(func, num) UnityDefaultTestRun(func, #func, num) -#else -#define RUN_TEST(func) UnityDefaultTestRun(func, #func, __LINE__) -#endif -#endif - -#define TEST_LINE_NUM (Unity.CurrentTestLineNumber) -#define TEST_IS_IGNORED (Unity.CurrentTestIgnored) -#define UNITY_NEW_TEST(a) \ - Unity.CurrentTestName = (a); \ - Unity.CurrentTestLineNumber = (UNITY_LINE_TYPE)(__LINE__); \ - Unity.NumberOfTests++; - -#ifndef UNITY_BEGIN -#define UNITY_BEGIN() UnityBegin(__FILE__) -#endif - -#ifndef UNITY_END -#define UNITY_END() UnityEnd() -#endif - -#ifndef UNITY_SHORTHAND_AS_INT -#ifndef UNITY_SHORTHAND_AS_MEM -#ifndef UNITY_SHORTHAND_AS_NONE -#ifndef UNITY_SHORTHAND_AS_RAW -#define UNITY_SHORTHAND_AS_OLD -#endif -#endif -#endif -#endif - -/*----------------------------------------------- - * Command Line Argument Support - *-----------------------------------------------*/ - -#ifdef UNITY_USE_COMMAND_LINE_ARGS -int UnityParseOptions(int argc, char** argv); -int UnityTestMatches(void); -#endif - -/*------------------------------------------------------- - * Basic Fail and Ignore - *-------------------------------------------------------*/ - -#define UNITY_TEST_FAIL(line, message) UnityFail( (message), (UNITY_LINE_TYPE)(line)) -#define UNITY_TEST_IGNORE(line, message) UnityIgnore( (message), (UNITY_LINE_TYPE)(line)) - -/*------------------------------------------------------- - * Test Asserts - *-------------------------------------------------------*/ - -#define UNITY_TEST_ASSERT(condition, line, message) do { if (condition) { /* nothing*/ } else { UNITY_TEST_FAIL((line), (message)); } } while (0) -#define UNITY_TEST_ASSERT_NULL(pointer, line, message) UNITY_TEST_ASSERT(((pointer) == NULL), (line), (message)) -#define UNITY_TEST_ASSERT_NOT_NULL(pointer, line, message) UNITY_TEST_ASSERT(((pointer) != NULL), (line), (message)) -#define UNITY_TEST_ASSERT_EMPTY(pointer, line, message) UNITY_TEST_ASSERT(((pointer[0]) == 0), (line), (message)) -#define UNITY_TEST_ASSERT_NOT_EMPTY(pointer, line, message) UNITY_TEST_ASSERT(((pointer[0]) != 0), (line), (message)) - -#define UNITY_TEST_ASSERT_EQUAL_INT(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT) -#define UNITY_TEST_ASSERT_EQUAL_INT8(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT8 )(expected), (UNITY_INT)(UNITY_INT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8) -#define UNITY_TEST_ASSERT_EQUAL_INT16(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT16)(expected), (UNITY_INT)(UNITY_INT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16) -#define UNITY_TEST_ASSERT_EQUAL_INT32(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT32)(expected), (UNITY_INT)(UNITY_INT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) -#define UNITY_TEST_ASSERT_EQUAL_UINT(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) -#define UNITY_TEST_ASSERT_EQUAL_UINT8(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_UINT8 )(expected), (UNITY_INT)(UNITY_UINT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) -#define UNITY_TEST_ASSERT_EQUAL_UINT16(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_UINT16)(expected), (UNITY_INT)(UNITY_UINT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) -#define UNITY_TEST_ASSERT_EQUAL_UINT32(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_UINT32)(expected), (UNITY_INT)(UNITY_UINT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) -#define UNITY_TEST_ASSERT_EQUAL_HEX8(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT8 )(expected), (UNITY_INT)(UNITY_INT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) -#define UNITY_TEST_ASSERT_EQUAL_HEX16(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT16)(expected), (UNITY_INT)(UNITY_INT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) -#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_CHAR(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT8 )(expected), (UNITY_INT)(UNITY_INT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR) -#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_NOT_EQUAL_INT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT) -#define UNITY_TEST_ASSERT_NOT_EQUAL_INT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8) -#define UNITY_TEST_ASSERT_NOT_EQUAL_INT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT16)(threshold), (UNITY_INT)(UNITY_INT16)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16) -#define UNITY_TEST_ASSERT_NOT_EQUAL_INT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT32)(threshold), (UNITY_INT)(UNITY_INT32)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) -#define UNITY_TEST_ASSERT_NOT_EQUAL_UINT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) -#define UNITY_TEST_ASSERT_NOT_EQUAL_UINT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) -#define UNITY_TEST_ASSERT_NOT_EQUAL_UINT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) -#define UNITY_TEST_ASSERT_NOT_EQUAL_UINT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) -#define UNITY_TEST_ASSERT_NOT_EQUAL_HEX8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) -#define UNITY_TEST_ASSERT_NOT_EQUAL_HEX16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) -#define UNITY_TEST_ASSERT_NOT_EQUAL_HEX32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32) -#define UNITY_TEST_ASSERT_NOT_EQUAL_CHAR(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR) - -#define UNITY_TEST_ASSERT_GREATER_THAN_INT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT) -#define UNITY_TEST_ASSERT_GREATER_THAN_INT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8) -#define UNITY_TEST_ASSERT_GREATER_THAN_INT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT16)(threshold), (UNITY_INT)(UNITY_INT16)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16) -#define UNITY_TEST_ASSERT_GREATER_THAN_INT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT32)(threshold), (UNITY_INT)(UNITY_INT32)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) -#define UNITY_TEST_ASSERT_GREATER_THAN_UINT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) -#define UNITY_TEST_ASSERT_GREATER_THAN_UINT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) -#define UNITY_TEST_ASSERT_GREATER_THAN_UINT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) -#define UNITY_TEST_ASSERT_GREATER_THAN_UINT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) -#define UNITY_TEST_ASSERT_GREATER_THAN_HEX8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) -#define UNITY_TEST_ASSERT_GREATER_THAN_HEX16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) -#define UNITY_TEST_ASSERT_GREATER_THAN_HEX32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32) -#define UNITY_TEST_ASSERT_GREATER_THAN_CHAR(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR) - -#define UNITY_TEST_ASSERT_SMALLER_THAN_INT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT) -#define UNITY_TEST_ASSERT_SMALLER_THAN_INT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8) -#define UNITY_TEST_ASSERT_SMALLER_THAN_INT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT16)(threshold), (UNITY_INT)(UNITY_INT16)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16) -#define UNITY_TEST_ASSERT_SMALLER_THAN_INT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT32)(threshold), (UNITY_INT)(UNITY_INT32)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) -#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) -#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) -#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) -#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) -#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) -#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) -#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32) -#define UNITY_TEST_ASSERT_SMALLER_THAN_CHAR(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR) - -#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT) (threshold), (UNITY_INT) (actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT) -#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 ) (threshold), (UNITY_INT)(UNITY_INT8 ) (actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8) -#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT16) (threshold), (UNITY_INT)(UNITY_INT16) (actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16) -#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT32) (threshold), (UNITY_INT)(UNITY_INT32) (actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) -#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT) (threshold), (UNITY_INT) (actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) -#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) -#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) -#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) -#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) -#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) -#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32) -#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_CHAR(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 ) (threshold), (UNITY_INT)(UNITY_INT8 ) (actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR) - -#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT) (threshold), (UNITY_INT) (actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT) -#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 ) (actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8) -#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT16)(threshold), (UNITY_INT)(UNITY_INT16) (actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16) -#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT32)(threshold), (UNITY_INT)(UNITY_INT32) (actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) -#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT) (threshold), (UNITY_INT) (actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) -#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) -#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) -#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) -#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) -#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) -#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32) -#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_CHAR(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 ) (actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR) - -#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_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_INT32_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT32)(delta), (UNITY_INT)(UNITY_INT32) (expected), (UNITY_INT)(UNITY_INT32) (actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) -#define UNITY_TEST_ASSERT_UINT_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin( (delta), (UNITY_INT) (expected), (UNITY_INT) (actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) -#define UNITY_TEST_ASSERT_UINT8_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT8 )(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT8 )(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) -#define UNITY_TEST_ASSERT_UINT16_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT16)(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT16)(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) -#define UNITY_TEST_ASSERT_UINT32_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT32)(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT32)(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) -#define UNITY_TEST_ASSERT_HEX8_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT8 )(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT8 )(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) -#define UNITY_TEST_ASSERT_HEX16_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT16)(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT16)(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) -#define UNITY_TEST_ASSERT_HEX32_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT32)(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT32)(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32) -#define UNITY_TEST_ASSERT_CHAR_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_CHAR) - -#define UNITY_TEST_ASSERT_INT_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin( (delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT, UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_INT8_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT8 )(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8, UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_INT16_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT16)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16, UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_INT32_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT32)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32, UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_UINT_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin( (delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT, UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_UINT8_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT8 )(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8, UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_UINT16_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT16)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16, UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_UINT32_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT32)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32, UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_HEX8_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT8 )(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8, UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_HEX16_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT16)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16, UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT32)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32, UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_CHAR_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT8 )(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR, UNITY_ARRAY_TO_ARRAY) - - -#define UNITY_TEST_ASSERT_EQUAL_PTR(expected, actual, line, message) UnityAssertEqualNumber((UNITY_PTR_TO_INT)(expected), (UNITY_PTR_TO_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_POINTER) -#define UNITY_TEST_ASSERT_EQUAL_STRING(expected, actual, line, message) UnityAssertEqualString((const char*)(expected), (const char*)(actual), (message), (UNITY_LINE_TYPE)(line)) -#define UNITY_TEST_ASSERT_EQUAL_STRING_LEN(expected, actual, len, line, message) UnityAssertEqualStringLen((const char*)(expected), (const char*)(actual), (UNITY_UINT32)(len), (message), (UNITY_LINE_TYPE)(line)) -#define UNITY_TEST_ASSERT_EQUAL_MEMORY(expected, actual, len, line, message) UnityAssertEqualMemory((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(len), 1, (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) - -#define UNITY_TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT, UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_EQUAL_INT8_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8, UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_EQUAL_INT16_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16, UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_EQUAL_INT32_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32, UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT, UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_EQUAL_UINT8_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8, UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16, UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_EQUAL_UINT32_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32, UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8, UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_EQUAL_HEX16_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16, UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32, UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_EQUAL_PTR_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_POINTER, UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualStringArray((UNITY_INTERNAL_PTR)(expected), (const char**)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY(expected, actual, len, num_elements, line, message) UnityAssertEqualMemory((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(len), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_EQUAL_CHAR_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR, UNITY_ARRAY_TO_ARRAY) - -#define UNITY_TEST_ASSERT_EACH_EQUAL_INT(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT) (expected), (UNITY_INT_WIDTH / 8)), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT, UNITY_ARRAY_TO_VAL) -#define UNITY_TEST_ASSERT_EACH_EQUAL_INT8(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT8 )(expected), 1), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8, UNITY_ARRAY_TO_VAL) -#define UNITY_TEST_ASSERT_EACH_EQUAL_INT16(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT16 )(expected), 2), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16, UNITY_ARRAY_TO_VAL) -#define UNITY_TEST_ASSERT_EACH_EQUAL_INT32(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT32 )(expected), 4), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32, UNITY_ARRAY_TO_VAL) -#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT) (expected), (UNITY_INT_WIDTH / 8)), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT, UNITY_ARRAY_TO_VAL) -#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT8(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_UINT8 )(expected), 1), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8, UNITY_ARRAY_TO_VAL) -#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT16(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_UINT16)(expected), 2), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16, UNITY_ARRAY_TO_VAL) -#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT32(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_UINT32)(expected), 4), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32, UNITY_ARRAY_TO_VAL) -#define UNITY_TEST_ASSERT_EACH_EQUAL_HEX8(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT8 )(expected), 1), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8, UNITY_ARRAY_TO_VAL) -#define UNITY_TEST_ASSERT_EACH_EQUAL_HEX16(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT16 )(expected), 2), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16, UNITY_ARRAY_TO_VAL) -#define UNITY_TEST_ASSERT_EACH_EQUAL_HEX32(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT32 )(expected), 4), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32, UNITY_ARRAY_TO_VAL) -#define UNITY_TEST_ASSERT_EACH_EQUAL_PTR(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_PTR_TO_INT) (expected), (UNITY_POINTER_WIDTH / 8)), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_POINTER, UNITY_ARRAY_TO_VAL) -#define UNITY_TEST_ASSERT_EACH_EQUAL_STRING(expected, actual, num_elements, line, message) UnityAssertEqualStringArray((UNITY_INTERNAL_PTR)(expected), (const char**)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL) -#define UNITY_TEST_ASSERT_EACH_EQUAL_MEMORY(expected, actual, len, num_elements, line, message) UnityAssertEqualMemory((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(len), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL) -#define UNITY_TEST_ASSERT_EACH_EQUAL_CHAR(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT8 )(expected), 1), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR, UNITY_ARRAY_TO_VAL) - -#ifdef UNITY_SUPPORT_64 -#define UNITY_TEST_ASSERT_EQUAL_INT64(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) -#define UNITY_TEST_ASSERT_EQUAL_UINT64(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) -#define UNITY_TEST_ASSERT_EQUAL_HEX64(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) -#define UNITY_TEST_ASSERT_EQUAL_INT64_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64, UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64, UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64, UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_EACH_EQUAL_INT64(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT64)(expected), 8), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64, UNITY_ARRAY_TO_VAL) -#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT64(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_UINT64)(expected), 8), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64, UNITY_ARRAY_TO_VAL) -#define UNITY_TEST_ASSERT_EACH_EQUAL_HEX64(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT64)(expected), 8), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64, UNITY_ARRAY_TO_VAL) -#define UNITY_TEST_ASSERT_INT64_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((delta), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) -#define UNITY_TEST_ASSERT_UINT64_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((delta), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) -#define UNITY_TEST_ASSERT_HEX64_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((delta), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) -#define UNITY_TEST_ASSERT_NOT_EQUAL_INT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) -#define UNITY_TEST_ASSERT_NOT_EQUAL_UINT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) -#define UNITY_TEST_ASSERT_NOT_EQUAL_HEX64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) -#define UNITY_TEST_ASSERT_GREATER_THAN_INT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) -#define UNITY_TEST_ASSERT_GREATER_THAN_UINT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) -#define UNITY_TEST_ASSERT_GREATER_THAN_HEX64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) -#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) -#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) -#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) -#define UNITY_TEST_ASSERT_SMALLER_THAN_INT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) -#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) -#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) -#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) -#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) -#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) -#define UNITY_TEST_ASSERT_INT64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT64)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64, UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_UINT64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT64)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64, UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_HEX64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT64)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64, UNITY_ARRAY_TO_ARRAY) -#else -#define UNITY_TEST_ASSERT_EQUAL_INT64(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) -#define UNITY_TEST_ASSERT_EQUAL_UINT64(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) -#define UNITY_TEST_ASSERT_EQUAL_HEX64(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) -#define UNITY_TEST_ASSERT_EQUAL_INT64_ARRAY(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) -#define UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) -#define UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) -#define UNITY_TEST_ASSERT_INT64_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) -#define UNITY_TEST_ASSERT_UINT64_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) -#define UNITY_TEST_ASSERT_HEX64_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) -#define UNITY_TEST_ASSERT_GREATER_THAN_INT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) -#define UNITY_TEST_ASSERT_GREATER_THAN_UINT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) -#define UNITY_TEST_ASSERT_GREATER_THAN_HEX64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) -#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) -#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) -#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) -#define UNITY_TEST_ASSERT_SMALLER_THAN_INT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) -#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) -#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) -#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) -#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) -#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) -#define UNITY_TEST_ASSERT_INT64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) -#define UNITY_TEST_ASSERT_UINT64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) -#define UNITY_TEST_ASSERT_HEX64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) -#endif - -#ifdef UNITY_EXCLUDE_FLOAT -#define UNITY_TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) -#define UNITY_TEST_ASSERT_FLOAT_NOT_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) -#define UNITY_TEST_ASSERT_EQUAL_FLOAT(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) -#define UNITY_TEST_ASSERT_NOT_EQUAL_FLOAT(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) -#define UNITY_TEST_ASSERT_FLOAT_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) -#define UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) -#define UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) -#define UNITY_TEST_ASSERT_GREATER_THAN_FLOAT(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) -#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) -#define UNITY_TEST_ASSERT_LESS_THAN_FLOAT(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) -#define UNITY_TEST_ASSERT_LESS_OR_EQUAL_FLOAT(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) -#define UNITY_TEST_ASSERT_FLOAT_IS_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) -#define UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) -#define UNITY_TEST_ASSERT_FLOAT_IS_NAN(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) -#define UNITY_TEST_ASSERT_FLOAT_IS_DETERMINATE(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) -#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) -#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_NEG_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) -#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_NAN(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) -#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) -#else -#define UNITY_TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual, line, message) UnityAssertFloatsWithin((UNITY_FLOAT)(delta), (UNITY_FLOAT)(expected), (UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line)) -#define UNITY_TEST_ASSERT_FLOAT_NOT_WITHIN(delta, expected, actual, line, message) UnityAssertFloatsNotWithin((UNITY_FLOAT)(delta), (UNITY_FLOAT)(expected), (UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line)) -#define UNITY_TEST_ASSERT_EQUAL_FLOAT(expected, actual, line, message) UNITY_TEST_ASSERT_FLOAT_WITHIN((UNITY_FLOAT)(expected) * (UNITY_FLOAT)UNITY_FLOAT_PRECISION, (UNITY_FLOAT)(expected), (UNITY_FLOAT)(actual), (UNITY_LINE_TYPE)(line), (message)) -#define UNITY_TEST_ASSERT_NOT_EQUAL_FLOAT(expected, actual, line, message) UNITY_TEST_ASSERT_FLOAT_NOT_WITHIN((UNITY_FLOAT)(expected) * (UNITY_FLOAT)UNITY_FLOAT_PRECISION, (UNITY_FLOAT)(expected), (UNITY_FLOAT)(actual), (UNITY_LINE_TYPE)(line), (message)) -#define UNITY_TEST_ASSERT_FLOAT_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertWithinFloatArray((UNITY_FLOAT)(delta), (const UNITY_FLOAT*)(expected), (const UNITY_FLOAT*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, line, message) UnityAssertWithinFloatArray((UNITY_FLOAT)0, (const UNITY_FLOAT*)(expected), (const UNITY_FLOAT*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT(expected, actual, num_elements, line, message) UnityAssertWithinFloatArray((UNITY_FLOAT)0, UnityFloatToPtr(expected), (const UNITY_FLOAT*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL) -#define UNITY_TEST_ASSERT_GREATER_THAN_FLOAT(threshold, actual, line, message) UnityAssertGreaterOrLessFloat((UNITY_FLOAT)(threshold), (UNITY_FLOAT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line)) -#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(threshold, actual, line, message) UnityAssertGreaterOrLessFloat((UNITY_FLOAT)(threshold), (UNITY_FLOAT)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line)) -#define UNITY_TEST_ASSERT_LESS_THAN_FLOAT(threshold, actual, line, message) UnityAssertGreaterOrLessFloat((UNITY_FLOAT)(threshold), (UNITY_FLOAT)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line)) -#define UNITY_TEST_ASSERT_LESS_OR_EQUAL_FLOAT(threshold, actual, line, message) UnityAssertGreaterOrLessFloat((UNITY_FLOAT)(threshold), (UNITY_FLOAT)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line)) -#define UNITY_TEST_ASSERT_FLOAT_IS_INF(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_INF) -#define UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NEG_INF) -#define UNITY_TEST_ASSERT_FLOAT_IS_NAN(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NAN) -#define UNITY_TEST_ASSERT_FLOAT_IS_DETERMINATE(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_DET) -#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_INF(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_INF) -#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_NEG_INF(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_NEG_INF) -#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_NAN(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_NAN) -#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_DET) -#endif - -#ifdef UNITY_EXCLUDE_DOUBLE -#define UNITY_TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) -#define UNITY_TEST_ASSERT_DOUBLE_NOT_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) -#define UNITY_TEST_ASSERT_EQUAL_DOUBLE(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) -#define UNITY_TEST_ASSERT_NOT_EQUAL_DOUBLE(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) -#define UNITY_TEST_ASSERT_DOUBLE_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) -#define UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) -#define UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) -#define UNITY_TEST_ASSERT_GREATER_THAN_DOUBLE(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) -#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) -#define UNITY_TEST_ASSERT_LESS_THAN_DOUBLE(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) -#define UNITY_TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) -#define UNITY_TEST_ASSERT_DOUBLE_IS_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) -#define UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) -#define UNITY_TEST_ASSERT_DOUBLE_IS_NAN(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) -#define UNITY_TEST_ASSERT_DOUBLE_IS_DETERMINATE(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) -#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) -#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) -#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NAN(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) -#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) -#else -#define UNITY_TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual, line, message) UnityAssertDoublesWithin((UNITY_DOUBLE)(delta), (UNITY_DOUBLE)(expected), (UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line)) -#define UNITY_TEST_ASSERT_DOUBLE_NOT_WITHIN(delta, expected, actual, line, message) UnityAssertDoublesNotWithin((UNITY_DOUBLE)(delta), (UNITY_DOUBLE)(expected), (UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line)) -#define UNITY_TEST_ASSERT_EQUAL_DOUBLE(expected, actual, line, message) UNITY_TEST_ASSERT_DOUBLE_WITHIN((UNITY_DOUBLE)(expected) * (UNITY_DOUBLE)UNITY_DOUBLE_PRECISION, (UNITY_DOUBLE)(expected), (UNITY_DOUBLE)(actual), (UNITY_LINE_TYPE)(line), (message)) -#define UNITY_TEST_ASSERT_NOT_EQUAL_DOUBLE(expected, actual, line, message) UNITY_TEST_ASSERT_DOUBLE_NOT_WITHIN((UNITY_DOUBLE)(expected) * (UNITY_DOUBLE)UNITY_DOUBLE_PRECISION, (UNITY_DOUBLE)(expected), (UNITY_DOUBLE)(actual), (UNITY_LINE_TYPE)(line), (message)) -#define UNITY_TEST_ASSERT_DOUBLE_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertWithinDoubleArray((UNITY_DOUBLE)(delta), (const UNITY_DOUBLE*)(expected), (const UNITY_DOUBLE*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements, line, message) UnityAssertWithinDoubleArray((UNITY_DOUBLE)0, (const UNITY_DOUBLE*)(expected), (const UNITY_DOUBLE*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE(expected, actual, num_elements, line, message) UnityAssertWithinDoubleArray((UNITY_DOUBLE)0, UnityDoubleToPtr(expected), (const UNITY_DOUBLE*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL) -#define UNITY_TEST_ASSERT_GREATER_THAN_DOUBLE(threshold, actual, line, message) UnityAssertGreaterOrLessDouble((UNITY_DOUBLE)(threshold), (UNITY_DOUBLE)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line)) -#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(threshold, actual, line, message) UnityAssertGreaterOrLessDouble((UNITY_DOUBLE)(threshold), (UNITY_DOUBLE)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line)) -#define UNITY_TEST_ASSERT_LESS_THAN_DOUBLE(threshold, actual, line, message) UnityAssertGreaterOrLessDouble((UNITY_DOUBLE)(threshold), (UNITY_DOUBLE)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line)) -#define UNITY_TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(threshold, actual, line, message) UnityAssertGreaterOrLessDouble((UNITY_DOUBLE)(threshold), (UNITY_DOUBLE)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line)) -#define UNITY_TEST_ASSERT_DOUBLE_IS_INF(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_INF) -#define UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NEG_INF) -#define UNITY_TEST_ASSERT_DOUBLE_IS_NAN(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NAN) -#define UNITY_TEST_ASSERT_DOUBLE_IS_DETERMINATE(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_DET) -#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_INF(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_INF) -#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_NEG_INF) -#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NAN(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_NAN) -#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_DET) -#endif - -/* End of UNITY_INTERNALS_H */ -#endif diff --git a/subprojects/unity/unity.wrap b/subprojects/unity/unity.wrap new file mode 100644 index 0000000000..440c66c6bc --- /dev/null +++ b/subprojects/unity/unity.wrap @@ -0,0 +1,3 @@ +[wrap-git] +url = https://github.com/ThrowTheSwitch/Unity.git +revision = v2.6.1 \ No newline at end of file diff --git a/subprojects/unity/unityConfig.cmake b/subprojects/unity/unityConfig.cmake deleted file mode 100644 index 55410ccc8d..0000000000 --- a/subprojects/unity/unityConfig.cmake +++ /dev/null @@ -1 +0,0 @@ -include(${CMAKE_CURRENT_LIST_DIR}/unityTargets.cmake) \ No newline at end of file From 8b7b141bc8c335fe51061059ac48fec428ab04ca Mon Sep 17 00:00:00 2001 From: Andrew Coffey Date: Fri, 6 Jun 2025 05:24:15 -0500 Subject: [PATCH 04/21] Deleted failed debian build --- .github/workflows/build-debian-packaged.yml | 189 -------------------- 1 file changed, 189 deletions(-) delete mode 100644 .github/workflows/build-debian-packaged.yml diff --git a/.github/workflows/build-debian-packaged.yml b/.github/workflows/build-debian-packaged.yml deleted file mode 100644 index 295886c1cf..0000000000 --- a/.github/workflows/build-debian-packaged.yml +++ /dev/null @@ -1,189 +0,0 @@ -# Tests pygame on more exotic architectures. This is not something that is -# actively supported, but source code support for this is nice to have. We -# don't do any releases from here. - -name: Debian Packaged - -# Run CI only on changes to main branch, or any PR to main. Do not run CI on -# any other branch. Also, skip any non-source changes from running on CI -on: - push: - branches: main - paths-ignore: - - 'docs/**' - - 'examples/**' - - '.gitignore' - - '*.rst' - - '*.md' - - '.github/workflows/*.yml' - # re-include current file to not be excluded - - '!.github/workflows/build-debian-packaged.yml' - - pull_request: - branches: main - paths-ignore: - - 'docs/**' - - 'examples/**' - - '.gitignore' - - '*.rst' - - '*.md' - - '.github/workflows/*.yml' - # re-include current file to not be excluded - - '!.github/workflows/build-debian-packaged.yml' - -concurrency: - group: ${{ github.workflow }}-${{ github.ref }}-debian-packaged - cancel-in-progress: true - -# this command is called in two places, so save it in an env first -env: - INSTALL_CMD: | - apt-get update --fix-missing - apt-get upgrade -y - apt-get install build-essential meson cython3 -y - apt-get install libsdl2-dev libsdl2-image-dev libsdl2-mixer-dev libsdl2-ttf-dev -y - apt-get install libfreetype6-dev libportmidi-dev fontconfig -y - apt-get install python3-dev python3-pip python3-wheel python3-sphinx python3-all dh-python python-all python-setuptools -y - apt-get update - apt-get install debhelper-compat python3-pyproject-metadata python3-tomli -y - wget http://http.us.debian.org/debian/pool/main/m/meson-python/python3-mesonpy_0.12.0-2_all.deb - dpkg -i python3-mesonpy_0.12.0-2_all.deb - apt install - pip3 install meson-python "sphinx-autoapi<=3.3.2" meson --break-system-packages - -jobs: - build-packaged: - name: Debian (Bookworm - 12) [${{ matrix.arch }}, ${{matrix.python}}] - runs-on: ubuntu-22.04 - - strategy: - fail-fast: false # if a particular matrix build fails, don't skip the rest - matrix: - # maybe more things could be added in here in the future (if needed) - include: - # - { arch: x86, base_image: '' } - # - { arch: x86-64, base_image: '', python: 3.9} - # - { arch: x86-64, base_image: '', python: 3.10} - # - { arch: x86-64, base_image: '', python: 3.11} - # - { arch: x86-64, base_image: '', python: 3.12} - - { arch: x86-64, base_image: '', python: 3.13} - # - { arch: s390x, base_image: '' } - # - { arch: ppc64le, base_image: '' } - # - { arch: armv6, base_image: '' } - # # a custom base_image is specified in the armv7 case. This is done because - # # the armv6 image is just raspbian in disguise. And the wheel built on armv7 - # # is going to be tested on armv6 - # - { arch: armv7, base_image: 'balenalib/raspberrypi3-debian:bookworm' } - - steps: - - uses: actions/checkout@v4.2.2 - - - uses: actions/setup-python@v5 - with: - python-version: ${{ matrix.python }} - - # - name: Build sources and run tests - # uses: uraimo/run-on-arch-action@v3.0.1 - # id: build - # with: - # arch: ${{ matrix.base_image && 'none' || matrix.arch }} - # distro: ${{ matrix.base_image && 'none' || 'bookworm' }} - # base_image: ${{ matrix.base_image }} - - # # Not required, but speeds up builds - # githubToken: ${{ github.token }} - - # # Create an artifacts directory - # setup: mkdir -p ~/artifacts - - # # Mount the artifacts directory as /artifacts in the container - # dockerRunArgs: --volume ~/artifacts:/artifacts - - # # The shell to run commands with in the container - # shell: /bin/sh - - # # Install some dependencies in the container. This speeds up builds if - # # you are also using githubToken. Any dependencies installed here will - # # be part of the container image that gets cached, so subsequent - # # builds don't have to re-install them. The image layer is cached - # # publicly in your project's package repository, so it is vital that - # # no secrets are present in the container state or logs. - # install: ${{ env.INSTALL_CMD }} - - # # Build a wheel, install it for running unit tests. - # # pip does not know that ninja is installed, and tries to install it again. - # # so pass --ignore-dep ninja explicitly - # run: | - # echo "\nBuilding and installing pygame wheel\n" - # PIP_BREAK_SYSTEM_PACKAGES=1 python3 dev.py --ignore-dep ninja build --wheel /artifacts --lax - # echo "\nRunning tests\n" - # export SDL_VIDEODRIVER=dummy - # export SDL_AUDIODRIVER=disk - # python3 -m pygame.tests -v --exclude opengl,music,timing --time_out 300 - - - name: Build Packaged Deb - id: build - run: | - ${{env.INSTALL_CMD}} - apt install debmake -y - mkdir ../pygame-ce-2.5.5 - mv * ../pygame-ce-2.5.5 - mv ../pygame-ce-2.5.5 . - tar czf pygame-ce-2.5.5.tar.gz pygame-ce-2.5.5 - mv pygame-ce-2.5.5.tar.gz pygame-ce_2.5.5.orig.tar.gz - cd pygame-ce-2.5.5 - debmake -b:python3 - perl -0000 -pi -e '$INDENT=" "; s{(Build-Depends: debhelper-compat.*python3-all)}{\1,\n${INDENT}cython3,\n${INDENT}libfreetype6-dev,\n${INDENT}libportmidi-dev,\n${INDENT}libsdl2-dev,\n${INDENT}libsdl2-image-dev,\n${INDENT}libsdl2-mixer-dev,\n${INDENT}libsdl2-ttf-dev}s' debian/control - perl -0000 -pi.bak -e 's{Standards-Version}{\nStandards-Version}s' debian/control - cat debian/control - dpkg-source -b . - dpkg-buildpackage - - - - name: debug - if: (failure() && steps.build.outcome == 'failure') - run: cat pygame-ce-2.5.5/debian/control - - # Upload the generated files under github actions assets section - - name: Upload dist - uses: actions/upload-artifact@v4 - with: - name: debian-packaged-${{ matrix.arch }}-dist - path: "*.deb" - - # # test wheels built on armv7 on armv6. Why? - # # because piwheels expects the same armv7 wheel to work on both armv7 and armv6 - # test-armv7-on-armv6: - # needs: build-packaged - # name: Debian (Bookworm - 12) [build - armv7, test - armv6] - # runs-on: ubuntu-22.04 - # steps: - # - name: Download all multiarch artifacts - # uses: actions/download-artifact@v4 - # with: - # name: pygame-multiarch-armv7-dist - # path: ~/artifacts - - # - name: Rename arm wheel in artifacts - # run: | - # cd ~/artifacts - # for f in *; do - # mv "$f" "${f//armv7l/armv6l}" - # done - - # - name: Test armv7 wheel on armv6 - # uses: uraimo/run-on-arch-action@v3.0.1 - # with: - # arch: armv6 - # distro: bookworm - # githubToken: ${{ github.token }} - # dockerRunArgs: --volume ~/artifacts:/artifacts_new - # shell: /bin/sh - # install: ${{ env.INSTALL_CMD }} - # run: | - # echo "\nInstalling wheel\n" - # pip3 install --no-index --pre --break-system-packages --find-links /artifacts_new pygame-ce - # echo "\nRunning tests\n" - # export SDL_VIDEODRIVER=dummy - # export SDL_AUDIODRIVER=disk - # python3 -m pygame.tests -v --exclude opengl,music,timing --time_out 300 From 66d8ca3afeb8abf120fad4bb17cf9824f2f237c6 Mon Sep 17 00:00:00 2001 From: Andrew Coffey Date: Fri, 6 Jun 2025 23:42:15 -0500 Subject: [PATCH 05/21] Messed with ctest build to try to get it to work on CI... failed --- .../workflows/build-ubuntu-debug-python.yml | 31 +++++++++++++++++-- .gitignore | 3 ++ ctest/meson.build | 25 ++++++++++----- dev.py | 6 ++-- subprojects/{unity => }/unity.wrap | 0 5 files changed, 52 insertions(+), 13 deletions(-) rename subprojects/{unity => }/unity.wrap (100%) diff --git a/.github/workflows/build-ubuntu-debug-python.yml b/.github/workflows/build-ubuntu-debug-python.yml index b1c24766e5..bcee4cff0b 100644 --- a/.github/workflows/build-ubuntu-debug-python.yml +++ b/.github/workflows/build-ubuntu-debug-python.yml @@ -50,7 +50,7 @@ jobs: os: [ ubuntu-24.04 ] # check our min python (minor) version and our max python (minor) version python: [ - 3.9.21, + # 3.9.21, 3.13.1 ] @@ -69,7 +69,7 @@ jobs: # https://github.com/orgs/community/discussions/47863 run: | sudo apt-get update --fix-missing - + sudo apt-get install lcov -y sudo apt-get install libsdl2-dev libsdl2-image-dev libsdl2-mixer-dev libsdl2-ttf-dev libfreetype6-dev libportmidi-dev -y - name: Install pyenv @@ -94,11 +94,12 @@ jobs: if: steps.cache-python.outputs.cache-hit != 'true' run: pyenv install ${{ matrix.python }} --debug -v + # python dev.py build --coverage --lax --ctest - name: Build pygame-ce id: build-pygame-ce run: | pyenv global ${{ matrix.python }}-debug - python dev.py build --lax + python dev.py build --wheel --lax --coverage --ctest - name: Run tests env: @@ -107,3 +108,27 @@ jobs: run: | pyenv global ${{ matrix.python }}-debug python -m pygame.tests -v --exclude opengl,music,timing --time_out 300 + + - name: Generate coverage + id: gen-coverage + # want to continue regardless of whether a test failed or not as long as the job wasn't cancelled + if: ${{ steps.build.conclusion == 'success' && !cancelled() }} + run: | + lcov --capture --directory . --output-file ./coverage.info + genhtml ./coverage.info --output-directory ./out + + # We upload the generated files under github actions assets + - name: Upload coverage html + # want to continue only if the coverage generation was successful + if: ${{ steps.gen-coverage.conclusion == 'success' && !cancelled() }} + uses: actions/upload-artifact@v4 + with: + name: pygame-wheels-coverage + path: ./out + + - name: Upload ctest log + if: !cancelled() + uses: actions/upload-artifact@v4 + with: + name: ctest_suite_log + path: ./ctest.log diff --git a/.gitignore b/.gitignore index 32862dc25a..dee3dbe63b 100644 --- a/.gitignore +++ b/.gitignore @@ -35,6 +35,9 @@ # Ruff .ruff_cache +# Meson subprojects +# subprojects/**/* + # Other envdev* .virtualenv* diff --git a/ctest/meson.build b/ctest/meson.build index 6608d2d45d..79a1dbeb89 100644 --- a/ctest/meson.build +++ b/ctest/meson.build @@ -2,21 +2,32 @@ unity_subproject = subproject('unity') unity_dependency = unity_subproject.get_variable('unity_dep') test_sources = files( - ['../src_c/base.c', - 'test_base.c'] + '../src_c/base.c', + 'test_base.c' ) inc = include_directories('../src_c') -test = executable('run_ctests', +py_version = py.language_version().split('.') +py_major = py_version[0] +py_minor = py_version[1] +libpython_name = 'python' + py_major + '.' + py_minor + +libpython = cc.find_library(libpython_name, required: false) + +python_dep = dependency(libpython_name, required: false) +if not python_dep.found() + python_dep = declare_dependency( + dependencies: libpython + ) +endif + +executable('run_ctests', sources: [ test_sources, ], include_directories: [inc], - dependencies: [unity_dependency, py_dep, sdl_dep], + dependencies: [unity_dependency, sdl_dep, python_dep, py_dep], install: true, install_dir: pg_dir ) - -# test('test', test, -# should_fail: false) diff --git a/dev.py b/dev.py index 936adceb7f..482b0bf91e 100644 --- a/dev.py +++ b/dev.py @@ -211,9 +211,9 @@ def cmd_build(self): sdl3 = self.args.get("sdl3", False) coverage = self.args.get("coverage", False) ctest = self.args.get("ctest", False) - if wheel_dir and coverage: - pprint("Cannot pass --wheel and --coverage together", Colors.RED) - sys.exit(1) + # if wheel_dir and coverage: + # pprint("Cannot pass --wheel and --coverage together", Colors.RED) + # sys.exit(1) build_suffix = "" if debug: diff --git a/subprojects/unity/unity.wrap b/subprojects/unity.wrap similarity index 100% rename from subprojects/unity/unity.wrap rename to subprojects/unity.wrap From d80791210d0dbab4f45346fc8d777108c6d72f79 Mon Sep 17 00:00:00 2001 From: Andrew Coffey Date: Fri, 6 Jun 2025 23:46:29 -0500 Subject: [PATCH 06/21] CI updates --- .github/workflows/build-ubuntu-coverage.yml | 97 ------------------- .github/workflows/build-ubuntu-ctest.yml | 87 ----------------- ...ebug-python.yml => build-ubuntu-debug.yml} | 19 ++-- 3 files changed, 13 insertions(+), 190 deletions(-) delete mode 100644 .github/workflows/build-ubuntu-coverage.yml delete mode 100644 .github/workflows/build-ubuntu-ctest.yml rename .github/workflows/{build-ubuntu-debug-python.yml => build-ubuntu-debug.yml} (89%) diff --git a/.github/workflows/build-ubuntu-coverage.yml b/.github/workflows/build-ubuntu-coverage.yml deleted file mode 100644 index 680481ba82..0000000000 --- a/.github/workflows/build-ubuntu-coverage.yml +++ /dev/null @@ -1,97 +0,0 @@ -# This workflow generates C code coverage information from the unit test -# suite. Note that for intrinsics, it only runs what gets compiled -# and would naturally run. It also is limited to what can run in -# a CI environment -# IMPORTANT: binaries are not to be uploaded from this workflow! - -name: Ubuntu coverage - -# Run CI only on changes to main branch, or any PR to main. -# Do not run CI on any other branch. Also, skip any non-source changes -# from running on CI -on: - push: - branches: main - paths-ignore: - - 'docs/**' - - 'examples/**' - - '.gitignore' - - '*.rst' - - '*.md' - - '.github/workflows/*.yml' - # gcov/lcov only gets C coverage - - 'src_py/**' - # re-include current file to not be excluded - - '!.github/workflows/build-ubuntu-coverage.yml' - - pull_request: - branches: main - paths-ignore: - - 'docs/**' - - 'examples/**' - - '.gitignore' - - '*.rst' - - '*.md' - - '.github/workflows/*.yml' - # gcov/lcov only gets C coverage - - 'src_py/**' - # re-include current file to not be excluded - - '!.github/workflows/build-ubuntu-coverage.yml' - -concurrency: - group: ${{ github.workflow }}-${{ github.ref }}-ubuntu-coverage - cancel-in-progress: true - -jobs: - gen_coverage: - runs-on: ${{ matrix.os }} - strategy: - fail-fast: false # if a particular matrix build fails, don't skip the rest - matrix: - os: [ubuntu-24.04] - - env: - # Pip now forces us to either make a venv or set this flag, so we will do - # this - PIP_BREAK_SYSTEM_PACKAGES: 1 - # We are using dependencies installed from apt - PG_DEPS_FROM_SYSTEM: 1 - - steps: - - uses: actions/checkout@v4.2.2 - - - name: Install deps - # https://github.com/actions/runner-images/issues/7192 - # https://github.com/orgs/community/discussions/47863 - run: | - sudo apt-get update --fix-missing - sudo apt-get install lcov -y - sudo apt-get install libsdl2-dev libsdl2-image-dev libsdl2-mixer-dev libsdl2-ttf-dev libfreetype6-dev libportmidi-dev python3-dev -y - - - name: Build with coverage hooks and install - id: build - run: | - python3 dev.py build --coverage - - - name: Run tests - env: - SDL_VIDEODRIVER: "dummy" - SDL_AUDIODRIVER: "disk" - run: python3 -m pygame.tests -v --exclude opengl,music,timing --time_out 300 - - - name: Generate coverage - id: gen-coverage - # want to continue regardless of whether a test failed or not as long as the job wasn't cancelled - if: ${{ steps.build.conclusion == 'success' && !cancelled() }} - run: | - lcov --capture --directory . --output-file ./coverage.info - genhtml ./coverage.info --output-directory ./out - - # We upload the generated files under github actions assets - - name: Upload coverage html - # want to continue only if the coverage generation was successful - if: ${{ steps.gen-coverage.conclusion == 'success' && !cancelled() }} - uses: actions/upload-artifact@v4 - with: - name: pygame-wheels-coverage - path: ./out diff --git a/.github/workflows/build-ubuntu-ctest.yml b/.github/workflows/build-ubuntu-ctest.yml deleted file mode 100644 index 0160df72c8..0000000000 --- a/.github/workflows/build-ubuntu-ctest.yml +++ /dev/null @@ -1,87 +0,0 @@ -# This workflow generates C code tests -# Note that for intrinsics, it only runs what gets compiled -# and would naturally run. It also is limited to what can run in -# a CI environment -# IMPORTANT: binaries are not to be uploaded from this workflow! - -name: Ubuntu ctest - -# Run CI only on changes to main branch, or any PR to main. -# Do not run CI on any other branch. Also, skip any non-source changes -# from running on CI -on: - push: - branches: main - paths-ignore: - - 'docs/**' - - 'examples/**' - - '.gitignore' - - '*.rst' - - '*.md' - - '.github/workflows/*.yml' - # only care about c code that changes - - 'src_py/**' - # re-include current file to not be excluded - - '!.github/workflows/build-ubuntu-ctest.yml' - - pull_request: - branches: main - paths-ignore: - - 'docs/**' - - 'examples/**' - - '.gitignore' - - '*.rst' - - '*.md' - - '.github/workflows/*.yml' - # only care about c code that changes - - 'src_py/**' - # re-include current file to not be excluded - - '!.github/workflows/build-ubuntu-ctest.yml' - -concurrency: - group: ${{ github.workflow }}-${{ github.ref }}-ubuntu-ctest - cancel-in-progress: true - -jobs: - gen_ctest: - runs-on: ${{ matrix.os }} - strategy: - fail-fast: false # if a particular matrix build fails, don't skip the rest - matrix: - os: [ubuntu-24.04] - - env: - # Pip now forces us to either make a venv or set this flag, so we will do - # this - PIP_BREAK_SYSTEM_PACKAGES: 1 - # We are using dependencies installed from apt - PG_DEPS_FROM_SYSTEM: 1 - - steps: - - uses: actions/checkout@v4.2.2 - - - name: Install deps - # https://github.com/actions/runner-images/issues/7192 - # https://github.com/orgs/community/discussions/47863 - run: | - sudo apt-get update --fix-missing - sudo apt-get install libsdl2-dev libsdl2-image-dev libsdl2-mixer-dev libsdl2-ttf-dev libfreetype6-dev libportmidi-dev python3-dev -y - - - name: Build with the ctest suite - id: build - run: | - python3 -m pip install . -Csetup-args="-Dctest=true" --break-system-packages - - - name: Run tests - env: - SDL_VIDEODRIVER: "dummy" - SDL_AUDIODRIVER: "disk" - run: python3 -m pygame.tests -v --exclude opengl,music,timing --time_out 300 - - # We upload the generated files under github actions assets - - name: Upload ctest log - if: !cancelled() - uses: actions/upload-artifact@v4 - with: - name: ctest_suite_log - path: ctest.log diff --git a/.github/workflows/build-ubuntu-debug-python.yml b/.github/workflows/build-ubuntu-debug.yml similarity index 89% rename from .github/workflows/build-ubuntu-debug-python.yml rename to .github/workflows/build-ubuntu-debug.yml index bcee4cff0b..703c4ffc49 100644 --- a/.github/workflows/build-ubuntu-debug-python.yml +++ b/.github/workflows/build-ubuntu-debug.yml @@ -1,10 +1,17 @@ # This workflow runs a build with a python version that has debug symbols +# Also generates coverage information from unit tests +# +# Note that for intrinsics, it only runs what gets compiled +# -# and would naturally run. It also is limited to what can run in +# -# a CI environment +# -# IMPORTANT: binaries are not to be uploaded from this workflow! +# # Update this workflow when our min/max python minor versions update # This workflow is necessary to ensure that we can build and run with # a debug python build without too much worrying about SIGABRT being thrown # IMPORTANT: binaries are not to be uploaded from this workflow! -name: Ubuntu debug python +name: Ubuntu debug defaults: run: shell: bash -leo pipefail {0} @@ -23,7 +30,7 @@ on: - '*.md' - '.github/workflows/*.yml' # re-include current file to not be excluded - - '!.github/workflows/build-ubuntu-debug-python.yml' + - '!.github/workflows/build-ubuntu-debug.yml' pull_request: branches: main @@ -35,14 +42,14 @@ on: - '*.md' - '.github/workflows/*.yml' # re-include current file to not be excluded - - '!.github/workflows/build-ubuntu-debug-python.yml' + - '!.github/workflows/build-ubuntu-debug.yml' concurrency: - group: ${{ github.workflow }}-${{ github.ref }}-ubuntu-debug-python + group: ${{ github.workflow }}-${{ github.ref }}-ubuntu-debug cancel-in-progress: true jobs: - debug_python: + debug: runs-on: ${{ matrix.os }} strategy: fail-fast: false # if a particular matrix build fails, don't skip the rest @@ -50,7 +57,7 @@ jobs: os: [ ubuntu-24.04 ] # check our min python (minor) version and our max python (minor) version python: [ - # 3.9.21, + 3.9.21, 3.13.1 ] From fae720304bf83023df70de6187696f34b665899b Mon Sep 17 00:00:00 2001 From: Andrew Coffey Date: Fri, 6 Jun 2025 23:51:06 -0500 Subject: [PATCH 07/21] .gitignore subprojects directory --- .gitignore | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index dee3dbe63b..da98211204 100644 --- a/.gitignore +++ b/.gitignore @@ -36,7 +36,8 @@ .ruff_cache # Meson subprojects -# subprojects/**/* +subprojects/* +!subprojects/*.wrap # Other envdev* From 89988c96616df8a343e2c4fba049cadaae16a157 Mon Sep 17 00:00:00 2001 From: Andrew Coffey Date: Sat, 7 Jun 2025 09:30:39 -0500 Subject: [PATCH 08/21] ctest is now python package --- ctest/base_ctest.c | 136 ++++++++++++++++++++++++++++++++++++++++++++ ctest/meson.build | 36 +++--------- ctest/test_base.c | 82 -------------------------- ctest/test_common.h | 23 ++++++++ test/ctest_test.py | 41 +++---------- 5 files changed, 175 insertions(+), 143 deletions(-) create mode 100644 ctest/base_ctest.c delete mode 100644 ctest/test_base.c create mode 100644 ctest/test_common.h diff --git a/ctest/base_ctest.c b/ctest/base_ctest.c new file mode 100644 index 0000000000..5df36e7e2c --- /dev/null +++ b/ctest/base_ctest.c @@ -0,0 +1,136 @@ +#include + +#include "base.h" +#include "test_common.h" + +static PyObject *base_module; + +/* setUp and tearDown must be nonstatic void(void) */ +void setUp(void) {} + +void tearDown(void) {} + +/** + * @brief Tests _pg_is_int_tuple when passed a tuple of ints + */ +static PyObject* +test__pg_is_int_tuple_nominal(PyObject *self, PyObject *_null) +{ + PyObject *arg1 = Py_BuildValue("(iii)", 1, 2, 3); + PyObject *arg2 = Py_BuildValue("(iii)", -1, -2, -3); + PyObject *arg3 = Py_BuildValue("(iii)", 1, -2, -3); + + TEST_ASSERT_EQUAL(1, _pg_is_int_tuple(arg1)); + TEST_ASSERT_EQUAL(1, _pg_is_int_tuple(arg2)); + TEST_ASSERT_EQUAL(1, _pg_is_int_tuple(arg3)); + + Py_RETURN_NONE; +} + +/** + * @brief Tests _pg_is_int_tuple when passed a tuple of non-numeric values + */ +static PyObject* +test__pg_is_int_tuple_failureModes(PyObject *self, PyObject *_null) +{ + PyObject *arg1 = + Py_BuildValue("(sss)", (char *)"Larry", (char *)"Moe", (char *)"Curly"); + PyObject *arg2 = Py_BuildValue("(sss)", (char *)NULL, (char *)NULL, + (char *)NULL); // tuple of None's + PyObject *arg3 = Py_BuildValue("(OOO)", arg1, arg2, arg1); + + TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg1)); + TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg2)); + TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg3)); + + Py_RETURN_NONE; +} + +/** + * @brief Tests _pg_is_int_tuple when passed a tuple of floats + */ +static PyObject* +test__pg_is_int_tuple_floats(PyObject *self, PyObject *_null) +{ + PyObject *arg1 = Py_BuildValue("(ddd)", 1.0, 2.0, 3.0); + PyObject *arg2 = Py_BuildValue("(ddd)", -1.1, -2.2, -3.3); + PyObject *arg3 = Py_BuildValue("(ddd)", 1.0, -2.0, -3.1); + + TEST_ASSERT_EQUAL(1, _pg_is_int_tuple(arg1)); + TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg2)); + TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg3)); + + Py_RETURN_NONE; +} + +/*=======Test Reset Option=====*/ +/* This must be void(void) */ +void resetTest(void) +{ + tearDown(); + setUp(); +} + +/*=======Exposed Test Reset Option=====*/ +static PyObject* +reset_test(PyObject *self, PyObject *_null) +{ + resetTest(); + + Py_RETURN_NONE; +} + +/*=======Run The Tests=======*/ +static PyObject* +run_tests(PyObject *self, PyObject *_null) +{ + UnityBegin("base_ctest.c"); + RUN_TEST_PG_INTERNAL(test__pg_is_int_tuple_nominal, 15, self, _null); + RUN_TEST_PG_INTERNAL(test__pg_is_int_tuple_failureModes, 29, self, _null); + RUN_TEST_PG_INTERNAL(test__pg_is_int_tuple_floats, 46, self, _null); + + return PyLong_FromLong(UnityEnd()); +} + +static PyMethodDef base_test_methods[] = { + {"test__pg_is_int_tuple_nominal", (PyCFunction)test__pg_is_int_tuple_nominal, METH_NOARGS, "Tests _pg_is_int_tuple when passed a tuple of ints"}, + {"test__pg_is_int_tuple_failureModes", (PyCFunction)test__pg_is_int_tuple_failureModes, METH_NOARGS, "Tests _pg_is_int_tuple when passed a tuple of non-numeric values"}, + {"test__pg_is_int_tuple_floats", (PyCFunction)test__pg_is_int_tuple_floats, METH_NOARGS, "Tests _pg_is_int_tuple when passed a tuple of floats"}, + {"reset_test", (PyCFunction)reset_test, METH_NOARGS, "Resets the test suite between tests, run_tests automatically calls this after each test case it calls"}, + {"run_tests", (PyCFunction)run_tests, METH_NOARGS, "Runs all the tests in this test wuite"}, + {NULL, NULL, 0, NULL}}; + +MODINIT_DEFINE(base_ctest) +{ + PyObject* module; + + static struct PyModuleDef _module = {PyModuleDef_HEAD_INIT, + "base_ctest", + "C unit tests for the pygame.base internal implementation", + -1, + base_test_methods, + NULL, + NULL, + NULL, + NULL}; + + /* create the module */ + module = PyModule_Create(&_module); + if (!module) { + return NULL; + } + + return module; +} + +// #undef main +// /*=======MAIN=====*/ +// int main(void) { +// Py_Initialize(); +// UnityBegin("test_base.c"); +// RUN_TEST(test__pg_is_int_tuple_nominal, 17); +// RUN_TEST(test__pg_is_int_tuple_failureModes, 31); +// RUN_TEST(test__pg_is_int_tuple_floats, 45); + +// return (UnityEnd()); +// } diff --git a/ctest/meson.build b/ctest/meson.build index 79a1dbeb89..aa961e79c6 100644 --- a/ctest/meson.build +++ b/ctest/meson.build @@ -1,33 +1,13 @@ unity_subproject = subproject('unity') unity_dependency = unity_subproject.get_variable('unity_dep') -test_sources = files( - '../src_c/base.c', - 'test_base.c' -) - -inc = include_directories('../src_c') - -py_version = py.language_version().split('.') -py_major = py_version[0] -py_minor = py_version[1] -libpython_name = 'python' + py_major + '.' + py_minor - -libpython = cc.find_library(libpython_name, required: false) - -python_dep = dependency(libpython_name, required: false) -if not python_dep.found() - python_dep = declare_dependency( - dependencies: libpython - ) -endif - -executable('run_ctests', - sources: [ - test_sources, - ], - include_directories: [inc], - dependencies: [unity_dependency, sdl_dep, python_dep, py_dep], +base_ctest = py.extension_module( + 'base_ctest', + 'base_ctest.c', + c_args: warnings_error, + dependencies: [pg_base_deps, unity_dependency], + sources: ['../src_c/base.c'], install: true, - install_dir: pg_dir + subdir: pg, + include_directories: ['../src_c'] ) diff --git a/ctest/test_base.c b/ctest/test_base.c deleted file mode 100644 index abe441681b..0000000000 --- a/ctest/test_base.c +++ /dev/null @@ -1,82 +0,0 @@ -#include "base.h" -#include "unity.h" - -PyObject *base_module; - -void setUp(void) {} - -void tearDown(void) {} - -/** - * @brief Tests _pg_is_int_tuple when passed a tuple of ints - */ -void test__pg_is_int_tuple_nominal(void) { - PyObject *arg1 = Py_BuildValue("(iii)", 1, 2, 3); - PyObject *arg2 = Py_BuildValue("(iii)", -1, -2, -3); - PyObject *arg3 = Py_BuildValue("(iii)", 1, -2, -3); - - TEST_ASSERT_EQUAL(1, _pg_is_int_tuple(arg1)); - TEST_ASSERT_EQUAL(1, _pg_is_int_tuple(arg2)); - TEST_ASSERT_EQUAL(1, _pg_is_int_tuple(arg3)); -} - -/** - * @brief Tests _pg_is_int_tuple when passed a tuple of non-numeric values - */ -void test__pg_is_int_tuple_failureModes(void) { - PyObject *arg1 = - Py_BuildValue("(sss)", (char *)"Larry", (char *)"Moe", (char *)"Curly"); - PyObject *arg2 = Py_BuildValue("(sss)", (char *)NULL, (char *)NULL, - (char *)NULL); // tuple of None's - PyObject *arg3 = Py_BuildValue("(OOO)", arg1, arg2, arg1); - - TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg1)); - TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg2)); - TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg3)); -} - -/** - * @brief Tests _pg_is_int_tuple when passed a tuple of floats - */ -void test__pg_is_int_tuple_floats(void) { - PyObject *arg1 = Py_BuildValue("(ddd)", 1.0, 2.0, 3.0); - PyObject *arg2 = Py_BuildValue("(ddd)", -1.1, -2.2, -3.3); - PyObject *arg3 = Py_BuildValue("(ddd)", 1.0, -2.0, -3.1); - - TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg1)); - TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg2)); - TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg3)); -} - -#define RUN_TEST(TestFunc, TestLineNum) \ - { \ - Unity.CurrentTestName = #TestFunc; \ - Unity.CurrentTestLineNumber = TestLineNum; \ - Unity.NumberOfTests++; \ - if (TEST_PROTECT()) { \ - setUp(); \ - TestFunc(); \ - } \ - if (TEST_PROTECT()) { \ - tearDown(); \ - } \ - UnityConcludeTest(); \ - } - -/*=======Test Reset Option=====*/ -void resetTest(void) { - tearDown(); - setUp(); -} - -#undef main -/*=======MAIN=====*/ -int main(void) { - Py_Initialize(); - UnityBegin("test_base.c"); - RUN_TEST(test__pg_is_int_tuple_nominal, 17); - RUN_TEST(test__pg_is_int_tuple_failureModes, 31); - RUN_TEST(test__pg_is_int_tuple_floats, 45); - - return (UnityEnd()); -} diff --git a/ctest/test_common.h b/ctest/test_common.h new file mode 100644 index 0000000000..5cc86a5d20 --- /dev/null +++ b/ctest/test_common.h @@ -0,0 +1,23 @@ +#include "unity.h" + +#ifndef TEST_COMMON_H +#define TEST_COMMON_H + +#define RUN_TEST_PG_INTERNAL(TestFunc, TestLineNum, self_arg, null_arg) \ + { \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + if (TEST_PROTECT()) \ + { \ + setUp(); \ + TestFunc(self_arg, null_arg); \ + } \ + if (TEST_PROTECT()) \ + { \ + tearDown(); \ + } \ + UnityConcludeTest(); \ + } + +#endif // #ifndef TEST_COMMON_H diff --git a/test/ctest_test.py b/test/ctest_test.py index a143d138ce..a90465816f 100644 --- a/test/ctest_test.py +++ b/test/ctest_test.py @@ -1,40 +1,15 @@ -import io -import os -import re -import subprocess import unittest +base_ctest = None +try: + import pygame.base_ctest as base_ctest +except ModuleNotFoundError: + pass class Ctest(unittest.TestCase): - def test_run_ctests(self): - filename_regex = re.compile(".*run_ctests.*") - - test_dir = os.path.dirname(os.path.abspath(__file__)) - pg_dir = os.path.join(test_dir, "..") - - test_executable_exists = False - test_filename = "" - for filename in os.listdir(pg_dir): - if re.match(filename_regex, filename): - test_filename = filename - test_executable_exists = True - break - - if test_executable_exists: - cwd = os.getcwd() - os.chdir(pg_dir) - - with open(f"{cwd}/ctest.log", 'w') as ctest_log: - test_result = subprocess.run( - [test_filename], stdout=ctest_log, stderr=subprocess.STDOUT - ) - - os.chdir(cwd) - - self.assertEqual(test_result.returncode, 0) - - else: - unittest.skip("Test Executable Not Available") + @unittest.skipIf(base_ctest is None, "base_ctest not built") + def test_run_base_ctests(self): + self.assertEqual(base_ctest.run_tests(), 0) if __name__ == "__main__": From 66801ec3391639429c154dd1b8f45bf7919383c2 Mon Sep 17 00:00:00 2001 From: Andrew Coffey Date: Sat, 7 Jun 2025 09:44:09 -0500 Subject: [PATCH 09/21] Finished proper ctest support in ubuntu-checks action --- .github/workflows/run-ubuntu-checks.yml | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/.github/workflows/run-ubuntu-checks.yml b/.github/workflows/run-ubuntu-checks.yml index 193d2b2989..dddf85164f 100644 --- a/.github/workflows/run-ubuntu-checks.yml +++ b/.github/workflows/run-ubuntu-checks.yml @@ -97,12 +97,11 @@ jobs: if: steps.cache-python.outputs.cache-hit != 'true' run: pyenv install ${{ matrix.python }} --debug -v - # python dev.py build --coverage --lax --ctest - name: Build pygame-ce id: build-pygame-ce run: | pyenv global ${{ matrix.python }}-debug - python dev.py build --lax --coverage + python dev.py build --lax --coverage --ctest - name: Run tests env: @@ -126,14 +125,14 @@ jobs: if: ${{ steps.gen-coverage.conclusion == 'success' && !cancelled() }} uses: actions/upload-artifact@v4 with: - name: pygame-wheels-coverage + name: pygame-wheels-coverage-{ matrix.os }-{ matrix.python } path: ./out - name: Upload ctest log if: !cancelled() uses: actions/upload-artifact@v4 with: - name: ctest_suite_log + name: ctest_suite_log-{ matrix.os }-{ matrix.python } path: ./ctest.log # Run cppcheck static analysis on src_c changes From 5b9e4849a043a9dc7ab4cdc97a14e0e4f9548c1e Mon Sep 17 00:00:00 2001 From: Andrew Coffey Date: Sat, 7 Jun 2025 09:47:16 -0500 Subject: [PATCH 10/21] Fixed ctest log upload step --- .github/workflows/run-ubuntu-checks.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/run-ubuntu-checks.yml b/.github/workflows/run-ubuntu-checks.yml index dddf85164f..13d23ec574 100644 --- a/.github/workflows/run-ubuntu-checks.yml +++ b/.github/workflows/run-ubuntu-checks.yml @@ -129,7 +129,7 @@ jobs: path: ./out - name: Upload ctest log - if: !cancelled() + if: ${{ steps.build-pygame-ce.conclusion == 'success' && !cancelled() }} uses: actions/upload-artifact@v4 with: name: ctest_suite_log-{ matrix.os }-{ matrix.python } From cdf2baf75a172c1bf332674c2f8199040b9d992c Mon Sep 17 00:00:00 2001 From: Andrew Coffey Date: Sat, 7 Jun 2025 09:47:28 -0500 Subject: [PATCH 11/21] Formatting --- ctest/base_ctest.c | 163 ++++++++++++++++++++++---------------------- ctest/test_common.h | 30 ++++---- test/ctest_test.py | 1 + 3 files changed, 96 insertions(+), 98 deletions(-) diff --git a/ctest/base_ctest.c b/ctest/base_ctest.c index 5df36e7e2c..529f5ddcc4 100644 --- a/ctest/base_ctest.c +++ b/ctest/base_ctest.c @@ -13,114 +13,113 @@ void tearDown(void) {} /** * @brief Tests _pg_is_int_tuple when passed a tuple of ints */ -static PyObject* -test__pg_is_int_tuple_nominal(PyObject *self, PyObject *_null) -{ - PyObject *arg1 = Py_BuildValue("(iii)", 1, 2, 3); - PyObject *arg2 = Py_BuildValue("(iii)", -1, -2, -3); - PyObject *arg3 = Py_BuildValue("(iii)", 1, -2, -3); - - TEST_ASSERT_EQUAL(1, _pg_is_int_tuple(arg1)); - TEST_ASSERT_EQUAL(1, _pg_is_int_tuple(arg2)); - TEST_ASSERT_EQUAL(1, _pg_is_int_tuple(arg3)); - - Py_RETURN_NONE; +static PyObject *test__pg_is_int_tuple_nominal(PyObject *self, + PyObject *_null) { + PyObject *arg1 = Py_BuildValue("(iii)", 1, 2, 3); + PyObject *arg2 = Py_BuildValue("(iii)", -1, -2, -3); + PyObject *arg3 = Py_BuildValue("(iii)", 1, -2, -3); + + TEST_ASSERT_EQUAL(1, _pg_is_int_tuple(arg1)); + TEST_ASSERT_EQUAL(1, _pg_is_int_tuple(arg2)); + TEST_ASSERT_EQUAL(1, _pg_is_int_tuple(arg3)); + + Py_RETURN_NONE; } /** * @brief Tests _pg_is_int_tuple when passed a tuple of non-numeric values */ -static PyObject* -test__pg_is_int_tuple_failureModes(PyObject *self, PyObject *_null) -{ - PyObject *arg1 = - Py_BuildValue("(sss)", (char *)"Larry", (char *)"Moe", (char *)"Curly"); - PyObject *arg2 = Py_BuildValue("(sss)", (char *)NULL, (char *)NULL, - (char *)NULL); // tuple of None's - PyObject *arg3 = Py_BuildValue("(OOO)", arg1, arg2, arg1); - - TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg1)); - TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg2)); - TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg3)); - - Py_RETURN_NONE; +static PyObject *test__pg_is_int_tuple_failureModes(PyObject *self, + PyObject *_null) { + PyObject *arg1 = + Py_BuildValue("(sss)", (char *)"Larry", (char *)"Moe", (char *)"Curly"); + PyObject *arg2 = Py_BuildValue("(sss)", (char *)NULL, (char *)NULL, + (char *)NULL); // tuple of None's + PyObject *arg3 = Py_BuildValue("(OOO)", arg1, arg2, arg1); + + TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg1)); + TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg2)); + TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg3)); + + Py_RETURN_NONE; } /** * @brief Tests _pg_is_int_tuple when passed a tuple of floats */ -static PyObject* -test__pg_is_int_tuple_floats(PyObject *self, PyObject *_null) -{ - PyObject *arg1 = Py_BuildValue("(ddd)", 1.0, 2.0, 3.0); - PyObject *arg2 = Py_BuildValue("(ddd)", -1.1, -2.2, -3.3); - PyObject *arg3 = Py_BuildValue("(ddd)", 1.0, -2.0, -3.1); - - TEST_ASSERT_EQUAL(1, _pg_is_int_tuple(arg1)); - TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg2)); - TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg3)); - - Py_RETURN_NONE; +static PyObject *test__pg_is_int_tuple_floats(PyObject *self, PyObject *_null) { + PyObject *arg1 = Py_BuildValue("(ddd)", 1.0, 2.0, 3.0); + PyObject *arg2 = Py_BuildValue("(ddd)", -1.1, -2.2, -3.3); + PyObject *arg3 = Py_BuildValue("(ddd)", 1.0, -2.0, -3.1); + + TEST_ASSERT_EQUAL(1, _pg_is_int_tuple(arg1)); + TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg2)); + TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg3)); + + Py_RETURN_NONE; } /*=======Test Reset Option=====*/ /* This must be void(void) */ -void resetTest(void) -{ - tearDown(); - setUp(); +void resetTest(void) { + tearDown(); + setUp(); } /*=======Exposed Test Reset Option=====*/ -static PyObject* -reset_test(PyObject *self, PyObject *_null) -{ - resetTest(); +static PyObject *reset_test(PyObject *self, PyObject *_null) { + resetTest(); - Py_RETURN_NONE; + Py_RETURN_NONE; } /*=======Run The Tests=======*/ -static PyObject* -run_tests(PyObject *self, PyObject *_null) -{ - UnityBegin("base_ctest.c"); - RUN_TEST_PG_INTERNAL(test__pg_is_int_tuple_nominal, 15, self, _null); - RUN_TEST_PG_INTERNAL(test__pg_is_int_tuple_failureModes, 29, self, _null); - RUN_TEST_PG_INTERNAL(test__pg_is_int_tuple_floats, 46, self, _null); - - return PyLong_FromLong(UnityEnd()); +static PyObject *run_tests(PyObject *self, PyObject *_null) { + UnityBegin("base_ctest.c"); + RUN_TEST_PG_INTERNAL(test__pg_is_int_tuple_nominal, 15, self, _null); + RUN_TEST_PG_INTERNAL(test__pg_is_int_tuple_failureModes, 29, self, _null); + RUN_TEST_PG_INTERNAL(test__pg_is_int_tuple_floats, 46, self, _null); + + return PyLong_FromLong(UnityEnd()); } static PyMethodDef base_test_methods[] = { - {"test__pg_is_int_tuple_nominal", (PyCFunction)test__pg_is_int_tuple_nominal, METH_NOARGS, "Tests _pg_is_int_tuple when passed a tuple of ints"}, - {"test__pg_is_int_tuple_failureModes", (PyCFunction)test__pg_is_int_tuple_failureModes, METH_NOARGS, "Tests _pg_is_int_tuple when passed a tuple of non-numeric values"}, - {"test__pg_is_int_tuple_floats", (PyCFunction)test__pg_is_int_tuple_floats, METH_NOARGS, "Tests _pg_is_int_tuple when passed a tuple of floats"}, - {"reset_test", (PyCFunction)reset_test, METH_NOARGS, "Resets the test suite between tests, run_tests automatically calls this after each test case it calls"}, - {"run_tests", (PyCFunction)run_tests, METH_NOARGS, "Runs all the tests in this test wuite"}, + {"test__pg_is_int_tuple_nominal", + (PyCFunction)test__pg_is_int_tuple_nominal, METH_NOARGS, + "Tests _pg_is_int_tuple when passed a tuple of ints"}, + {"test__pg_is_int_tuple_failureModes", + (PyCFunction)test__pg_is_int_tuple_failureModes, METH_NOARGS, + "Tests _pg_is_int_tuple when passed a tuple of non-numeric values"}, + {"test__pg_is_int_tuple_floats", (PyCFunction)test__pg_is_int_tuple_floats, + METH_NOARGS, "Tests _pg_is_int_tuple when passed a tuple of floats"}, + {"reset_test", (PyCFunction)reset_test, METH_NOARGS, + "Resets the test suite between tests, run_tests automatically calls this " + "after each test case it calls"}, + {"run_tests", (PyCFunction)run_tests, METH_NOARGS, + "Runs all the tests in this test wuite"}, {NULL, NULL, 0, NULL}}; -MODINIT_DEFINE(base_ctest) -{ - PyObject* module; - - static struct PyModuleDef _module = {PyModuleDef_HEAD_INIT, - "base_ctest", - "C unit tests for the pygame.base internal implementation", - -1, - base_test_methods, - NULL, - NULL, - NULL, - NULL}; - - /* create the module */ - module = PyModule_Create(&_module); - if (!module) { - return NULL; - } - - return module; +MODINIT_DEFINE(base_ctest) { + PyObject *module; + + static struct PyModuleDef _module = { + PyModuleDef_HEAD_INIT, + "base_ctest", + "C unit tests for the pygame.base internal implementation", + -1, + base_test_methods, + NULL, + NULL, + NULL, + NULL}; + + /* create the module */ + module = PyModule_Create(&_module); + if (!module) { + return NULL; + } + + return module; } // #undef main diff --git a/ctest/test_common.h b/ctest/test_common.h index 5cc86a5d20..114ee4ceb9 100644 --- a/ctest/test_common.h +++ b/ctest/test_common.h @@ -3,21 +3,19 @@ #ifndef TEST_COMMON_H #define TEST_COMMON_H -#define RUN_TEST_PG_INTERNAL(TestFunc, TestLineNum, self_arg, null_arg) \ - { \ - Unity.CurrentTestName = #TestFunc; \ - Unity.CurrentTestLineNumber = TestLineNum; \ - Unity.NumberOfTests++; \ - if (TEST_PROTECT()) \ - { \ - setUp(); \ - TestFunc(self_arg, null_arg); \ - } \ - if (TEST_PROTECT()) \ - { \ - tearDown(); \ - } \ - UnityConcludeTest(); \ - } +#define RUN_TEST_PG_INTERNAL(TestFunc, TestLineNum, self_arg, null_arg) \ + { \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + if (TEST_PROTECT()) { \ + setUp(); \ + TestFunc(self_arg, null_arg); \ + } \ + if (TEST_PROTECT()) { \ + tearDown(); \ + } \ + UnityConcludeTest(); \ + } #endif // #ifndef TEST_COMMON_H diff --git a/test/ctest_test.py b/test/ctest_test.py index a90465816f..73f30fdbfb 100644 --- a/test/ctest_test.py +++ b/test/ctest_test.py @@ -6,6 +6,7 @@ except ModuleNotFoundError: pass + class Ctest(unittest.TestCase): @unittest.skipIf(base_ctest is None, "base_ctest not built") def test_run_base_ctests(self): From 43104f8b582b4db09241364c0071ec6ccc2a9e9e Mon Sep 17 00:00:00 2001 From: Andrew Coffey Date: Sat, 7 Jun 2025 09:59:42 -0500 Subject: [PATCH 12/21] Workflow no longer tries to upload nonexistent artifact and intentionally failing test no longer intentionally fails --- .github/workflows/run-ubuntu-checks.yml | 7 ------- ctest/base_ctest.c | 2 +- 2 files changed, 1 insertion(+), 8 deletions(-) diff --git a/.github/workflows/run-ubuntu-checks.yml b/.github/workflows/run-ubuntu-checks.yml index 13d23ec574..c5758ce1e0 100644 --- a/.github/workflows/run-ubuntu-checks.yml +++ b/.github/workflows/run-ubuntu-checks.yml @@ -128,13 +128,6 @@ jobs: name: pygame-wheels-coverage-{ matrix.os }-{ matrix.python } path: ./out - - name: Upload ctest log - if: ${{ steps.build-pygame-ce.conclusion == 'success' && !cancelled() }} - uses: actions/upload-artifact@v4 - with: - name: ctest_suite_log-{ matrix.os }-{ matrix.python } - path: ./ctest.log - # Run cppcheck static analysis on src_c changes run-cppcheck: runs-on: ubuntu-24.04 diff --git a/ctest/base_ctest.c b/ctest/base_ctest.c index 529f5ddcc4..bf83114ddd 100644 --- a/ctest/base_ctest.c +++ b/ctest/base_ctest.c @@ -52,7 +52,7 @@ static PyObject *test__pg_is_int_tuple_floats(PyObject *self, PyObject *_null) { PyObject *arg2 = Py_BuildValue("(ddd)", -1.1, -2.2, -3.3); PyObject *arg3 = Py_BuildValue("(ddd)", 1.0, -2.0, -3.1); - TEST_ASSERT_EQUAL(1, _pg_is_int_tuple(arg1)); + TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg1)); TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg2)); TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg3)); From a9b0e986314e22213d2dd1b9309aa4672171db5c Mon Sep 17 00:00:00 2001 From: Andrew Coffey Date: Sat, 7 Jun 2025 10:08:43 -0500 Subject: [PATCH 13/21] Properly reference matrix vars --- .github/workflows/run-ubuntu-checks.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/run-ubuntu-checks.yml b/.github/workflows/run-ubuntu-checks.yml index c5758ce1e0..ce634eb041 100644 --- a/.github/workflows/run-ubuntu-checks.yml +++ b/.github/workflows/run-ubuntu-checks.yml @@ -125,7 +125,7 @@ jobs: if: ${{ steps.gen-coverage.conclusion == 'success' && !cancelled() }} uses: actions/upload-artifact@v4 with: - name: pygame-wheels-coverage-{ matrix.os }-{ matrix.python } + name: pygame-wheels-coverage-${{ matrix.os }}-${{ matrix.python }} path: ./out # Run cppcheck static analysis on src_c changes From 99920aa1cb03d6c3d69a650f5860ac0c4fb6254d Mon Sep 17 00:00:00 2001 From: Andrew Coffey Date: Sat, 7 Jun 2025 10:19:07 -0500 Subject: [PATCH 14/21] Maybe fixed cppcheck diff --- .github/workflows/run-ubuntu-checks.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/run-ubuntu-checks.yml b/.github/workflows/run-ubuntu-checks.yml index ce634eb041..ce88a501da 100644 --- a/.github/workflows/run-ubuntu-checks.yml +++ b/.github/workflows/run-ubuntu-checks.yml @@ -140,6 +140,7 @@ jobs: id: check-changes run: | git fetch origin ${{ github.base_ref }} --depth=1 || true + git checkout ${{ github.base_ref }} CHANGED_FILES=$(git diff --name-only origin/${{ github.base_ref }}...HEAD) echo "$CHANGED_FILES" | grep '^src_c/' || echo "::set-output name=skip::true" From b8184e47280b63cedb14dbf4571dc3c35b31ca68 Mon Sep 17 00:00:00 2001 From: Andrew Coffey Date: Sat, 7 Jun 2025 18:31:57 -0500 Subject: [PATCH 15/21] Split off declarations of base module to header and exposed everything externally for potential unit tests --- src_c/base.c | 337 ++++++++++++++++++++++----------------------------- src_c/base.h | 215 ++++++++++++++++++++++++++++++++ 2 files changed, 358 insertions(+), 194 deletions(-) create mode 100644 src_c/base.h diff --git a/src_c/base.c b/src_c/base.c index 654e73404a..db0c459e45 100644 --- a/src_c/base.c +++ b/src_c/base.c @@ -19,165 +19,114 @@ Pete Shinners pete@shinners.org */ -#define NO_PYGAME_C_API -#define PYGAMEAPI_BASE_INTERNAL - -#include "pygame.h" - -#include -#include "doc/pygame_doc.h" -#include "pgarrinter.h" -#include "pgcompat.h" - -/* This file controls all the initialization of - * the module and the various SDL subsystems - */ - -/*platform specific init stuff*/ - -#ifdef MS_WIN32 /*python gives us MS_WIN32*/ -#define WIN32_LEAN_AND_MEAN -#define VC_EXTRALEAN -#include -extern int -SDL_RegisterApp(const char *, Uint32, void *); -#endif - -#if defined(macintosh) -#if (!defined(__MWERKS__) && !TARGET_API_MAC_CARBON) -QDGlobals pg_qd; -#endif -#endif - -#if SDL_BYTEORDER == SDL_LIL_ENDIAN -#define PAI_MY_ENDIAN '<' -#define PAI_OTHER_ENDIAN '>' -#define BUF_OTHER_ENDIAN '>' -#else -#define PAI_MY_ENDIAN '>' -#define PAI_OTHER_ENDIAN '<' -#define BUF_OTHER_ENDIAN '<' -#endif -#define BUF_MY_ENDIAN '=' - -/* Extended array struct */ -typedef struct pg_capsule_interface_s { - PyArrayInterface inter; - Py_intptr_t imem[1]; -} pgCapsuleInterface; - -/* Py_buffer internal data for an array interface/struct */ -typedef struct pg_view_internals_s { - char format[4]; /* make 4 byte word sized */ - Py_ssize_t imem[1]; -} pgViewInternals; +#include "base.h" /* Custom exceptions */ -static PyObject *pgExc_BufferError = NULL; +PyObject *pgExc_BufferError = NULL; /* Only one instance of the state per process. */ -static PyObject *pg_quit_functions = NULL; -static int pg_is_init = 0; -static int pg_sdl_was_init = 0; +PyObject *pg_quit_functions = NULL; +int pg_is_init = 0; +int pg_sdl_was_init = 0; SDL_Window *pg_default_window = NULL; pgSurfaceObject *pg_default_screen = NULL; -static int pg_env_blend_alpha_SDL2 = 0; +int pg_env_blend_alpha_SDL2 = 0; -static void +void pg_install_parachute(void); -static void +void pg_uninstall_parachute(void); -static void +void pg_atexit_quit(void); -static int +int pgGetArrayStruct(PyObject *, PyObject **, PyArrayInterface **); -static PyObject * +PyObject * pgArrayStruct_AsDict(PyArrayInterface *); -static PyObject * +PyObject * pgBuffer_AsArrayInterface(Py_buffer *); -static PyObject * +PyObject * pgBuffer_AsArrayStruct(Py_buffer *); -static int +int _pg_buffer_is_byteswapped(Py_buffer *); -static void +void pgBuffer_Release(pg_buffer *); -static int +int pgObject_GetBuffer(PyObject *, pg_buffer *, int); -static inline PyObject * +inline PyObject * pgObject_getRectHelper(PyObject *, PyObject *const *, Py_ssize_t, PyObject *, char *); -static int +int pgGetArrayInterface(PyObject **, PyObject *); -static int +int pgArrayStruct_AsBuffer(pg_buffer *, PyObject *, PyArrayInterface *, int); -static int +int _pg_arraystruct_as_buffer(Py_buffer *, PyObject *, PyArrayInterface *, int); -static int +int _pg_arraystruct_to_format(char *, PyArrayInterface *, int); -static int +int pgDict_AsBuffer(pg_buffer *, PyObject *, int); -static int +int _pg_shape_check(PyObject *); -static int +int _pg_typestr_check(PyObject *); -static int +int _pg_strides_check(PyObject *); -static int +int _pg_data_check(PyObject *); -static int +int _pg_is_int_tuple(PyObject *); -static int +int _pg_values_as_buffer(Py_buffer *, int, PyObject *, PyObject *, PyObject *, PyObject *); -static int +int _pg_int_tuple_as_ssize_arr(PyObject *, Py_ssize_t *); -static int +int _pg_typestr_as_format(PyObject *, char *, Py_ssize_t *); -static PyObject * +PyObject * pg_view_get_typestr_obj(Py_buffer *); -static PyObject * +PyObject * pg_view_get_shape_obj(Py_buffer *); -static PyObject * +PyObject * pg_view_get_strides_obj(Py_buffer *); -static PyObject * +PyObject * pg_view_get_data_obj(Py_buffer *); -static char +char _pg_as_arrayinter_typekind(Py_buffer *); -static char +char _pg_as_arrayinter_byteorder(Py_buffer *); -static int +int _pg_as_arrayinter_flags(Py_buffer *); -static pgCapsuleInterface * +pgCapsuleInterface * _pg_new_capsuleinterface(Py_buffer *); -static void +void _pg_capsule_PyMem_Free(PyObject *); -static PyObject * +PyObject * _pg_shape_as_tuple(PyArrayInterface *); -static PyObject * +PyObject * _pg_typekind_as_str(PyArrayInterface *); -static PyObject * +PyObject * _pg_strides_as_tuple(PyArrayInterface *); -static PyObject * +PyObject * _pg_data_as_tuple(PyArrayInterface *); -static PyObject * +PyObject * pg_get_array_interface(PyObject *, PyObject *); -static void +void _pg_release_buffer_array(Py_buffer *); -static void +void _pg_release_buffer_generic(Py_buffer *); -static SDL_Window * +SDL_Window * pg_GetDefaultWindow(void); -static void +void pg_SetDefaultWindow(SDL_Window *); -static pgSurfaceObject * +pgSurfaceObject * pg_GetDefaultWindowSurface(void); -static void +void pg_SetDefaultWindowSurface(pgSurfaceObject *); -static int +int pg_EnvShouldBlendAlphaSDL2(void); /* compare compiled to linked, raise python error on incompatibility */ -static int +int pg_CheckSDLVersions(void) { #if SDL_VERSION_ATLEAST(3, 0, 0) @@ -246,7 +195,7 @@ pg_RegisterQuit(void (*func)(void)) } } -static PyObject * +PyObject * pg_register_quit(PyObject *self, PyObject *value) { if (!pg_quit_functions) { @@ -263,7 +212,7 @@ pg_register_quit(PyObject *self, PyObject *value) } /* init pygame modules, returns 1 if successful, 0 if fail, with PyErr set*/ -static int +int pg_mod_autoinit(const char *modname) { PyObject *module, *funcobj, *temp; @@ -296,7 +245,7 @@ pg_mod_autoinit(const char *modname) } /* try to quit pygame modules, errors silenced */ -static void +void pg_mod_autoquit(const char *modname) { PyObject *module, *funcobj, *temp; @@ -333,7 +282,7 @@ pg_mod_autoquit(const char *modname) Py_XDECREF(funcobj); } -static PyObject * +PyObject * pg_init(PyObject *self, PyObject *_null) { int i = 0, success = 0, fail = 0; @@ -374,7 +323,7 @@ pg_init(PyObject *self, PyObject *_null) return pg_tuple_couple_from_values_int(success, fail); } -static void +void pg_atexit_quit(void) { /* Maybe it is safe to call SDL_quit more than once after an SDL_Init, @@ -387,7 +336,7 @@ pg_atexit_quit(void) } } -static PyObject * +PyObject * pg_get_sdl_version(PyObject *self, PyObject *args, PyObject *kwargs) { int linked = 1; /* Default is linked version. */ @@ -398,7 +347,7 @@ pg_get_sdl_version(PyObject *self, PyObject *args, PyObject *kwargs) SDL_VERSION(&version); #endif - static char *keywords[] = {"linked", NULL}; + char *keywords[] = {"linked", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|p", keywords, &linked)) { return NULL; /* Exception already set. */ @@ -417,13 +366,13 @@ pg_get_sdl_version(PyObject *self, PyObject *args, PyObject *kwargs) PG_FIND_VNUM_MICRO(version)); } -static PyObject * +PyObject * pg_get_sdl_byteorder(PyObject *self, PyObject *_null) { return PyLong_FromLong(SDL_BYTEORDER); } -static void +void _pg_quit(void) { Py_ssize_t num, i; @@ -491,21 +440,21 @@ _pg_quit(void) Py_END_ALLOW_THREADS; } -static PyObject * +PyObject * pg_quit(PyObject *self, PyObject *_null) { _pg_quit(); Py_RETURN_NONE; } -static PyObject * +PyObject * pg_base_get_init(PyObject *self, PyObject *_null) { return PyBool_FromLong(pg_is_init); } /* internal C API utility functions */ -static int +int pg_IntFromObj(PyObject *obj, int *val) { if (PyFloat_Check(obj)) { @@ -524,7 +473,7 @@ pg_IntFromObj(PyObject *obj, int *val) return 1; } -static int +int pg_IntFromObjIndex(PyObject *obj, int _index, int *val) { int result = 0; @@ -539,7 +488,7 @@ pg_IntFromObjIndex(PyObject *obj, int _index, int *val) return result; } -static int +int pg_TwoIntsFromObj(PyObject *obj, int *val1, int *val2) { // First, lets check the size. This returns -1 if invalid and may set an @@ -602,7 +551,7 @@ pg_TwoIntsFromObj(PyObject *obj, int *val1, int *val2) return 1; } -static int +int pg_FloatFromObj(PyObject *obj, float *val) { if (PyFloat_Check(obj)) { @@ -618,7 +567,7 @@ pg_FloatFromObj(PyObject *obj, float *val) return 1; } -static int +int pg_FloatFromObjIndex(PyObject *obj, int _index, float *val) { int result = 0; @@ -633,7 +582,7 @@ pg_FloatFromObjIndex(PyObject *obj, int _index, float *val) return result; } -static int +int pg_TwoFloatsFromObj(PyObject *obj, float *val1, float *val2) { // First, lets check the size. This returns -1 if invalid and may set an @@ -696,7 +645,7 @@ pg_TwoFloatsFromObj(PyObject *obj, float *val1, float *val2) return 1; } -static inline int +inline int pg_DoubleFromObj(PyObject *obj, double *val) { if (PyFloat_Check(obj)) { @@ -714,7 +663,7 @@ pg_DoubleFromObj(PyObject *obj, double *val) } /*Assumes obj is a Sequence, internal or conscious use only*/ -static inline int +inline int _pg_DoubleFromObjIndex(PyObject *obj, int index, double *val) { int result = 0; @@ -730,7 +679,7 @@ _pg_DoubleFromObjIndex(PyObject *obj, int index, double *val) return result; } -static inline int +inline int pg_TwoDoublesFromObj(PyObject *obj, double *val1, double *val2) { Py_ssize_t length; @@ -781,7 +730,7 @@ pg_TwoDoublesFromObj(PyObject *obj, double *val1, double *val2) return 1; } -static inline int +inline int pg_TwoDoublesFromFastcallArgs(PyObject *const *args, Py_ssize_t nargs, double *val1, double *val2) { @@ -795,7 +744,7 @@ pg_TwoDoublesFromFastcallArgs(PyObject *const *args, Py_ssize_t nargs, return 0; } -static int +int pg_UintFromObj(PyObject *obj, Uint32 *val) { if (PyNumber_Check(obj)) { @@ -816,7 +765,7 @@ pg_UintFromObj(PyObject *obj, Uint32 *val) return 0; } -static int +int pg_UintFromObjIndex(PyObject *obj, int _index, Uint32 *val) { int result = 0; @@ -832,7 +781,7 @@ pg_UintFromObjIndex(PyObject *obj, int _index, Uint32 *val) } /* You probably want to use the pg_RGBAFromObjEx function instead of this. */ -static int +int pg_RGBAFromObj(PyObject *obj, Uint8 *RGBA) { Py_ssize_t length; @@ -872,13 +821,13 @@ pg_RGBAFromObj(PyObject *obj, Uint8 *RGBA) return 1; } -static PyObject * +PyObject * pg_get_error(PyObject *self, PyObject *_null) { return PyUnicode_FromString(SDL_GetError()); } -static PyObject * +PyObject * pg_set_error(PyObject *s, PyObject *args) { char *errstring = NULL; @@ -900,7 +849,7 @@ pg_set_error(PyObject *s, PyObject *args) /*array interface*/ -static int +int pgGetArrayStruct(PyObject *obj, PyObject **cobj_p, PyArrayInterface **inter_p) { PyObject *cobj = PyObject_GetAttrString(obj, "__array_struct__"); @@ -929,7 +878,7 @@ pgGetArrayStruct(PyObject *obj, PyObject **cobj_p, PyArrayInterface **inter_p) return 0; } -static PyObject * +PyObject * pgArrayStruct_AsDict(PyArrayInterface *inter_p) { PyObject *dictobj = Py_BuildValue("{sisNsNsNsN}", "version", (int)3, @@ -957,7 +906,7 @@ pgArrayStruct_AsDict(PyArrayInterface *inter_p) return dictobj; } -static PyObject * +PyObject * pgBuffer_AsArrayInterface(Py_buffer *view_p) { return Py_BuildValue("{sisNsNsNsN}", "version", (int)3, "typestr", @@ -967,7 +916,7 @@ pgBuffer_AsArrayInterface(Py_buffer *view_p) pg_view_get_data_obj(view_p)); } -static PyObject * +PyObject * pgBuffer_AsArrayStruct(Py_buffer *view_p) { void *cinter_p = _pg_new_capsuleinterface(view_p); @@ -984,7 +933,7 @@ pgBuffer_AsArrayStruct(Py_buffer *view_p) return capsule; } -static pgCapsuleInterface * +pgCapsuleInterface * _pg_new_capsuleinterface(Py_buffer *view_p) { int ndim = view_p->ndim; @@ -1021,13 +970,13 @@ _pg_new_capsuleinterface(Py_buffer *view_p) return cinter_p; } -static void +void _pg_capsule_PyMem_Free(PyObject *capsule) { PyMem_Free(PyCapsule_GetPointer(capsule, 0)); } -static int +int _pg_as_arrayinter_flags(Py_buffer *view_p) { int inter_flags = PAI_ALIGNED; /* atomic int types always aligned */ @@ -1045,7 +994,7 @@ _pg_as_arrayinter_flags(Py_buffer *view_p) return inter_flags; } -static PyObject * +PyObject * pg_view_get_typestr_obj(Py_buffer *view) { return PyUnicode_FromFormat("%c%c%i", _pg_as_arrayinter_byteorder(view), @@ -1053,7 +1002,7 @@ pg_view_get_typestr_obj(Py_buffer *view) (int)view->itemsize); } -static PyObject * +PyObject * pg_view_get_shape_obj(Py_buffer *view) { PyObject *shapeobj = PyTuple_New(view->ndim); @@ -1074,7 +1023,7 @@ pg_view_get_shape_obj(Py_buffer *view) return shapeobj; } -static PyObject * +PyObject * pg_view_get_strides_obj(Py_buffer *view) { PyObject *shapeobj = PyTuple_New(view->ndim); @@ -1095,14 +1044,14 @@ pg_view_get_strides_obj(Py_buffer *view) return shapeobj; } -static PyObject * +PyObject * pg_view_get_data_obj(Py_buffer *view) { return Py_BuildValue("NN", PyLong_FromVoidPtr(view->buf), PyBool_FromLong((long)view->readonly)); } -static char +char _pg_as_arrayinter_typekind(Py_buffer *view) { char type = view->format ? view->format[0] : 'B'; @@ -1142,7 +1091,7 @@ _pg_as_arrayinter_typekind(Py_buffer *view) return typekind; } -static char +char _pg_as_arrayinter_byteorder(Py_buffer *view) { char format_0 = view->format ? view->format[0] : 'B'; @@ -1174,7 +1123,7 @@ _pg_as_arrayinter_byteorder(Py_buffer *view) return byteorder; } -static PyObject * +PyObject * _pg_shape_as_tuple(PyArrayInterface *inter_p) { PyObject *shapeobj = PyTuple_New((Py_ssize_t)inter_p->nd); @@ -1195,7 +1144,7 @@ _pg_shape_as_tuple(PyArrayInterface *inter_p) return shapeobj; } -static PyObject * +PyObject * _pg_typekind_as_str(PyArrayInterface *inter_p) { return PyUnicode_FromFormat( @@ -1207,7 +1156,7 @@ _pg_typekind_as_str(PyArrayInterface *inter_p) inter_p->typekind, inter_p->itemsize); } -static PyObject * +PyObject * _pg_strides_as_tuple(PyArrayInterface *inter_p) { PyObject *stridesobj = PyTuple_New((Py_ssize_t)inter_p->nd); @@ -1228,7 +1177,7 @@ _pg_strides_as_tuple(PyArrayInterface *inter_p) return stridesobj; } -static PyObject * +PyObject * _pg_data_as_tuple(PyArrayInterface *inter_p) { long readonly = (inter_p->flags & PAI_WRITEABLE) == 0; @@ -1237,7 +1186,7 @@ _pg_data_as_tuple(PyArrayInterface *inter_p) PyBool_FromLong(readonly)); } -static PyObject * +PyObject * pg_get_array_interface(PyObject *self, PyObject *arg) { PyObject *cobj; @@ -1252,7 +1201,7 @@ pg_get_array_interface(PyObject *self, PyObject *arg) return dictobj; } -static int +int pgObject_GetBuffer(PyObject *obj, pg_buffer *pg_view_p, int flags) { Py_buffer *view_p = (Py_buffer *)pg_view_p; @@ -1385,7 +1334,7 @@ pgObject_GetBuffer(PyObject *obj, pg_buffer *pg_view_p, int flags) return 0; } -static inline PyObject * +inline PyObject * pgObject_getRectHelper(PyObject *rect, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames, char *type) { @@ -1411,7 +1360,7 @@ pgObject_getRectHelper(PyObject *rect, PyObject *const *args, Py_ssize_t nargs, return rect; } -static void +void pgBuffer_Release(pg_buffer *pg_view_p) { assert(pg_view_p && pg_view_p->release_buffer); @@ -1423,7 +1372,7 @@ pgBuffer_Release(pg_buffer *pg_view_p) PyErr_Restore(type, value, traceback); } -static void +void _pg_release_buffer_generic(Py_buffer *view_p) { if (view_p->obj) { @@ -1432,7 +1381,7 @@ _pg_release_buffer_generic(Py_buffer *view_p) } } -static void +void _pg_release_buffer_array(Py_buffer *view_p) { /* This is deliberately made safe for use on an uninitialized *view_p */ @@ -1443,14 +1392,14 @@ _pg_release_buffer_array(Py_buffer *view_p) _pg_release_buffer_generic(view_p); } -static int +int _pg_buffer_is_byteswapped(Py_buffer *view) { if (view->format) { switch (view->format[0]) { case '<': #if SDL_BYTEORDER == SDL_LIL_ENDIAN - /* Use macros to make static analyzer happy */ + /* Use macros to make analyzer happy */ return 0; #else return 1; @@ -1458,7 +1407,7 @@ _pg_buffer_is_byteswapped(Py_buffer *view) case '>': case '!': #if SDL_BYTEORDER == SDL_BIG_ENDIAN - /* Use macros to make static analyzer happy */ + /* Use macros to make analyzer happy */ return 0; #else return 1; @@ -1468,7 +1417,7 @@ _pg_buffer_is_byteswapped(Py_buffer *view) return 0; } -static int +int pgGetArrayInterface(PyObject **dict, PyObject *obj) { PyObject *inter = PyObject_GetAttrString(obj, "__array_interface__"); @@ -1491,7 +1440,7 @@ pgGetArrayInterface(PyObject **dict, PyObject *obj) return 0; } -static int +int pgArrayStruct_AsBuffer(pg_buffer *pg_view_p, PyObject *cobj, PyArrayInterface *inter_p, int flags) { @@ -1504,7 +1453,7 @@ pgArrayStruct_AsBuffer(pg_buffer *pg_view_p, PyObject *cobj, return 0; } -static int +int _pg_arraystruct_as_buffer(Py_buffer *view_p, PyObject *cobj, PyArrayInterface *inter_p, int flags) { @@ -1599,7 +1548,7 @@ _pg_arraystruct_as_buffer(Py_buffer *view_p, PyObject *cobj, return 0; } -static int +int _pg_arraystruct_to_format(char *format, PyArrayInterface *inter_p, int max_format_len) { @@ -1724,7 +1673,7 @@ _pg_arraystruct_to_format(char *format, PyArrayInterface *inter_p, return 0; } -static int +int pgDict_AsBuffer(pg_buffer *pg_view_p, PyObject *dict, int flags) { PyObject *shape = PyDict_GetItemString(dict, "shape"); @@ -1753,7 +1702,7 @@ pgDict_AsBuffer(pg_buffer *pg_view_p, PyObject *dict, int flags) return 0; } -static int +int _pg_shape_check(PyObject *op) { if (!op) { @@ -1773,7 +1722,7 @@ _pg_shape_check(PyObject *op) return 0; } -static int +int _pg_typestr_check(PyObject *op) { if (!op) { @@ -1803,7 +1752,7 @@ _pg_typestr_check(PyObject *op) return 0; } -static int +int _pg_data_check(PyObject *op) { PyObject *item; @@ -1830,7 +1779,7 @@ _pg_data_check(PyObject *op) return 0; } -static int +int _pg_strides_check(PyObject *op) { if (op && !_pg_is_int_tuple(op) /* Conditional && */) { @@ -1841,7 +1790,7 @@ _pg_strides_check(PyObject *op) return 0; } -static int +int _pg_is_int_tuple(PyObject *op) { Py_ssize_t i; @@ -1861,7 +1810,7 @@ _pg_is_int_tuple(PyObject *op) return 1; } -static int +int _pg_values_as_buffer(Py_buffer *view_p, int flags, PyObject *typestr, PyObject *shape, PyObject *data, PyObject *strides) { @@ -1976,7 +1925,7 @@ _pg_values_as_buffer(Py_buffer *view_p, int flags, PyObject *typestr, return 0; } -static int +int _pg_int_tuple_as_ssize_arr(PyObject *tp, Py_ssize_t *arr) { Py_ssize_t i; @@ -1991,7 +1940,7 @@ _pg_int_tuple_as_ssize_arr(PyObject *tp, Py_ssize_t *arr) return 0; } -static int +int _pg_typestr_as_format(PyObject *sp, char *format, Py_ssize_t *itemsize_p) { const char *typestr; @@ -2167,13 +2116,13 @@ _pg_typestr_as_format(PyObject *sp, char *format, Py_ssize_t *itemsize_p) } /*Default window(display)*/ -static SDL_Window * +SDL_Window * pg_GetDefaultWindow(void) { return pg_default_window; } -static void +void pg_SetDefaultWindow(SDL_Window *win) { /*Allows a window to be replaced by itself*/ @@ -2186,14 +2135,14 @@ pg_SetDefaultWindow(SDL_Window *win) pg_default_window = win; } -static pgSurfaceObject * +pgSurfaceObject * pg_GetDefaultWindowSurface(void) { /* return a borrowed reference*/ return pg_default_screen; } -static void +void pg_SetDefaultWindowSurface(pgSurfaceObject *screen) { /*a screen surface can be replaced with itself*/ @@ -2207,7 +2156,7 @@ pg_SetDefaultWindowSurface(pgSurfaceObject *screen) PG_PixelFormatEnum pg_default_convert_format = 0; -static PG_PixelFormatEnum +PG_PixelFormatEnum pg_GetDefaultConvertFormat(void) { if (pg_default_screen) { @@ -2216,20 +2165,20 @@ pg_GetDefaultConvertFormat(void) return pg_default_convert_format; } -static void +void pg_SetDefaultConvertFormat(PG_PixelFormatEnum format) { pg_default_convert_format = format; } -static int +int pg_EnvShouldBlendAlphaSDL2(void) { return pg_env_blend_alpha_SDL2; } /*error signal handlers(replacing SDL parachute)*/ -static void +void pygame_parachute(int sig) { #ifdef HAVE_SIGNAL_H @@ -2267,7 +2216,7 @@ pygame_parachute(int sig) #endif } -static int fatal_signals[] = { +int fatal_signals[] = { SIGSEGV, #ifdef SIGBUS SIGBUS, @@ -2281,8 +2230,8 @@ static int fatal_signals[] = { 0 /*end of list*/ }; -static int parachute_installed = 0; -static void +int parachute_installed = 0; +void pg_install_parachute(void) { #ifdef HAVE_SIGNAL_H @@ -2306,7 +2255,7 @@ pg_install_parachute(void) return; } -static void +void pg_uninstall_parachute(void) { #ifdef HAVE_SIGNAL_H @@ -2330,7 +2279,7 @@ pg_uninstall_parachute(void) /* bind functions to python */ -static PyMethodDef _base_methods[] = { +PyMethodDef _base_methods[] = { {"init", (PyCFunction)pg_init, METH_NOARGS, DOC_INIT}, {"quit", (PyCFunction)pg_quit, METH_NOARGS, DOC_QUIT}, {"get_init", (PyCFunction)pg_base_get_init, METH_NOARGS, DOC_GETINIT}, @@ -2349,8 +2298,8 @@ static PyMethodDef _base_methods[] = { #if defined(BUILD_STATIC) && defined(NO_PYGAME_C_API) // in case of wasm+dynamic loading it could be a trampoline in the globals // generated at runtime. -// when building static make global accessible symbol directly. -static PyObject *pgExc_SDLError; +// when building make global accessible symbol directly. +PyObject *pgExc_SDLError; #endif MODINIT_DEFINE(base) @@ -2361,17 +2310,17 @@ MODINIT_DEFINE(base) // only pointer via C-api will be used, no need to keep global. PyObject *pgExc_SDLError; #endif - static void *c_api[PYGAMEAPI_BASE_NUMSLOTS]; - - static struct PyModuleDef _module = {PyModuleDef_HEAD_INIT, - "base", - "", - -1, - _base_methods, - NULL, - NULL, - NULL, - NULL}; + void *c_api[PYGAMEAPI_BASE_NUMSLOTS]; + + struct PyModuleDef _module = {PyModuleDef_HEAD_INIT, + "base", + "", + -1, + _base_methods, + NULL, + NULL, + NULL, + NULL}; /* import need modules. Do this first so if there is an error the module is not loaded. diff --git a/src_c/base.h b/src_c/base.h new file mode 100644 index 0000000000..ffd37e4781 --- /dev/null +++ b/src_c/base.h @@ -0,0 +1,215 @@ +#ifndef BASE_H +#define BASE_H + +#define NO_PYGAME_C_API +#define PYGAMEAPI_BASE_INTERNAL + +#include "pygame.h" + +#include +#include "doc/pygame_doc.h" +#include "pgarrinter.h" +#include "pgcompat.h" + +/* This file controls all the initialization of + * the module and the various SDL subsystems + */ + +/*platform specific init stuff*/ + +#ifdef MS_WIN32 /*python gives us MS_WIN32*/ +#define WIN32_LEAN_AND_MEAN +#define VC_EXTRALEAN +#include +extern int +SDL_RegisterApp(const char *, Uint32, void *); +#endif + +#if defined(macintosh) +#if (!defined(__MWERKS__) && !TARGET_API_MAC_CARBON) +QDGlobals pg_qd; +#endif +#endif + +#if SDL_BYTEORDER == SDL_LIL_ENDIAN +#define PAI_MY_ENDIAN '<' +#define PAI_OTHER_ENDIAN '>' +#define BUF_OTHER_ENDIAN '>' +#else +#define PAI_MY_ENDIAN '>' +#define PAI_OTHER_ENDIAN '<' +#define BUF_OTHER_ENDIAN '<' +#endif +#define BUF_MY_ENDIAN '=' + +/* Extended array struct */ +typedef struct pg_capsule_interface_s { + PyArrayInterface inter; + Py_intptr_t imem[1]; +} pgCapsuleInterface; + +/* Py_buffer internal data for an array interface/struct */ +typedef struct pg_view_internals_s { + char format[4]; /* make 4 byte word sized */ + Py_ssize_t imem[1]; +} pgViewInternals; + +void +pg_install_parachute(void); +void +pg_uninstall_parachute(void); +void +pg_atexit_quit(void); +int +pgGetArrayStruct(PyObject *, PyObject **, PyArrayInterface **); +PyObject * +pgArrayStruct_AsDict(PyArrayInterface *); +PyObject * +pgBuffer_AsArrayInterface(Py_buffer *); +PyObject * +pgBuffer_AsArrayStruct(Py_buffer *); +int +_pg_buffer_is_byteswapped(Py_buffer *); +void +pgBuffer_Release(pg_buffer *); +int +pgObject_GetBuffer(PyObject *, pg_buffer *, int); +extern inline PyObject * +pgObject_getRectHelper(PyObject *, PyObject *const *, Py_ssize_t, PyObject *, + char *); +int +pgGetArrayInterface(PyObject **, PyObject *); +int +pgArrayStruct_AsBuffer(pg_buffer *, PyObject *, PyArrayInterface *, int); +int +_pg_arraystruct_as_buffer(Py_buffer *, PyObject *, PyArrayInterface *, int); +int +_pg_arraystruct_to_format(char *, PyArrayInterface *, int); +int +pgDict_AsBuffer(pg_buffer *, PyObject *, int); +int +_pg_shape_check(PyObject *); +int +_pg_typestr_check(PyObject *); +int +_pg_strides_check(PyObject *); +int +_pg_data_check(PyObject *); +int +_pg_is_int_tuple(PyObject *); +int +_pg_values_as_buffer(Py_buffer *, int, PyObject *, PyObject *, PyObject *, + PyObject *); +int +_pg_int_tuple_as_ssize_arr(PyObject *, Py_ssize_t *); +int +_pg_typestr_as_format(PyObject *, char *, Py_ssize_t *); +PyObject * +pg_view_get_typestr_obj(Py_buffer *); +PyObject * +pg_view_get_shape_obj(Py_buffer *); +PyObject * +pg_view_get_strides_obj(Py_buffer *); +PyObject * +pg_view_get_data_obj(Py_buffer *); +char +_pg_as_arrayinter_typekind(Py_buffer *); +char +_pg_as_arrayinter_byteorder(Py_buffer *); +int +_pg_as_arrayinter_flags(Py_buffer *); +pgCapsuleInterface * +_pg_new_capsuleinterface(Py_buffer *); +void +_pg_capsule_PyMem_Free(PyObject *); +PyObject * +_pg_shape_as_tuple(PyArrayInterface *); +PyObject * +_pg_typekind_as_str(PyArrayInterface *); +PyObject * +_pg_strides_as_tuple(PyArrayInterface *); +PyObject * +_pg_data_as_tuple(PyArrayInterface *); +PyObject * +pg_get_array_interface(PyObject *, PyObject *); +void +_pg_release_buffer_array(Py_buffer *); +void +_pg_release_buffer_generic(Py_buffer *); +SDL_Window * +pg_GetDefaultWindow(void); +void +pg_SetDefaultWindow(SDL_Window *); +pgSurfaceObject * +pg_GetDefaultWindowSurface(void); +void +pg_SetDefaultWindowSurface(pgSurfaceObject *); +int +pg_EnvShouldBlendAlphaSDL2(void); +int +pg_CheckSDLVersions(void); +void +pg_RegisterQuit(void (*func)(void)); +PyObject * +pg_register_quit(PyObject *self, PyObject *value); +int +pg_mod_autoinit(const char *modname); +void +pg_mod_autoquit(const char *modname); +PyObject * +pg_init(PyObject *self, PyObject *_null); +PyObject * +pg_get_sdl_version(PyObject *self, PyObject *args, PyObject *kwargs); +PyObject * +pg_get_sdl_byteorder(PyObject *self, PyObject *_null); +void +_pg_quit(void); +PyObject * +pg_quit(PyObject *self, PyObject *_null); +PyObject * +pg_base_get_init(PyObject *self, PyObject *_null); +/* internal C API utility functions */ +int +pg_IntFromObj(PyObject *obj, int *val); +int +pg_IntFromObjIndex(PyObject *obj, int _index, int *val); +int +pg_TwoIntsFromObj(PyObject *obj, int *val1, int *val2); +int +pg_FloatFromObj(PyObject *obj, float *val); +int +pg_FloatFromObjIndex(PyObject *obj, int _index, float *val); +int +pg_TwoFloatsFromObj(PyObject *obj, float *val1, float *val2); +extern inline int +pg_DoubleFromObj(PyObject *obj, double *val); +/*Assumes obj is a Sequence, internal or conscious use only*/ +extern inline int +_pg_DoubleFromObjIndex(PyObject *obj, int index, double *val); +extern inline int +pg_TwoDoublesFromObj(PyObject *obj, double *val1, double *val2); +extern inline int +pg_TwoDoublesFromFastcallArgs(PyObject *const *args, Py_ssize_t nargs, + double *val1, double *val2); +int +pg_UintFromObj(PyObject *obj, Uint32 *val); +int +pg_UintFromObjIndex(PyObject *obj, int _index, Uint32 *val); +/* You probably want to use the pg_RGBAFromObjEx function instead of this. */ +int +pg_RGBAFromObj(PyObject *obj, Uint8 *RGBA); +PyObject * +pg_get_error(PyObject *self, PyObject *_null); +PyObject * +pg_set_error(PyObject *s, PyObject *args); +/*error signal handlers(replacing SDL parachute)*/ +void +pygame_parachute(int sig); +void +pg_SetDefaultConvertFormat(PG_PixelFormatEnum format); +PG_PixelFormatEnum +pg_GetDefaultConvertFormat(void); + +MODINIT_DEFINE(base); + +#endif // #ifndef BASE_H From e7bfb29cedb8baba2bdb0ab7977e187d2672cfb1 Mon Sep 17 00:00:00 2001 From: Andrew Coffey Date: Sat, 7 Jun 2025 19:31:06 -0500 Subject: [PATCH 16/21] Split off base declarations to base.h, and remove static linkage for future unit test purposes --- src_c/base.c | 274 ++++++------------------------------------------- src_c/base.h | 143 +++++++++++++++++++++++++- src_c/static.c | 2 +- 3 files changed, 169 insertions(+), 250 deletions(-) diff --git a/src_c/base.c b/src_c/base.c index db0c459e45..04740d7c9a 100644 --- a/src_c/base.c +++ b/src_c/base.c @@ -1,3 +1,4 @@ + /* pygame-ce - Python Game Library Copyright (C) 2000-2001 Pete Shinners @@ -19,111 +20,23 @@ Pete Shinners pete@shinners.org */ +#define NO_PYGAME_C_API +#define PYGAMEAPI_BASE_INTERNAL + #include "base.h" +PG_PixelFormatEnum pg_default_convert_format = 0; + /* Custom exceptions */ -PyObject *pgExc_BufferError = NULL; +static PyObject *pgExc_BufferError = NULL; /* Only one instance of the state per process. */ -PyObject *pg_quit_functions = NULL; -int pg_is_init = 0; -int pg_sdl_was_init = 0; +static PyObject *pg_quit_functions = NULL; +static int pg_is_init = 0; +static int pg_sdl_was_init = 0; SDL_Window *pg_default_window = NULL; pgSurfaceObject *pg_default_screen = NULL; -int pg_env_blend_alpha_SDL2 = 0; - -void -pg_install_parachute(void); -void -pg_uninstall_parachute(void); -void -pg_atexit_quit(void); -int -pgGetArrayStruct(PyObject *, PyObject **, PyArrayInterface **); -PyObject * -pgArrayStruct_AsDict(PyArrayInterface *); -PyObject * -pgBuffer_AsArrayInterface(Py_buffer *); -PyObject * -pgBuffer_AsArrayStruct(Py_buffer *); -int -_pg_buffer_is_byteswapped(Py_buffer *); -void -pgBuffer_Release(pg_buffer *); -int -pgObject_GetBuffer(PyObject *, pg_buffer *, int); -inline PyObject * -pgObject_getRectHelper(PyObject *, PyObject *const *, Py_ssize_t, PyObject *, - char *); -int -pgGetArrayInterface(PyObject **, PyObject *); -int -pgArrayStruct_AsBuffer(pg_buffer *, PyObject *, PyArrayInterface *, int); -int -_pg_arraystruct_as_buffer(Py_buffer *, PyObject *, PyArrayInterface *, int); -int -_pg_arraystruct_to_format(char *, PyArrayInterface *, int); -int -pgDict_AsBuffer(pg_buffer *, PyObject *, int); -int -_pg_shape_check(PyObject *); -int -_pg_typestr_check(PyObject *); -int -_pg_strides_check(PyObject *); -int -_pg_data_check(PyObject *); -int -_pg_is_int_tuple(PyObject *); -int -_pg_values_as_buffer(Py_buffer *, int, PyObject *, PyObject *, PyObject *, - PyObject *); -int -_pg_int_tuple_as_ssize_arr(PyObject *, Py_ssize_t *); -int -_pg_typestr_as_format(PyObject *, char *, Py_ssize_t *); -PyObject * -pg_view_get_typestr_obj(Py_buffer *); -PyObject * -pg_view_get_shape_obj(Py_buffer *); -PyObject * -pg_view_get_strides_obj(Py_buffer *); -PyObject * -pg_view_get_data_obj(Py_buffer *); -char -_pg_as_arrayinter_typekind(Py_buffer *); -char -_pg_as_arrayinter_byteorder(Py_buffer *); -int -_pg_as_arrayinter_flags(Py_buffer *); -pgCapsuleInterface * -_pg_new_capsuleinterface(Py_buffer *); -void -_pg_capsule_PyMem_Free(PyObject *); -PyObject * -_pg_shape_as_tuple(PyArrayInterface *); -PyObject * -_pg_typekind_as_str(PyArrayInterface *); -PyObject * -_pg_strides_as_tuple(PyArrayInterface *); -PyObject * -_pg_data_as_tuple(PyArrayInterface *); -PyObject * -pg_get_array_interface(PyObject *, PyObject *); -void -_pg_release_buffer_array(Py_buffer *); -void -_pg_release_buffer_generic(Py_buffer *); -SDL_Window * -pg_GetDefaultWindow(void); -void -pg_SetDefaultWindow(SDL_Window *); -pgSurfaceObject * -pg_GetDefaultWindowSurface(void); -void -pg_SetDefaultWindowSurface(pgSurfaceObject *); -int -pg_EnvShouldBlendAlphaSDL2(void); +static int pg_env_blend_alpha_SDL2 = 0; /* compare compiled to linked, raise python error on incompatibility */ int @@ -347,7 +260,7 @@ pg_get_sdl_version(PyObject *self, PyObject *args, PyObject *kwargs) SDL_VERSION(&version); #endif - char *keywords[] = {"linked", NULL}; + static char *keywords[] = {"linked", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|p", keywords, &linked)) { return NULL; /* Exception already set. */ @@ -645,105 +558,6 @@ pg_TwoFloatsFromObj(PyObject *obj, float *val1, float *val2) return 1; } -inline int -pg_DoubleFromObj(PyObject *obj, double *val) -{ - if (PyFloat_Check(obj)) { - *val = PyFloat_AS_DOUBLE(obj); - return 1; - } - - *val = (double)PyLong_AsLong(obj); - if (PyErr_Occurred()) { - PyErr_Clear(); - return 0; - } - - return 1; -} - -/*Assumes obj is a Sequence, internal or conscious use only*/ -inline int -_pg_DoubleFromObjIndex(PyObject *obj, int index, double *val) -{ - int result = 0; - - PyObject *item = PySequence_ITEM(obj, index); - if (!item) { - PyErr_Clear(); - return 0; - } - result = pg_DoubleFromObj(item, val); - Py_DECREF(item); - - return result; -} - -inline int -pg_TwoDoublesFromObj(PyObject *obj, double *val1, double *val2) -{ - Py_ssize_t length; - /*Faster path for tuples and lists*/ - if (pgSequenceFast_Check(obj)) { - length = PySequence_Fast_GET_SIZE(obj); - PyObject **f_arr = PySequence_Fast_ITEMS(obj); - if (length == 2) { - if (!pg_DoubleFromObj(f_arr[0], val1) || - !pg_DoubleFromObj(f_arr[1], val2)) { - return 0; - } - } - else if (length == 1) { - /* Handle case of ((x, y), ) 'nested sequence' */ - return pg_TwoDoublesFromObj(f_arr[0], val1, val2); - } - else { - return 0; - } - } - else if (PySequence_Check(obj)) { - length = PySequence_Length(obj); - if (length == 2) { - if (!_pg_DoubleFromObjIndex(obj, 0, val1)) { - return 0; - } - if (!_pg_DoubleFromObjIndex(obj, 1, val2)) { - return 0; - } - } - else if (length == 1 && !PyUnicode_Check(obj)) { - /* Handle case of ((x, y), ) 'nested sequence' */ - PyObject *tmp = PySequence_ITEM(obj, 0); - int ret = pg_TwoDoublesFromObj(tmp, val1, val2); - Py_DECREF(tmp); - return ret; - } - else { - PyErr_Clear(); - return 0; - } - } - else { - return 0; - } - - return 1; -} - -inline int -pg_TwoDoublesFromFastcallArgs(PyObject *const *args, Py_ssize_t nargs, - double *val1, double *val2) -{ - if (nargs == 1 && pg_TwoDoublesFromObj(args[0], val1, val2)) { - return 1; - } - else if (nargs == 2 && pg_DoubleFromObj(args[0], val1) && - pg_DoubleFromObj(args[1], val2)) { - return 1; - } - return 0; -} - int pg_UintFromObj(PyObject *obj, Uint32 *val) { @@ -1334,32 +1148,6 @@ pgObject_GetBuffer(PyObject *obj, pg_buffer *pg_view_p, int flags) return 0; } -inline PyObject * -pgObject_getRectHelper(PyObject *rect, PyObject *const *args, Py_ssize_t nargs, - PyObject *kwnames, char *type) -{ - if (nargs > 0) { - Py_DECREF(rect); - return PyErr_Format(PyExc_TypeError, - "get_%s only accepts keyword arguments", type); - } - - if (rect && kwnames) { - Py_ssize_t i, sequence_len; - PyObject **sequence_items; - sequence_items = PySequence_Fast_ITEMS(kwnames); - sequence_len = PyTuple_GET_SIZE(kwnames); - - for (i = 0; i < sequence_len; ++i) { - if ((PyObject_SetAttr(rect, sequence_items[i], args[i]) == -1)) { - Py_DECREF(rect); - return NULL; - } - } - } - return rect; -} - void pgBuffer_Release(pg_buffer *pg_view_p) { @@ -1399,7 +1187,7 @@ _pg_buffer_is_byteswapped(Py_buffer *view) switch (view->format[0]) { case '<': #if SDL_BYTEORDER == SDL_LIL_ENDIAN - /* Use macros to make analyzer happy */ + /* Use macros to make static analyzer happy */ return 0; #else return 1; @@ -1407,7 +1195,7 @@ _pg_buffer_is_byteswapped(Py_buffer *view) case '>': case '!': #if SDL_BYTEORDER == SDL_BIG_ENDIAN - /* Use macros to make analyzer happy */ + /* Use macros to make static analyzer happy */ return 0; #else return 1; @@ -2154,8 +1942,6 @@ pg_SetDefaultWindowSurface(pgSurfaceObject *screen) pg_default_screen = screen; } -PG_PixelFormatEnum pg_default_convert_format = 0; - PG_PixelFormatEnum pg_GetDefaultConvertFormat(void) { @@ -2216,7 +2002,7 @@ pygame_parachute(int sig) #endif } -int fatal_signals[] = { +static int fatal_signals[] = { SIGSEGV, #ifdef SIGBUS SIGBUS, @@ -2230,7 +2016,7 @@ int fatal_signals[] = { 0 /*end of list*/ }; -int parachute_installed = 0; +static int parachute_installed = 0; void pg_install_parachute(void) { @@ -2279,7 +2065,7 @@ pg_uninstall_parachute(void) /* bind functions to python */ -PyMethodDef _base_methods[] = { +static PyMethodDef _base_methods[] = { {"init", (PyCFunction)pg_init, METH_NOARGS, DOC_INIT}, {"quit", (PyCFunction)pg_quit, METH_NOARGS, DOC_QUIT}, {"get_init", (PyCFunction)pg_base_get_init, METH_NOARGS, DOC_GETINIT}, @@ -2298,8 +2084,8 @@ PyMethodDef _base_methods[] = { #if defined(BUILD_STATIC) && defined(NO_PYGAME_C_API) // in case of wasm+dynamic loading it could be a trampoline in the globals // generated at runtime. -// when building make global accessible symbol directly. -PyObject *pgExc_SDLError; +// when building static make global accessible symbol directly. +static PyObject *pgExc_SDLError; #endif MODINIT_DEFINE(base) @@ -2310,17 +2096,17 @@ MODINIT_DEFINE(base) // only pointer via C-api will be used, no need to keep global. PyObject *pgExc_SDLError; #endif - void *c_api[PYGAMEAPI_BASE_NUMSLOTS]; - - struct PyModuleDef _module = {PyModuleDef_HEAD_INIT, - "base", - "", - -1, - _base_methods, - NULL, - NULL, - NULL, - NULL}; + static void *c_api[PYGAMEAPI_BASE_NUMSLOTS]; + + static struct PyModuleDef _module = {PyModuleDef_HEAD_INIT, + "base", + "", + -1, + _base_methods, + NULL, + NULL, + NULL, + NULL}; /* import need modules. Do this first so if there is an error the module is not loaded. diff --git a/src_c/base.h b/src_c/base.h index ffd37e4781..fd01631396 100644 --- a/src_c/base.h +++ b/src_c/base.h @@ -54,6 +54,10 @@ typedef struct pg_view_internals_s { Py_ssize_t imem[1]; } pgViewInternals; +extern PG_PixelFormatEnum pg_default_convert_format; +extern SDL_Window *pg_default_window; +extern pgSurfaceObject *pg_default_screen; + void pg_install_parachute(void); void @@ -74,7 +78,7 @@ void pgBuffer_Release(pg_buffer *); int pgObject_GetBuffer(PyObject *, pg_buffer *, int); -extern inline PyObject * +static inline PyObject * pgObject_getRectHelper(PyObject *, PyObject *const *, Py_ssize_t, PyObject *, char *); int @@ -181,14 +185,14 @@ int pg_FloatFromObjIndex(PyObject *obj, int _index, float *val); int pg_TwoFloatsFromObj(PyObject *obj, float *val1, float *val2); -extern inline int +static inline int pg_DoubleFromObj(PyObject *obj, double *val); /*Assumes obj is a Sequence, internal or conscious use only*/ -extern inline int +static inline int _pg_DoubleFromObjIndex(PyObject *obj, int index, double *val); -extern inline int +static inline int pg_TwoDoublesFromObj(PyObject *obj, double *val1, double *val2); -extern inline int +static inline int pg_TwoDoublesFromFastcallArgs(PyObject *const *args, Py_ssize_t nargs, double *val1, double *val2); int @@ -202,14 +206,143 @@ PyObject * pg_get_error(PyObject *self, PyObject *_null); PyObject * pg_set_error(PyObject *s, PyObject *args); + /*error signal handlers(replacing SDL parachute)*/ void pygame_parachute(int sig); + void pg_SetDefaultConvertFormat(PG_PixelFormatEnum format); + PG_PixelFormatEnum pg_GetDefaultConvertFormat(void); MODINIT_DEFINE(base); +/*=======static inline function definitions=======*/ +static inline PyObject * +pgObject_getRectHelper(PyObject *rect, PyObject *const *args, Py_ssize_t nargs, + PyObject *kwnames, char *type) +{ + if (nargs > 0) { + Py_DECREF(rect); + return PyErr_Format(PyExc_TypeError, + "get_%s only accepts keyword arguments", type); + } + + if (rect && kwnames) { + Py_ssize_t i, sequence_len; + PyObject **sequence_items; + sequence_items = PySequence_Fast_ITEMS(kwnames); + sequence_len = PyTuple_GET_SIZE(kwnames); + + for (i = 0; i < sequence_len; ++i) { + if ((PyObject_SetAttr(rect, sequence_items[i], args[i]) == -1)) { + Py_DECREF(rect); + return NULL; + } + } + } + return rect; +} + +static inline int +pg_DoubleFromObj(PyObject *obj, double *val) +{ + if (PyFloat_Check(obj)) { + *val = PyFloat_AS_DOUBLE(obj); + return 1; + } + + *val = (double)PyLong_AsLong(obj); + if (PyErr_Occurred()) { + PyErr_Clear(); + return 0; + } + + return 1; +} + +/*Assumes obj is a Sequence, internal or conscious use only*/ +static inline int +_pg_DoubleFromObjIndex(PyObject *obj, int index, double *val) +{ + int result = 0; + + PyObject *item = PySequence_ITEM(obj, index); + if (!item) { + PyErr_Clear(); + return 0; + } + result = pg_DoubleFromObj(item, val); + Py_DECREF(item); + + return result; +} + +static inline int +pg_TwoDoublesFromObj(PyObject *obj, double *val1, double *val2) +{ + Py_ssize_t length; + /*Faster path for tuples and lists*/ + if (pgSequenceFast_Check(obj)) { + length = PySequence_Fast_GET_SIZE(obj); + PyObject **f_arr = PySequence_Fast_ITEMS(obj); + if (length == 2) { + if (!pg_DoubleFromObj(f_arr[0], val1) || + !pg_DoubleFromObj(f_arr[1], val2)) { + return 0; + } + } + else if (length == 1) { + /* Handle case of ((x, y), ) 'nested sequence' */ + return pg_TwoDoublesFromObj(f_arr[0], val1, val2); + } + else { + return 0; + } + } + else if (PySequence_Check(obj)) { + length = PySequence_Length(obj); + if (length == 2) { + if (!_pg_DoubleFromObjIndex(obj, 0, val1)) { + return 0; + } + if (!_pg_DoubleFromObjIndex(obj, 1, val2)) { + return 0; + } + } + else if (length == 1 && !PyUnicode_Check(obj)) { + /* Handle case of ((x, y), ) 'nested sequence' */ + PyObject *tmp = PySequence_ITEM(obj, 0); + int ret = pg_TwoDoublesFromObj(tmp, val1, val2); + Py_DECREF(tmp); + return ret; + } + else { + PyErr_Clear(); + return 0; + } + } + else { + return 0; + } + + return 1; +} + +static inline int +pg_TwoDoublesFromFastcallArgs(PyObject *const *args, Py_ssize_t nargs, + double *val1, double *val2) +{ + if (nargs == 1 && pg_TwoDoublesFromObj(args[0], val1, val2)) { + return 1; + } + else if (nargs == 2 && pg_DoubleFromObj(args[0], val1) && + pg_DoubleFromObj(args[1], val2)) { + return 1; + } + return 0; +} + #endif // #ifndef BASE_H diff --git a/src_c/static.c b/src_c/static.c index 87c0264d14..6201f1bc18 100644 --- a/src_c/static.c +++ b/src_c/static.c @@ -334,7 +334,7 @@ PyInit_pygame_static() #endif // defined(BUILD_STATIC) -#include "base.c" +#include "base.h" #include "rect.c" #include "pgcompat_rect.c" From 2aa120f5dc0d4c1746b9fc0912eb432c86f06c9d Mon Sep 17 00:00:00 2001 From: Andrew Coffey Date: Sat, 7 Jun 2025 19:39:07 -0500 Subject: [PATCH 17/21] Should fix WASM build --- src_c/base.c | 9 +-------- src_c/base.h | 8 ++++++++ 2 files changed, 9 insertions(+), 8 deletions(-) diff --git a/src_c/base.c b/src_c/base.c index 04740d7c9a..f4cf4136c7 100644 --- a/src_c/base.c +++ b/src_c/base.c @@ -28,7 +28,7 @@ PG_PixelFormatEnum pg_default_convert_format = 0; /* Custom exceptions */ -static PyObject *pgExc_BufferError = NULL; +PyObject *pgExc_BufferError = NULL; /* Only one instance of the state per process. */ static PyObject *pg_quit_functions = NULL; @@ -2081,13 +2081,6 @@ static PyMethodDef _base_methods[] = { "return an array struct interface as an interface dictionary"}, {NULL, NULL, 0, NULL}}; -#if defined(BUILD_STATIC) && defined(NO_PYGAME_C_API) -// in case of wasm+dynamic loading it could be a trampoline in the globals -// generated at runtime. -// when building static make global accessible symbol directly. -static PyObject *pgExc_SDLError; -#endif - MODINIT_DEFINE(base) { PyObject *module, *apiobj, *atexit; diff --git a/src_c/base.h b/src_c/base.h index fd01631396..8fb0970eac 100644 --- a/src_c/base.h +++ b/src_c/base.h @@ -55,6 +55,7 @@ typedef struct pg_view_internals_s { } pgViewInternals; extern PG_PixelFormatEnum pg_default_convert_format; +extern PyObject *pgExc_BufferError; extern SDL_Window *pg_default_window; extern pgSurfaceObject *pg_default_screen; @@ -217,6 +218,13 @@ pg_SetDefaultConvertFormat(PG_PixelFormatEnum format); PG_PixelFormatEnum pg_GetDefaultConvertFormat(void); +#if defined(BUILD_STATIC) && defined(NO_PYGAME_C_API) +// in case of wasm+dynamic loading it could be a trampoline in the globals +// generated at runtime. +// when building static make global accessible symbol directly. +extern PyObject *pgExc_SDLError; +#endif + MODINIT_DEFINE(base); /*=======static inline function definitions=======*/ From f9298f6044d962b44cf3f39b379e2edf9dc55006 Mon Sep 17 00:00:00 2001 From: Ankith Date: Mon, 9 Jun 2025 01:00:26 +0530 Subject: [PATCH 18/21] Fix cppcheck skip logic on CI --- .github/workflows/run-ubuntu-checks.yml | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/.github/workflows/run-ubuntu-checks.yml b/.github/workflows/run-ubuntu-checks.yml index 06eb1ccbd6..49e03ec045 100644 --- a/.github/workflows/run-ubuntu-checks.yml +++ b/.github/workflows/run-ubuntu-checks.yml @@ -135,13 +135,19 @@ jobs: steps: - uses: actions/checkout@v4.2.2 + with: + fetch-depth: 0 # fetch full history - name: Check if any src_c files changed id: check-changes + continue-on-error: true run: | - git fetch origin ${{ github.base_ref }} --depth=1 || true - git checkout ${{ github.base_ref }} - CHANGED_FILES=$(git diff --name-only origin/${{ github.base_ref }}...HEAD) + if [[ "${{ github.event_name }}" == "pull_request" ]]; then + CHANGED_FILES=$(git diff --name-only origin/${{ github.base_ref }}...HEAD) + else + CHANGED_FILES=$(git diff --name-only HEAD^1...HEAD) + fi + echo "Changed files: $CHANGED_FILES" echo "$CHANGED_FILES" | grep '^src_c/' || echo "skip=true" >> "$GITHUB_OUTPUT" - name: Install cppcheck From 9f4fd1cbb17dfb47735e1d5628243453974c6075 Mon Sep 17 00:00:00 2001 From: Andrew Coffey Date: Sun, 8 Jun 2025 21:42:16 -0500 Subject: [PATCH 19/21] Code cleanup, reverted unnecessary changes --- .github/workflows/run-ubuntu-checks.yml | 2 +- .gitignore | 1 - ctest/base_ctest.c | 146 ++++++++++++------------ ctest/test_common.h | 54 ++++++--- dev.py | 6 +- 5 files changed, 114 insertions(+), 95 deletions(-) diff --git a/.github/workflows/run-ubuntu-checks.yml b/.github/workflows/run-ubuntu-checks.yml index 4526bc700e..de99d94e8b 100644 --- a/.github/workflows/run-ubuntu-checks.yml +++ b/.github/workflows/run-ubuntu-checks.yml @@ -125,7 +125,7 @@ jobs: if: ${{ steps.gen-coverage.conclusion == 'success' && !cancelled() }} uses: actions/upload-artifact@v4 with: - name: pygame-wheels-coverage-${{ matrix.os }}-${{ matrix.python }} + name: pygame-coverage-${{ matrix.os }}-${{ matrix.python }} path: ./out # Run cppcheck static analysis on src_c changes diff --git a/.gitignore b/.gitignore index da98211204..f29b774e44 100644 --- a/.gitignore +++ b/.gitignore @@ -52,7 +52,6 @@ dist __pycache__ _headers/* buildconfig/win_dll_dirs.json -*.log # cython generated files src_c/_sdl2/*.c diff --git a/ctest/base_ctest.c b/ctest/base_ctest.c index bf83114ddd..705366bd8a 100644 --- a/ctest/base_ctest.c +++ b/ctest/base_ctest.c @@ -13,74 +13,78 @@ void tearDown(void) {} /** * @brief Tests _pg_is_int_tuple when passed a tuple of ints */ -static PyObject *test__pg_is_int_tuple_nominal(PyObject *self, - PyObject *_null) { - PyObject *arg1 = Py_BuildValue("(iii)", 1, 2, 3); - PyObject *arg2 = Py_BuildValue("(iii)", -1, -2, -3); - PyObject *arg3 = Py_BuildValue("(iii)", 1, -2, -3); +PG_CTEST(test__pg_is_int_tuple_nominal) +{ + PyObject *arg1 = Py_BuildValue("(iii)", 1, 2, 3); + PyObject *arg2 = Py_BuildValue("(iii)", -1, -2, -3); + PyObject *arg3 = Py_BuildValue("(iii)", 1, -2, -3); - TEST_ASSERT_EQUAL(1, _pg_is_int_tuple(arg1)); - TEST_ASSERT_EQUAL(1, _pg_is_int_tuple(arg2)); - TEST_ASSERT_EQUAL(1, _pg_is_int_tuple(arg3)); + TEST_ASSERT_EQUAL(1, _pg_is_int_tuple(arg1)); + TEST_ASSERT_EQUAL(1, _pg_is_int_tuple(arg2)); + TEST_ASSERT_EQUAL(1, _pg_is_int_tuple(arg3)); - Py_RETURN_NONE; + Py_RETURN_NONE; } /** * @brief Tests _pg_is_int_tuple when passed a tuple of non-numeric values */ -static PyObject *test__pg_is_int_tuple_failureModes(PyObject *self, - PyObject *_null) { - PyObject *arg1 = - Py_BuildValue("(sss)", (char *)"Larry", (char *)"Moe", (char *)"Curly"); - PyObject *arg2 = Py_BuildValue("(sss)", (char *)NULL, (char *)NULL, - (char *)NULL); // tuple of None's - PyObject *arg3 = Py_BuildValue("(OOO)", arg1, arg2, arg1); - - TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg1)); - TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg2)); - TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg3)); - - Py_RETURN_NONE; +PG_CTEST(test__pg_is_int_tuple_failureModes) +{ + PyObject *arg1 = + Py_BuildValue("(sss)", (char *)"Larry", (char *)"Moe", (char *)"Curly"); + PyObject *arg2 = Py_BuildValue("(sss)", (char *)NULL, (char *)NULL, + (char *)NULL); // tuple of None's + PyObject *arg3 = Py_BuildValue("(OOO)", arg1, arg2, arg1); + + TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg1)); + TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg2)); + TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg3)); + + Py_RETURN_NONE; } /** * @brief Tests _pg_is_int_tuple when passed a tuple of floats */ -static PyObject *test__pg_is_int_tuple_floats(PyObject *self, PyObject *_null) { - PyObject *arg1 = Py_BuildValue("(ddd)", 1.0, 2.0, 3.0); - PyObject *arg2 = Py_BuildValue("(ddd)", -1.1, -2.2, -3.3); - PyObject *arg3 = Py_BuildValue("(ddd)", 1.0, -2.0, -3.1); +PG_CTEST(test__pg_is_int_tuple_floats) +{ + PyObject *arg1 = Py_BuildValue("(ddd)", 1.0, 2.0, 3.0); + PyObject *arg2 = Py_BuildValue("(ddd)", -1.1, -2.2, -3.3); + PyObject *arg3 = Py_BuildValue("(ddd)", 1.0, -2.0, -3.1); - TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg1)); - TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg2)); - TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg3)); + TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg1)); + TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg2)); + TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg3)); - Py_RETURN_NONE; + Py_RETURN_NONE; } /*=======Test Reset Option=====*/ /* This must be void(void) */ -void resetTest(void) { - tearDown(); - setUp(); +void resetTest(void) +{ + tearDown(); + setUp(); } /*=======Exposed Test Reset Option=====*/ -static PyObject *reset_test(PyObject *self, PyObject *_null) { - resetTest(); +static PyObject *reset_test(PyObject *self, PyObject *_null) +{ + resetTest(); - Py_RETURN_NONE; + Py_RETURN_NONE; } /*=======Run The Tests=======*/ -static PyObject *run_tests(PyObject *self, PyObject *_null) { - UnityBegin("base_ctest.c"); - RUN_TEST_PG_INTERNAL(test__pg_is_int_tuple_nominal, 15, self, _null); - RUN_TEST_PG_INTERNAL(test__pg_is_int_tuple_failureModes, 29, self, _null); - RUN_TEST_PG_INTERNAL(test__pg_is_int_tuple_floats, 46, self, _null); - - return PyLong_FromLong(UnityEnd()); +static PyObject *run_tests(PyObject *self, PyObject *_null) +{ + UnityBegin("base_ctest.c"); + RUN_TEST_PG_INTERNAL(test__pg_is_int_tuple_nominal); + RUN_TEST_PG_INTERNAL(test__pg_is_int_tuple_failureModes); + RUN_TEST_PG_INTERNAL(test__pg_is_int_tuple_floats); + + return PyLong_FromLong(UnityEnd()); } static PyMethodDef base_test_methods[] = { @@ -99,37 +103,27 @@ static PyMethodDef base_test_methods[] = { "Runs all the tests in this test wuite"}, {NULL, NULL, 0, NULL}}; -MODINIT_DEFINE(base_ctest) { - PyObject *module; - - static struct PyModuleDef _module = { - PyModuleDef_HEAD_INIT, - "base_ctest", - "C unit tests for the pygame.base internal implementation", - -1, - base_test_methods, - NULL, - NULL, - NULL, - NULL}; - - /* create the module */ - module = PyModule_Create(&_module); - if (!module) { - return NULL; - } - - return module; +MODINIT_DEFINE(base_ctest) +{ + PyObject *module; + + static struct PyModuleDef _module = { + PyModuleDef_HEAD_INIT, + "base_ctest", + "C unit tests for the pygame.base internal implementation", + -1, + base_test_methods, + NULL, + NULL, + NULL, + NULL}; + + /* create the module */ + module = PyModule_Create(&_module); + if (!module) + { + return NULL; + } + + return module; } - -// #undef main -// /*=======MAIN=====*/ -// int main(void) { -// Py_Initialize(); -// UnityBegin("test_base.c"); -// RUN_TEST(test__pg_is_int_tuple_nominal, 17); -// RUN_TEST(test__pg_is_int_tuple_failureModes, 31); -// RUN_TEST(test__pg_is_int_tuple_floats, 45); - -// return (UnityEnd()); -// } diff --git a/ctest/test_common.h b/ctest/test_common.h index 114ee4ceb9..7843aea470 100644 --- a/ctest/test_common.h +++ b/ctest/test_common.h @@ -1,21 +1,47 @@ +#include + #include "unity.h" #ifndef TEST_COMMON_H #define TEST_COMMON_H -#define RUN_TEST_PG_INTERNAL(TestFunc, TestLineNum, self_arg, null_arg) \ - { \ - Unity.CurrentTestName = #TestFunc; \ - Unity.CurrentTestLineNumber = TestLineNum; \ - Unity.NumberOfTests++; \ - if (TEST_PROTECT()) { \ - setUp(); \ - TestFunc(self_arg, null_arg); \ - } \ - if (TEST_PROTECT()) { \ - tearDown(); \ - } \ - UnityConcludeTest(); \ - } +struct TestCase +{ + char *test_name; + int line_num; +}; + +/* + This will take some explanation... the PG_CTEST macro defines two things + for an individual test case. The test case itself, and a struct instance + called meta_TEST_CASE_NAME. The struct has two pieces of important + information that unity needs: the name in string format and the line + number of the test. This would be an absolute nighmare to maintain by + hand, so I defined a macro to do it automagically for us. + + The RUN_TEST_PG_INTERNAL macro then references that struct for each test + case that we tell it about and automatically populates the unity fields + with the requisite data. +*/ +#define PG_CTEST(TestFunc) \ + static struct TestCase meta_##TestFunc = {#TestFunc, __LINE__}; \ + static PyObject *TestFunc##(PyObject * self, PyObject * _null) + +#define RUN_TEST_PG_INTERNAL(TestFunc) \ + { \ + Unity.CurrentTestName = meta_##TestFunc.test_name; \ + Unity.CurrentTestLineNumber = meta_##TestFunc.line_num; \ + Unity.NumberOfTests++; \ + if (TEST_PROTECT()) \ + { \ + setUp(); \ + TestFunc(self, _null); \ + } \ + if (TEST_PROTECT()) \ + { \ + tearDown(); \ + } \ + UnityConcludeTest(); \ + } #endif // #ifndef TEST_COMMON_H diff --git a/dev.py b/dev.py index 482b0bf91e..936adceb7f 100644 --- a/dev.py +++ b/dev.py @@ -211,9 +211,9 @@ def cmd_build(self): sdl3 = self.args.get("sdl3", False) coverage = self.args.get("coverage", False) ctest = self.args.get("ctest", False) - # if wheel_dir and coverage: - # pprint("Cannot pass --wheel and --coverage together", Colors.RED) - # sys.exit(1) + if wheel_dir and coverage: + pprint("Cannot pass --wheel and --coverage together", Colors.RED) + sys.exit(1) build_suffix = "" if debug: From 0af9f90fe9e1118b354f958c0d338a3cc2361777 Mon Sep 17 00:00:00 2001 From: Andrew Coffey Date: Sun, 8 Jun 2025 21:43:08 -0500 Subject: [PATCH 20/21] Code formatting --- ctest/base_ctest.c | 132 +++++++++++++++++++++----------------------- ctest/test_common.h | 43 +++++++-------- 2 files changed, 82 insertions(+), 93 deletions(-) diff --git a/ctest/base_ctest.c b/ctest/base_ctest.c index 705366bd8a..57791e71e1 100644 --- a/ctest/base_ctest.c +++ b/ctest/base_ctest.c @@ -13,78 +13,72 @@ void tearDown(void) {} /** * @brief Tests _pg_is_int_tuple when passed a tuple of ints */ -PG_CTEST(test__pg_is_int_tuple_nominal) -{ - PyObject *arg1 = Py_BuildValue("(iii)", 1, 2, 3); - PyObject *arg2 = Py_BuildValue("(iii)", -1, -2, -3); - PyObject *arg3 = Py_BuildValue("(iii)", 1, -2, -3); +PG_CTEST(test__pg_is_int_tuple_nominal) { + PyObject *arg1 = Py_BuildValue("(iii)", 1, 2, 3); + PyObject *arg2 = Py_BuildValue("(iii)", -1, -2, -3); + PyObject *arg3 = Py_BuildValue("(iii)", 1, -2, -3); - TEST_ASSERT_EQUAL(1, _pg_is_int_tuple(arg1)); - TEST_ASSERT_EQUAL(1, _pg_is_int_tuple(arg2)); - TEST_ASSERT_EQUAL(1, _pg_is_int_tuple(arg3)); + TEST_ASSERT_EQUAL(1, _pg_is_int_tuple(arg1)); + TEST_ASSERT_EQUAL(1, _pg_is_int_tuple(arg2)); + TEST_ASSERT_EQUAL(1, _pg_is_int_tuple(arg3)); - Py_RETURN_NONE; + Py_RETURN_NONE; } /** * @brief Tests _pg_is_int_tuple when passed a tuple of non-numeric values */ -PG_CTEST(test__pg_is_int_tuple_failureModes) -{ - PyObject *arg1 = - Py_BuildValue("(sss)", (char *)"Larry", (char *)"Moe", (char *)"Curly"); - PyObject *arg2 = Py_BuildValue("(sss)", (char *)NULL, (char *)NULL, - (char *)NULL); // tuple of None's - PyObject *arg3 = Py_BuildValue("(OOO)", arg1, arg2, arg1); - - TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg1)); - TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg2)); - TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg3)); - - Py_RETURN_NONE; +PG_CTEST(test__pg_is_int_tuple_failureModes) { + PyObject *arg1 = + Py_BuildValue("(sss)", (char *)"Larry", (char *)"Moe", (char *)"Curly"); + PyObject *arg2 = Py_BuildValue("(sss)", (char *)NULL, (char *)NULL, + (char *)NULL); // tuple of None's + PyObject *arg3 = Py_BuildValue("(OOO)", arg1, arg2, arg1); + + TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg1)); + TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg2)); + TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg3)); + + Py_RETURN_NONE; } /** * @brief Tests _pg_is_int_tuple when passed a tuple of floats */ -PG_CTEST(test__pg_is_int_tuple_floats) -{ - PyObject *arg1 = Py_BuildValue("(ddd)", 1.0, 2.0, 3.0); - PyObject *arg2 = Py_BuildValue("(ddd)", -1.1, -2.2, -3.3); - PyObject *arg3 = Py_BuildValue("(ddd)", 1.0, -2.0, -3.1); +PG_CTEST(test__pg_is_int_tuple_floats) { + PyObject *arg1 = Py_BuildValue("(ddd)", 1.0, 2.0, 3.0); + PyObject *arg2 = Py_BuildValue("(ddd)", -1.1, -2.2, -3.3); + PyObject *arg3 = Py_BuildValue("(ddd)", 1.0, -2.0, -3.1); - TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg1)); - TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg2)); - TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg3)); + TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg1)); + TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg2)); + TEST_ASSERT_EQUAL(0, _pg_is_int_tuple(arg3)); - Py_RETURN_NONE; + Py_RETURN_NONE; } /*=======Test Reset Option=====*/ /* This must be void(void) */ -void resetTest(void) -{ - tearDown(); - setUp(); +void resetTest(void) { + tearDown(); + setUp(); } /*=======Exposed Test Reset Option=====*/ -static PyObject *reset_test(PyObject *self, PyObject *_null) -{ - resetTest(); +static PyObject *reset_test(PyObject *self, PyObject *_null) { + resetTest(); - Py_RETURN_NONE; + Py_RETURN_NONE; } /*=======Run The Tests=======*/ -static PyObject *run_tests(PyObject *self, PyObject *_null) -{ - UnityBegin("base_ctest.c"); - RUN_TEST_PG_INTERNAL(test__pg_is_int_tuple_nominal); - RUN_TEST_PG_INTERNAL(test__pg_is_int_tuple_failureModes); - RUN_TEST_PG_INTERNAL(test__pg_is_int_tuple_floats); - - return PyLong_FromLong(UnityEnd()); +static PyObject *run_tests(PyObject *self, PyObject *_null) { + UnityBegin("base_ctest.c"); + RUN_TEST_PG_INTERNAL(test__pg_is_int_tuple_nominal); + RUN_TEST_PG_INTERNAL(test__pg_is_int_tuple_failureModes); + RUN_TEST_PG_INTERNAL(test__pg_is_int_tuple_floats); + + return PyLong_FromLong(UnityEnd()); } static PyMethodDef base_test_methods[] = { @@ -103,27 +97,25 @@ static PyMethodDef base_test_methods[] = { "Runs all the tests in this test wuite"}, {NULL, NULL, 0, NULL}}; -MODINIT_DEFINE(base_ctest) -{ - PyObject *module; - - static struct PyModuleDef _module = { - PyModuleDef_HEAD_INIT, - "base_ctest", - "C unit tests for the pygame.base internal implementation", - -1, - base_test_methods, - NULL, - NULL, - NULL, - NULL}; - - /* create the module */ - module = PyModule_Create(&_module); - if (!module) - { - return NULL; - } - - return module; +MODINIT_DEFINE(base_ctest) { + PyObject *module; + + static struct PyModuleDef _module = { + PyModuleDef_HEAD_INIT, + "base_ctest", + "C unit tests for the pygame.base internal implementation", + -1, + base_test_methods, + NULL, + NULL, + NULL, + NULL}; + + /* create the module */ + module = PyModule_Create(&_module); + if (!module) { + return NULL; + } + + return module; } diff --git a/ctest/test_common.h b/ctest/test_common.h index 7843aea470..0c31e6a54b 100644 --- a/ctest/test_common.h +++ b/ctest/test_common.h @@ -5,10 +5,9 @@ #ifndef TEST_COMMON_H #define TEST_COMMON_H -struct TestCase -{ - char *test_name; - int line_num; +struct TestCase { + char *test_name; + int line_num; }; /* @@ -23,25 +22,23 @@ struct TestCase case that we tell it about and automatically populates the unity fields with the requisite data. */ -#define PG_CTEST(TestFunc) \ - static struct TestCase meta_##TestFunc = {#TestFunc, __LINE__}; \ - static PyObject *TestFunc##(PyObject * self, PyObject * _null) +#define PG_CTEST(TestFunc) \ + static struct TestCase meta_##TestFunc = {#TestFunc, __LINE__}; \ + static PyObject *TestFunc##(PyObject * self, PyObject * _null) -#define RUN_TEST_PG_INTERNAL(TestFunc) \ - { \ - Unity.CurrentTestName = meta_##TestFunc.test_name; \ - Unity.CurrentTestLineNumber = meta_##TestFunc.line_num; \ - Unity.NumberOfTests++; \ - if (TEST_PROTECT()) \ - { \ - setUp(); \ - TestFunc(self, _null); \ - } \ - if (TEST_PROTECT()) \ - { \ - tearDown(); \ - } \ - UnityConcludeTest(); \ - } +#define RUN_TEST_PG_INTERNAL(TestFunc) \ + { \ + Unity.CurrentTestName = meta_##TestFunc.test_name; \ + Unity.CurrentTestLineNumber = meta_##TestFunc.line_num; \ + Unity.NumberOfTests++; \ + if (TEST_PROTECT()) { \ + setUp(); \ + TestFunc(self, _null); \ + } \ + if (TEST_PROTECT()) { \ + tearDown(); \ + } \ + UnityConcludeTest(); \ + } #endif // #ifndef TEST_COMMON_H From b850dad1b7e1eca86a00c89542cb2b4c6c45a590 Mon Sep 17 00:00:00 2001 From: Andrew Coffey Date: Sun, 8 Jun 2025 22:06:55 -0500 Subject: [PATCH 21/21] Make slightly less clever use of token pasting to make gcc happy --- ctest/base_ctest.c | 6 +++--- ctest/test_common.h | 6 +++++- 2 files changed, 8 insertions(+), 4 deletions(-) diff --git a/ctest/base_ctest.c b/ctest/base_ctest.c index 57791e71e1..c001552ad6 100644 --- a/ctest/base_ctest.c +++ b/ctest/base_ctest.c @@ -13,7 +13,7 @@ void tearDown(void) {} /** * @brief Tests _pg_is_int_tuple when passed a tuple of ints */ -PG_CTEST(test__pg_is_int_tuple_nominal) { +PG_CTEST(test__pg_is_int_tuple_nominal)(PyObject *self, PyObject *_null) { PyObject *arg1 = Py_BuildValue("(iii)", 1, 2, 3); PyObject *arg2 = Py_BuildValue("(iii)", -1, -2, -3); PyObject *arg3 = Py_BuildValue("(iii)", 1, -2, -3); @@ -28,7 +28,7 @@ PG_CTEST(test__pg_is_int_tuple_nominal) { /** * @brief Tests _pg_is_int_tuple when passed a tuple of non-numeric values */ -PG_CTEST(test__pg_is_int_tuple_failureModes) { +PG_CTEST(test__pg_is_int_tuple_failureModes)(PyObject *self, PyObject *_null) { PyObject *arg1 = Py_BuildValue("(sss)", (char *)"Larry", (char *)"Moe", (char *)"Curly"); PyObject *arg2 = Py_BuildValue("(sss)", (char *)NULL, (char *)NULL, @@ -45,7 +45,7 @@ PG_CTEST(test__pg_is_int_tuple_failureModes) { /** * @brief Tests _pg_is_int_tuple when passed a tuple of floats */ -PG_CTEST(test__pg_is_int_tuple_floats) { +PG_CTEST(test__pg_is_int_tuple_floats)(PyObject *self, PyObject *_null) { PyObject *arg1 = Py_BuildValue("(ddd)", 1.0, 2.0, 3.0); PyObject *arg2 = Py_BuildValue("(ddd)", -1.1, -2.2, -3.3); PyObject *arg3 = Py_BuildValue("(ddd)", 1.0, -2.0, -3.1); diff --git a/ctest/test_common.h b/ctest/test_common.h index 0c31e6a54b..4442f6dce2 100644 --- a/ctest/test_common.h +++ b/ctest/test_common.h @@ -21,10 +21,14 @@ struct TestCase { The RUN_TEST_PG_INTERNAL macro then references that struct for each test case that we tell it about and automatically populates the unity fields with the requisite data. + + Note that the arguments to the test function must be *exactly* + (PyObject * self, PyObject * _null), but due to gcc throwing a fit, I + cannot just use token pasting to have the macro generate that part for me */ #define PG_CTEST(TestFunc) \ static struct TestCase meta_##TestFunc = {#TestFunc, __LINE__}; \ - static PyObject *TestFunc##(PyObject * self, PyObject * _null) + static PyObject *TestFunc #define RUN_TEST_PG_INTERNAL(TestFunc) \ { \