From 987a54b31f6d0750d0e0cc7071eefd06a550a49c Mon Sep 17 00:00:00 2001 From: Apostolof Date: Sun, 16 Jun 2019 22:23:45 +0300 Subject: [PATCH] Init unit testing using Unity --- Makefile | 142 +- test/runners/test_circ_buff_Runner.c | 92 + test/test_circ_buff.c | 235 +- unity/.editorconfig | 27 + unity/.gitattributes | 30 + unity/.gitignore | 9 + unity/.travis.yml | 29 + unity/CMakeLists.txt | 70 + unity/LICENSE.txt | 21 + unity/README.md | 191 + unity/auto/colour_prompt.rb | 118 + unity/auto/colour_reporter.rb | 39 + unity/auto/generate_config.yml | 36 + unity/auto/generate_module.rb | 306 + unity/auto/generate_test_runner.rb | 475 + unity/auto/parse_output.rb | 322 + unity/auto/stylize_as_junit.rb | 248 + unity/auto/test_file_filter.rb | 25 + unity/auto/type_sanitizer.rb | 6 + unity/auto/unity_test_summary.py | 139 + unity/auto/unity_test_summary.rb | 132 + unity/auto/unity_to_junit.py | 146 + unity/docs/ThrowTheSwitchCodingStandard.md | 206 + ...tSuitableforPrintingandPossiblyFraming.pdf | Bin 0 -> 144467 bytes unity/docs/UnityAssertionsReference.md | 814 ++ unity/docs/UnityConfigurationGuide.md | 520 ++ unity/docs/UnityGettingStartedGuide.md | 250 + unity/docs/UnityHelperScriptsGuide.md | 266 + unity/examples/example_1/makefile | 71 + unity/examples/example_1/readme.txt | 5 + unity/examples/example_1/src/ProductionCode.c | 24 + unity/examples/example_1/src/ProductionCode.h | 3 + .../examples/example_1/src/ProductionCode2.c | 11 + .../examples/example_1/src/ProductionCode2.h | 2 + .../example_1/test/TestProductionCode.c | 62 + .../example_1/test/TestProductionCode2.c | 31 + .../test_runners/TestProductionCode2_Runner.c | 53 + .../test_runners/TestProductionCode_Runner.c | 57 + unity/examples/example_2/makefile | 70 + unity/examples/example_2/readme.txt | 5 + unity/examples/example_2/src/ProductionCode.c | 24 + unity/examples/example_2/src/ProductionCode.h | 3 + .../examples/example_2/src/ProductionCode2.c | 11 + .../examples/example_2/src/ProductionCode2.h | 2 + .../example_2/test/TestProductionCode.c | 64 + .../example_2/test/TestProductionCode2.c | 33 + .../test_runners/TestProductionCode2_Runner.c | 9 + .../test_runners/TestProductionCode_Runner.c | 11 + .../example_2/test/test_runners/all_tests.c | 12 + unity/examples/example_3/helper/UnityHelper.c | 10 + unity/examples/example_3/helper/UnityHelper.h | 12 + unity/examples/example_3/rakefile.rb | 40 + unity/examples/example_3/rakefile_helper.rb | 249 + unity/examples/example_3/readme.txt | 13 + unity/examples/example_3/src/ProductionCode.c | 24 + unity/examples/example_3/src/ProductionCode.h | 3 + .../examples/example_3/src/ProductionCode2.c | 11 + .../examples/example_3/src/ProductionCode2.h | 2 + unity/examples/example_3/target_gcc_32.yml | 47 + .../example_3/test/TestProductionCode.c | 62 + .../example_3/test/TestProductionCode2.c | 31 + unity/examples/unity_config.h | 263 + unity/extras/eclipse/error_parsers.txt | 26 + unity/extras/fixture/rakefile.rb | 46 + unity/extras/fixture/rakefile_helper.rb | 178 + unity/extras/fixture/readme.txt | 9 + unity/extras/fixture/src/unity_fixture.c | 455 + unity/extras/fixture/src/unity_fixture.h | 83 + .../fixture/src/unity_fixture_internals.h | 52 + .../src/unity_fixture_malloc_overrides.h | 47 + unity/extras/fixture/test/Makefile | 75 + unity/extras/fixture/test/main/AllTests.c | 22 + .../fixture/test/template_fixture_tests.c | 39 + .../extras/fixture/test/unity_fixture_Test.c | 543 ++ .../fixture/test/unity_fixture_TestRunner.c | 57 + unity/extras/fixture/test/unity_output_Spy.c | 57 + unity/extras/fixture/test/unity_output_Spy.h | 17 + unity/release/build.info | 2 + unity/release/version.info | 2 + unity/src/unity.c | 1985 +++++ unity/src/unity.h | 539 ++ unity/src/unity_internals.h | 990 +++ unity/test/.rubocop.yml | 58 + unity/test/Makefile | 68 + unity/test/expectdata/testsample_cmd.c | 61 + unity/test/expectdata/testsample_def.c | 57 + unity/test/expectdata/testsample_head1.c | 55 + unity/test/expectdata/testsample_head1.h | 15 + unity/test/expectdata/testsample_mock_cmd.c | 80 + unity/test/expectdata/testsample_mock_def.c | 76 + unity/test/expectdata/testsample_mock_head1.c | 75 + unity/test/expectdata/testsample_mock_head1.h | 13 + unity/test/expectdata/testsample_mock_new1.c | 89 + unity/test/expectdata/testsample_mock_new2.c | 89 + unity/test/expectdata/testsample_mock_param.c | 77 + unity/test/expectdata/testsample_mock_run1.c | 89 + unity/test/expectdata/testsample_mock_run2.c | 89 + unity/test/expectdata/testsample_mock_yaml.c | 90 + unity/test/expectdata/testsample_new1.c | 67 + unity/test/expectdata/testsample_new2.c | 70 + unity/test/expectdata/testsample_param.c | 58 + unity/test/expectdata/testsample_run1.c | 67 + unity/test/expectdata/testsample_run2.c | 70 + unity/test/expectdata/testsample_yaml.c | 71 + unity/test/rakefile | 124 + unity/test/rakefile_helper.rb | 260 + .../generate_module_existing_file_spec.rb | 158 + unity/test/targets/clang_file.yml | 78 + unity/test/targets/clang_strict.yml | 78 + unity/test/targets/gcc_32.yml | 49 + unity/test/targets/gcc_64.yml | 50 + unity/test/targets/gcc_auto_limits.yml | 47 + unity/test/targets/gcc_auto_stdint.yml | 59 + unity/test/targets/gcc_manual_math.yml | 47 + unity/test/targets/hitech_picc18.yml | 101 + unity/test/targets/iar_arm_v4.yml | 90 + unity/test/targets/iar_arm_v5.yml | 80 + unity/test/targets/iar_arm_v5_3.yml | 80 + .../targets/iar_armcortex_LM3S9B92_v5_4.yml | 94 + unity/test/targets/iar_cortexm3_v5.yml | 84 + unity/test/targets/iar_msp430.yml | 95 + unity/test/targets/iar_sh2a_v6.yml | 86 + unity/test/testdata/CException.h | 11 + unity/test/testdata/Defs.h | 8 + unity/test/testdata/cmock.h | 14 + unity/test/testdata/mockMock.h | 13 + unity/test/testdata/testRunnerGenerator.c | 186 + .../test/testdata/testRunnerGeneratorSmall.c | 70 + .../testdata/testRunnerGeneratorWithMocks.c | 195 + unity/test/tests/test_generate_test_runner.rb | 1252 +++ unity/test/tests/testparameterized.c | 174 + unity/test/tests/testunity.c | 7804 +++++++++++++++++ 132 files changed, 24252 insertions(+), 67 deletions(-) create mode 100644 test/runners/test_circ_buff_Runner.c create mode 100644 unity/.editorconfig create mode 100644 unity/.gitattributes create mode 100644 unity/.gitignore create mode 100644 unity/.travis.yml create mode 100644 unity/CMakeLists.txt create mode 100644 unity/LICENSE.txt create mode 100644 unity/README.md create mode 100644 unity/auto/colour_prompt.rb create mode 100644 unity/auto/colour_reporter.rb create mode 100644 unity/auto/generate_config.yml create mode 100644 unity/auto/generate_module.rb create mode 100644 unity/auto/generate_test_runner.rb create mode 100644 unity/auto/parse_output.rb create mode 100644 unity/auto/stylize_as_junit.rb create mode 100644 unity/auto/test_file_filter.rb create mode 100644 unity/auto/type_sanitizer.rb create mode 100644 unity/auto/unity_test_summary.py create mode 100644 unity/auto/unity_test_summary.rb create mode 100644 unity/auto/unity_to_junit.py create mode 100644 unity/docs/ThrowTheSwitchCodingStandard.md create mode 100644 unity/docs/UnityAssertionsCheatSheetSuitableforPrintingandPossiblyFraming.pdf create mode 100644 unity/docs/UnityAssertionsReference.md create mode 100644 unity/docs/UnityConfigurationGuide.md create mode 100644 unity/docs/UnityGettingStartedGuide.md create mode 100644 unity/docs/UnityHelperScriptsGuide.md create mode 100644 unity/examples/example_1/makefile create mode 100644 unity/examples/example_1/readme.txt create mode 100644 unity/examples/example_1/src/ProductionCode.c create mode 100644 unity/examples/example_1/src/ProductionCode.h create mode 100644 unity/examples/example_1/src/ProductionCode2.c create mode 100644 unity/examples/example_1/src/ProductionCode2.h create mode 100644 unity/examples/example_1/test/TestProductionCode.c create mode 100644 unity/examples/example_1/test/TestProductionCode2.c create mode 100644 unity/examples/example_1/test/test_runners/TestProductionCode2_Runner.c create mode 100644 unity/examples/example_1/test/test_runners/TestProductionCode_Runner.c create mode 100644 unity/examples/example_2/makefile create mode 100644 unity/examples/example_2/readme.txt create mode 100644 unity/examples/example_2/src/ProductionCode.c create mode 100644 unity/examples/example_2/src/ProductionCode.h create mode 100644 unity/examples/example_2/src/ProductionCode2.c create mode 100644 unity/examples/example_2/src/ProductionCode2.h create mode 100644 unity/examples/example_2/test/TestProductionCode.c create mode 100644 unity/examples/example_2/test/TestProductionCode2.c create mode 100644 unity/examples/example_2/test/test_runners/TestProductionCode2_Runner.c create mode 100644 unity/examples/example_2/test/test_runners/TestProductionCode_Runner.c create mode 100644 unity/examples/example_2/test/test_runners/all_tests.c create mode 100644 unity/examples/example_3/helper/UnityHelper.c create mode 100644 unity/examples/example_3/helper/UnityHelper.h create mode 100644 unity/examples/example_3/rakefile.rb create mode 100644 unity/examples/example_3/rakefile_helper.rb create mode 100644 unity/examples/example_3/readme.txt create mode 100644 unity/examples/example_3/src/ProductionCode.c create mode 100644 unity/examples/example_3/src/ProductionCode.h create mode 100644 unity/examples/example_3/src/ProductionCode2.c create mode 100644 unity/examples/example_3/src/ProductionCode2.h create mode 100644 unity/examples/example_3/target_gcc_32.yml create mode 100644 unity/examples/example_3/test/TestProductionCode.c create mode 100644 unity/examples/example_3/test/TestProductionCode2.c create mode 100644 unity/examples/unity_config.h create mode 100644 unity/extras/eclipse/error_parsers.txt create mode 100644 unity/extras/fixture/rakefile.rb create mode 100644 unity/extras/fixture/rakefile_helper.rb create mode 100644 unity/extras/fixture/readme.txt create mode 100644 unity/extras/fixture/src/unity_fixture.c create mode 100644 unity/extras/fixture/src/unity_fixture.h create mode 100644 unity/extras/fixture/src/unity_fixture_internals.h create mode 100644 unity/extras/fixture/src/unity_fixture_malloc_overrides.h create mode 100644 unity/extras/fixture/test/Makefile create mode 100644 unity/extras/fixture/test/main/AllTests.c create mode 100644 unity/extras/fixture/test/template_fixture_tests.c create mode 100644 unity/extras/fixture/test/unity_fixture_Test.c create mode 100644 unity/extras/fixture/test/unity_fixture_TestRunner.c create mode 100644 unity/extras/fixture/test/unity_output_Spy.c create mode 100644 unity/extras/fixture/test/unity_output_Spy.h create mode 100644 unity/release/build.info create mode 100644 unity/release/version.info create mode 100644 unity/src/unity.c create mode 100644 unity/src/unity.h create mode 100644 unity/src/unity_internals.h create mode 100644 unity/test/.rubocop.yml create mode 100644 unity/test/Makefile create mode 100644 unity/test/expectdata/testsample_cmd.c create mode 100644 unity/test/expectdata/testsample_def.c create mode 100644 unity/test/expectdata/testsample_head1.c create mode 100644 unity/test/expectdata/testsample_head1.h create mode 100644 unity/test/expectdata/testsample_mock_cmd.c create mode 100644 unity/test/expectdata/testsample_mock_def.c create mode 100644 unity/test/expectdata/testsample_mock_head1.c create mode 100644 unity/test/expectdata/testsample_mock_head1.h create mode 100644 unity/test/expectdata/testsample_mock_new1.c create mode 100644 unity/test/expectdata/testsample_mock_new2.c create mode 100644 unity/test/expectdata/testsample_mock_param.c create mode 100644 unity/test/expectdata/testsample_mock_run1.c create mode 100644 unity/test/expectdata/testsample_mock_run2.c create mode 100644 unity/test/expectdata/testsample_mock_yaml.c create mode 100644 unity/test/expectdata/testsample_new1.c create mode 100644 unity/test/expectdata/testsample_new2.c create mode 100644 unity/test/expectdata/testsample_param.c create mode 100644 unity/test/expectdata/testsample_run1.c create mode 100644 unity/test/expectdata/testsample_run2.c create mode 100644 unity/test/expectdata/testsample_yaml.c create mode 100644 unity/test/rakefile create mode 100644 unity/test/rakefile_helper.rb create mode 100644 unity/test/spec/generate_module_existing_file_spec.rb create mode 100644 unity/test/targets/clang_file.yml create mode 100644 unity/test/targets/clang_strict.yml create mode 100644 unity/test/targets/gcc_32.yml create mode 100644 unity/test/targets/gcc_64.yml create mode 100644 unity/test/targets/gcc_auto_limits.yml create mode 100644 unity/test/targets/gcc_auto_stdint.yml create mode 100644 unity/test/targets/gcc_manual_math.yml create mode 100644 unity/test/targets/hitech_picc18.yml create mode 100644 unity/test/targets/iar_arm_v4.yml create mode 100644 unity/test/targets/iar_arm_v5.yml create mode 100644 unity/test/targets/iar_arm_v5_3.yml create mode 100644 unity/test/targets/iar_armcortex_LM3S9B92_v5_4.yml create mode 100644 unity/test/targets/iar_cortexm3_v5.yml create mode 100644 unity/test/targets/iar_msp430.yml create mode 100644 unity/test/targets/iar_sh2a_v6.yml create mode 100644 unity/test/testdata/CException.h create mode 100644 unity/test/testdata/Defs.h create mode 100644 unity/test/testdata/cmock.h create mode 100644 unity/test/testdata/mockMock.h create mode 100644 unity/test/testdata/testRunnerGenerator.c create mode 100644 unity/test/testdata/testRunnerGeneratorSmall.c create mode 100644 unity/test/testdata/testRunnerGeneratorWithMocks.c create mode 100644 unity/test/tests/test_generate_test_runner.rb create mode 100644 unity/test/tests/testparameterized.c create mode 100644 unity/test/tests/testunity.c diff --git a/Makefile b/Makefile index e78c199..26048b6 100644 --- a/Makefile +++ b/Makefile @@ -1,49 +1,121 @@ -SHELL := /bin/bash +ifeq ($(OS),Windows_NT) + ifeq ($(shell uname -s),) # not in a bash-like shell + CLEANUP = del /F /Q + MKDIR = mkdir + else # in a bash-like shell, like msys + CLEANUP = rm -f + MKDIR = mkdir -p + endif + TARGET_EXTENSION=.exe +else + CLEANUP = rm -f + MKDIR = mkdir -p + TARGET_EXTENSION=out +endif -CC = gcc -std=gnu99 -RM = rm -f -CFLAGS_DEBUG=-O0 -ggdb3 -Wall -Werror -pedantic -D_FORTIFY_SOURCE=2 -fasynchronous-unwind-tables -grecord-gcc-switches -Werror=implicit-function-declaration -I. -CFLAGS=-O2 -Wall -Werror -pedantic -I. +.PHONY: runners +.PHONY: clean +.PHONY: test -TESTS_SRC = $(wildcard test/*.c) -EXECS_SRC = $(wildcard zaqar/*.c) -DEPS_SRC = $(wildcard lib/*.c) +PATHU = unity/src/ +PATHS = src/ +PATHT = test/ +PATHTR = test/runners/ +PATHL = lib/ +PATHB = build/ +PATHD = build/depends/ +PATHO = build/objs/ +PATHR = build/results/ -DEPS_OBJ = $(DEPS_SRC:.c=.o) -TESTS_OBJ = $(DEPS_OBJ) \ - $(TESTS_SRC:.c=.o) -EXECS_OBJ = $(DEPS_OBJ) \ - $(EXECS_SRC:.c=.o) -ALL_OBJ = $(DEPS_OBJ) \ - $(TESTS_SRC:.c=.o) \ - $(EXECS_SRC:.c=.o) +BUILD_PATHS = $(PATHB) $(PATHD) $(PATHO) $(PATHR) $(PATHL) -DEPS_TRACK = $(OBJ:.o=.d) +RUNNERS = $(patsubst $(PATHT)%.c,$(PATHTR)%_Runner.c, $(wildcard $(PATHT)*.c)) -TESTS = test/test_circ_buff -EXECUTABLES = zaqar +runners: $(RUNNERS) test -.PHONY: all +SRCTR = $(wildcard $(PATHTR)*.c) -all: $(TESTS) $(EXECUTABLES) -execs: $(EXECUTABLES) -tests: $(TESTS) +COMPILE = gcc -c +LINK = gcc +DEPEND = gcc -MM -MG -MF +CFLAGS = -I. -I$(PATHU) -I$(PATHS) -I$(PATHL) -DTEST -$(TESTS): $(TESTS_OBJ) - $(CC) -o $@ $^ $(CFLAGS) +CFLAGS += -std=c99 +CFLAGS += -Wall +CFLAGS += -Wextra +CFLAGS += -Wpointer-arith +CFLAGS += -Wcast-align +# CFLAGS += -Wwrite-strings +CFLAGS += -Wswitch-default +CFLAGS += -Wunreachable-code +CFLAGS += -Winit-self +CFLAGS += -Wmissing-field-initializers +CFLAGS += -Wno-unknown-pragmas +CFLAGS += -Wstrict-prototypes +CFLAGS += -Wundef +CFLAGS += -Wold-style-definition -$(EXECUTABLES): $(EXECS_OBJ) - $(CC) -o $@ $^ $(CFLAGS) +RESULTS = $(patsubst $(PATHTR)test_%_Runner.c,$(PATHR)test_%.txt,$(SRCTR)) --include $(DEPS_TRACK) +PASSED = `grep -s PASS $(PATHR)*.txt` +FAIL = `grep -s FAIL $(PATHR)*.txt` +IGNORE = `grep -s IGNORE $(PATHR)*.txt` -%.d: %.c - @$(CPP) $(CFLAGS) $< -MM -MT $(@:.d=.o) >$@ +test: $(BUILD_PATHS) $(RESULTS) + @echo "===============UNIT TEST RESULTS===============\n" + @echo "---------------IGNORES---------------" + @echo "$(IGNORE)" + @echo "---------------FAILURES---------------" + @echo "$(FAIL)" + @echo "---------------PASSED---------------" + @echo "$(PASSED)" + @echo "\nDONE" + +$(PATHR)%.txt: $(PATHB)%.$(TARGET_EXTENSION) + -./$< > $@ 2>&1 + +$(PATHB)test_%.$(TARGET_EXTENSION): $(PATHO)test_%.o $(PATHO)test_%_Runner.o $(PATHO)%.o $(PATHU)unity.o #$(PATHD)test_%.d + $(LINK) -o $@ $^ + +$(PATHO)%.o: $(PATHTR)%.c + $(COMPILE) $(CFLAGS) $< -o $@ + +$(PATHO)%.o:: $(PATHT)%.c + $(COMPILE) $(CFLAGS) $< -o $@ + +$(PATHO)%.o:: $(PATHS)%.c + $(COMPILE) $(CFLAGS) $< -o $@ + +$(PATHO)%.o:: $(PATHL)%.c + $(COMPILE) $(CFLAGS) $< -o $@ + +$(PATHO)%.o:: $(PATHU)%.c $(PATHU)%.h + $(COMPILE) $(CFLAGS) $< -o $@ + +$(PATHD)%.d:: $(PATHT)%.c + $(DEPEND) $@ $< + +$(PATHTR)%.c: + ruby unity/auto/generate_test_runner.rb $(patsubst $(PATHTR)%_Runner.c,$(PATHT)%.c, $@) $@ + +$(PATHB): + $(MKDIR) $(PATHB) + +$(PATHD): + $(MKDIR) $(PATHD) + +$(PATHO): + $(MKDIR) $(PATHO) + +$(PATHR): + $(MKDIR) $(PATHR) -.PHONY: clean clean: - rm -f $(ALL_OBJ) $(TESTS) $(EXECUTABLES) + $(CLEANUP) $(PATHO)*.o + $(CLEANUP) $(PATHB)*.$(TARGET_EXTENSION) + $(CLEANUP) $(PATHR)*.txt -.PHONY: cleandep -cleandep: - rm -f $(DEPS_TRACK) \ No newline at end of file +.PRECIOUS: $(PATHB)test_%.$(TARGET_EXTENSION) +.PRECIOUS: $(PATHD)%.d +.PRECIOUS: $(PATHO)%.o +.PRECIOUS: $(PATHR)%.txt diff --git a/test/runners/test_circ_buff_Runner.c b/test/runners/test_circ_buff_Runner.c new file mode 100644 index 0000000..4d10e2b --- /dev/null +++ b/test/runners/test_circ_buff_Runner.c @@ -0,0 +1,92 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + UNITY_EXEC_TIME_START(); \ + if (TEST_PROTECT()) \ + { \ + setUp(); \ + TestFunc(); \ + } \ + if (TEST_PROTECT()) \ + { \ + tearDown(); \ + } \ + UNITY_EXEC_TIME_STOP(); \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#ifdef __WIN32__ +#define UNITY_INCLUDE_SETUP_STUBS +#endif +#include "unity.h" +#ifndef UNITY_EXCLUDE_SETJMP_H +#include +#endif +#include +#include "circ_buff.h" +#include +#include +#include + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_circ_buf_init(void); +extern void test_circ_buf_put(void); +extern void test_circ_buf_get(void); +extern void test_circ_buf_empty(void); +extern void test_circ_buf_full(void); +extern void test_circ_buf_capacity(void); +extern void test_circ_buf_size(void); +extern void test_circ_buf_reset(void); + + +/*=======Suite Setup=====*/ +static void suite_setup(void) +{ +#if defined(UNITY_WEAK_ATTRIBUTE) || defined(UNITY_WEAK_PRAGMA) + suiteSetUp(); +#endif +} + +/*=======Suite Teardown=====*/ +static int suite_teardown(int num_failures) +{ +#if defined(UNITY_WEAK_ATTRIBUTE) || defined(UNITY_WEAK_PRAGMA) + return suiteTearDown(num_failures); +#else + return num_failures; +#endif +} + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + tearDown(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + suite_setup(); + UnityBegin("test/test_circ_buff.c"); + RUN_TEST(test_circ_buf_init, 17); + RUN_TEST(test_circ_buf_put, 29); + RUN_TEST(test_circ_buf_get, 73); + RUN_TEST(test_circ_buf_empty, 110); + RUN_TEST(test_circ_buf_full, 142); + RUN_TEST(test_circ_buf_capacity, 164); + RUN_TEST(test_circ_buf_size, 191); + RUN_TEST(test_circ_buf_reset, 220); + + return suite_teardown(UnityEnd()); +} diff --git a/test/test_circ_buff.c b/test/test_circ_buff.c index 14fa640..d6f5db1 100644 --- a/test/test_circ_buff.c +++ b/test/test_circ_buff.c @@ -2,70 +2,241 @@ #include #include -#include "../lib/circ_buff.h" +#include "unity.h" +#include "circ_buff.h" #define BUFFER_SIZE 8 #define BUFFER_ELEMENT_SIZE 278 -void print_buff_status(cbuf_handle_t circ_buf); +void free_buffer(char** buffer) { + for(uint8_t i = 0; i < BUFFER_SIZE; ++i) { + free(buffer[i]); + } +} -int main(void) { - // Creates and initializes a buffer +void test_circ_buf_init(void) { char** buffer = (char **) malloc(BUFFER_SIZE * sizeof(char *)); for (uint8_t buff_el = 0; buff_el < BUFFER_SIZE; ++buff_el) { buffer[buff_el] = (char *) malloc(BUFFER_ELEMENT_SIZE * sizeof(char)); } - printf("===== C Circular Buffer Check\n\n"); + TEST_ASSERT_NOT_NULL(circ_buf_init(buffer, BUFFER_SIZE)); + + free_buffer(buffer); + free(buffer); +} + +void test_circ_buf_put(void) { + char** buffer = (char **) malloc(BUFFER_SIZE * sizeof(char *)); + for (uint8_t buff_el = 0; buff_el < BUFFER_SIZE; ++buff_el) { + buffer[buff_el] = (char *) malloc(BUFFER_ELEMENT_SIZE * sizeof(char)); + } cbuf_handle_t circ_buf = circ_buf_init(buffer, BUFFER_SIZE); + char* temp = (char *) malloc(BUFFER_ELEMENT_SIZE * sizeof(char)); + + for(uint8_t i = 0; i < (BUFFER_SIZE - 2); ++i) { + snprintf(temp, BUFFER_ELEMENT_SIZE, "string_%d", i); + + circ_buf_put(circ_buf, temp); + } - printf("Buffer initialized.\n"); - print_buff_status(circ_buf); + TEST_ASSERT_EQUAL_STRING_LEN("string_0", buffer[0], BUFFER_ELEMENT_SIZE); + TEST_ASSERT_EQUAL_STRING_LEN("string_1", buffer[1], BUFFER_ELEMENT_SIZE); + TEST_ASSERT_EQUAL_STRING_LEN("string_2", buffer[2], BUFFER_ELEMENT_SIZE); + TEST_ASSERT_EQUAL_STRING_LEN("string_3", buffer[3], BUFFER_ELEMENT_SIZE); + TEST_ASSERT_EQUAL_STRING_LEN("string_4", buffer[4], BUFFER_ELEMENT_SIZE); + TEST_ASSERT_EQUAL_STRING_LEN("string_5", buffer[5], BUFFER_ELEMENT_SIZE); - printf("\n===== Adding %d values\n", BUFFER_SIZE - 1); - for(uint8_t i = 0; i < (BUFFER_SIZE - 1); i++) { - char* temp = (char *) malloc(BUFFER_ELEMENT_SIZE * sizeof(char)); + for(uint8_t i = 0; i < BUFFER_SIZE; ++i) { snprintf(temp, BUFFER_ELEMENT_SIZE, "string_%d", i); circ_buf_put(circ_buf, temp); - printf("Added %u, Size now: %zu\n", i, circ_buf_size(circ_buf)); } - print_buff_status(circ_buf); + free(temp); - printf("\n===== Adding %d values\n", BUFFER_SIZE); - for(uint8_t i = 0; i < BUFFER_SIZE; i++) { - char* temp = (char *) malloc(BUFFER_ELEMENT_SIZE * sizeof(char)); - snprintf(temp, BUFFER_ELEMENT_SIZE, "string_%d", BUFFER_SIZE - 1 + i); + TEST_ASSERT_EQUAL_STRING_LEN("string_2", buffer[0], BUFFER_ELEMENT_SIZE); + TEST_ASSERT_EQUAL_STRING_LEN("string_3", buffer[1], BUFFER_ELEMENT_SIZE); + TEST_ASSERT_EQUAL_STRING_LEN("string_4", buffer[2], BUFFER_ELEMENT_SIZE); + TEST_ASSERT_EQUAL_STRING_LEN("string_5", buffer[3], BUFFER_ELEMENT_SIZE); + TEST_ASSERT_EQUAL_STRING_LEN("string_6", buffer[4], BUFFER_ELEMENT_SIZE); + TEST_ASSERT_EQUAL_STRING_LEN("string_7", buffer[5], BUFFER_ELEMENT_SIZE); + TEST_ASSERT_EQUAL_STRING_LEN("string_0", buffer[6], BUFFER_ELEMENT_SIZE); + TEST_ASSERT_EQUAL_STRING_LEN("string_1", buffer[7], BUFFER_ELEMENT_SIZE); + + circ_buf_free(circ_buf); + free_buffer(buffer); + free(buffer); +} + +void test_circ_buf_get(void) { + char** buffer = (char **) malloc(BUFFER_SIZE * sizeof(char *)); + for (uint8_t buff_el = 0; buff_el < BUFFER_SIZE; ++buff_el) { + buffer[buff_el] = (char *) malloc(BUFFER_ELEMENT_SIZE * sizeof(char)); + } + + cbuf_handle_t circ_buf = circ_buf_init(buffer, BUFFER_SIZE); + char* temp = (char *) malloc(BUFFER_ELEMENT_SIZE * sizeof(char)); + + for(uint8_t i = 0; i < (BUFFER_SIZE - 2); ++i) { + snprintf(temp, BUFFER_ELEMENT_SIZE, "string_%d", i); circ_buf_put(circ_buf, temp); - printf("Added %u, Size now: %zu\n", i, circ_buf_size(circ_buf)); } - print_buff_status(circ_buf); + free(temp); + + char* actual = (char *) malloc(BUFFER_ELEMENT_SIZE * sizeof(char)); + char* test_against = (char *) malloc(BUFFER_ELEMENT_SIZE * sizeof(char)); + + for(uint8_t i = 0; i < (BUFFER_SIZE - 2); ++i) { + circ_buf_get(circ_buf, actual); + snprintf(test_against, BUFFER_ELEMENT_SIZE, "string_%d", i); + + TEST_ASSERT_EQUAL_STRING_LEN(test_against, actual, BUFFER_ELEMENT_SIZE); + } + + free(actual); + free(test_against); + + circ_buf_free(circ_buf); + free_buffer(buffer); + free(buffer); +} + + + +void test_circ_buf_empty(void) { + char** buffer = (char **) malloc(BUFFER_SIZE * sizeof(char *)); + for (uint8_t buff_el = 0; buff_el < BUFFER_SIZE; ++buff_el) { + buffer[buff_el] = (char *) malloc(BUFFER_ELEMENT_SIZE * sizeof(char)); + } - printf("\n===== Reading back values:\n"); - while(!circ_buf_empty(circ_buf)) { - char* temp = (char *) malloc(BUFFER_ELEMENT_SIZE * sizeof(char)); + cbuf_handle_t circ_buf = circ_buf_init(buffer, BUFFER_SIZE); + + TEST_ASSERT_TRUE(circ_buf_empty(circ_buf)); + + for(uint8_t i = 0; i < BUFFER_SIZE; ++i) { + circ_buf_put(circ_buf, "Lorem ipsum"); + } + + TEST_ASSERT_FALSE(circ_buf_empty(circ_buf)); + + char* temp = (char *) malloc(BUFFER_ELEMENT_SIZE * sizeof(char)); + + for(uint8_t i = 0; i < BUFFER_SIZE; ++i) { circ_buf_get(circ_buf, temp); - printf("%s ", temp); } - printf("\n"); - print_buff_status(circ_buf); + free(temp); + + TEST_ASSERT_TRUE(circ_buf_empty(circ_buf)); + + circ_buf_free(circ_buf); + free_buffer(buffer); + free(buffer); +} + + +void test_circ_buf_full(void) { + char** buffer = (char **) malloc(BUFFER_SIZE * sizeof(char *)); + for (uint8_t buff_el = 0; buff_el < BUFFER_SIZE; ++buff_el) { + buffer[buff_el] = (char *) malloc(BUFFER_ELEMENT_SIZE * sizeof(char)); + } + + cbuf_handle_t circ_buf = circ_buf_init(buffer, BUFFER_SIZE); + + for(uint8_t i = 0; i < (BUFFER_SIZE - 1); ++i) { + circ_buf_put(circ_buf, "Lorem ipsum"); + TEST_ASSERT_FALSE(circ_buf_full(circ_buf)); + } - printf("\n===== Test done, cleaning up\n"); + circ_buf_put(circ_buf, "Lorem ipsum"); + TEST_ASSERT_TRUE(circ_buf_full(circ_buf)); + circ_buf_free(circ_buf); + free_buffer(buffer); free(buffer); +} + + +void test_circ_buf_capacity(void) { + char** buffer = (char **) malloc(BUFFER_SIZE * sizeof(char *)); + for (uint8_t buff_el = 0; buff_el < BUFFER_SIZE; ++buff_el) { + buffer[buff_el] = (char *) malloc(BUFFER_ELEMENT_SIZE * sizeof(char)); + } + + cbuf_handle_t circ_buf = circ_buf_init(buffer, BUFFER_SIZE); + + TEST_ASSERT_EQUAL_INT8(BUFFER_SIZE, circ_buf_capacity(circ_buf)); + + circ_buf_put(circ_buf, "Lorem ipsum"); + circ_buf_put(circ_buf, "Lorem ipsum"); + + TEST_ASSERT_EQUAL_INT8(BUFFER_SIZE, circ_buf_capacity(circ_buf)); + + char* temp = (char *) malloc(BUFFER_ELEMENT_SIZE * sizeof(char)); + circ_buf_get(circ_buf, temp); + free(temp); + + TEST_ASSERT_EQUAL_INT8(BUFFER_SIZE, circ_buf_capacity(circ_buf)); + circ_buf_free(circ_buf); + free_buffer(buffer); + free(buffer); +} + + +void test_circ_buf_size(void) { + char** buffer = (char **) malloc(BUFFER_SIZE * sizeof(char *)); + for (uint8_t buff_el = 0; buff_el < BUFFER_SIZE; ++buff_el) { + buffer[buff_el] = (char *) malloc(BUFFER_ELEMENT_SIZE * sizeof(char)); + } + + cbuf_handle_t circ_buf = circ_buf_init(buffer, BUFFER_SIZE); + + TEST_ASSERT_EQUAL_INT8(0, circ_buf_size(circ_buf)); + + for(uint8_t i = 0; i < BUFFER_SIZE; ++i) { + circ_buf_put(circ_buf, "Lorem ipsum"); + TEST_ASSERT_EQUAL_INT8(i + 1, circ_buf_size(circ_buf)); + } - return 0; + char* temp = (char *) malloc(BUFFER_ELEMENT_SIZE * sizeof(char)); + + for(uint8_t i = 0; i < BUFFER_SIZE; ++i) { + circ_buf_get(circ_buf, temp); + TEST_ASSERT_EQUAL_INT8(BUFFER_SIZE - i - 1, circ_buf_size(circ_buf)); + } + + free(temp); + + circ_buf_free(circ_buf); + free_buffer(buffer); + free(buffer); } -void print_buff_status(cbuf_handle_t circ_buf) { - printf("Full: %d, empty: %d, size: %zu\n", - circ_buf_full(circ_buf), - circ_buf_empty(circ_buf), - circ_buf_size(circ_buf)); -} \ No newline at end of file +void test_circ_buf_reset(void) { + char** buffer = (char **) malloc(BUFFER_SIZE * sizeof(char *)); + for (uint8_t buff_el = 0; buff_el < BUFFER_SIZE; ++buff_el) { + buffer[buff_el] = (char *) malloc(BUFFER_ELEMENT_SIZE * sizeof(char)); + } + + cbuf_handle_t circ_buf = circ_buf_init(buffer, BUFFER_SIZE); + + for(uint8_t i = 0; i < BUFFER_SIZE - 3; ++i) { + circ_buf_put(circ_buf, "Lorem ipsum"); + } + + circ_buf_reset(circ_buf); + + TEST_ASSERT_EQUAL_INT8(0, circ_buf_size(circ_buf)); + TEST_ASSERT_EQUAL_INT8(BUFFER_SIZE, circ_buf_capacity(circ_buf)); + TEST_ASSERT_TRUE(circ_buf_empty(circ_buf)); + TEST_ASSERT_FALSE(circ_buf_full(circ_buf)); + + circ_buf_free(circ_buf); + free_buffer(buffer); + free(buffer); +} diff --git a/unity/.editorconfig b/unity/.editorconfig new file mode 100644 index 0000000..7b7a47a --- /dev/null +++ b/unity/.editorconfig @@ -0,0 +1,27 @@ +############################################################################### +# Unity Project - A Test Framework for C +# .editorconfig - F. Zahn 2019 +############################################################################### + +# This is the topmost .editorconfig file +root = true + +# Settings that apply to all languages / files +[*] +charset = utf-8 +indent_size = 4 +indent_style = space +insert_final_newline = true +trim_trailing_whitespace = true + +[*.md] +trim_trailing_whitespace = false + +[*.txt] +trim_trailing_whitespace = false + +[*.rb] +indent_size = 2 + +[*.yml] +indent_size = 2 diff --git a/unity/.gitattributes b/unity/.gitattributes new file mode 100644 index 0000000..ad95226 --- /dev/null +++ b/unity/.gitattributes @@ -0,0 +1,30 @@ +* text=auto + +# These files are text and should be normalized (convert crlf to lf) +*.rb text +*.test text +*.c text +*.cpp text +*.h text +*.txt text +*.yml text +*.s79 text +*.bat text +*.xcl text +*.inc text +*.info text +*.md text +makefile text +rakefile text + + +#These files are binary and should not be normalized +*.doc binary +*.odt binary +*.pdf binary +*.ewd binary +*.eww binary +*.dni binary +*.wsdt binary +*.dbgdt binary +*.mac binary diff --git a/unity/.gitignore b/unity/.gitignore new file mode 100644 index 0000000..a383c3c --- /dev/null +++ b/unity/.gitignore @@ -0,0 +1,9 @@ +build/ +test/sandbox +.DS_Store +examples/example_1/test1.exe +examples/example_1/test2.exe +examples/example_2/all_tests.exe +examples/example_1/test1.out +examples/example_1/test2.out +examples/example_2/all_tests.out diff --git a/unity/.travis.yml b/unity/.travis.yml new file mode 100644 index 0000000..8d32264 --- /dev/null +++ b/unity/.travis.yml @@ -0,0 +1,29 @@ +language: c + +matrix: + include: + - os: osx + compiler: clang + osx_image: xcode7.3 + - os: linux + dist: trusty + compiler: gcc + +before_install: + - if [ "$TRAVIS_OS_NAME" == "osx" ]; then rvm install 2.3 && rvm use 2.3 && ruby -v; fi + - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo apt-get install --assume-yes --quiet gcc-multilib; fi +install: + - gem install rspec + - gem install rubocop -v 0.57.2 +script: + - cd test && rake ci + - make -s + - make -s DEBUG=-m32 #32-bit architecture with 64-bit support + - make -s DEBUG=-m32 UNITY_SUPPORT_64= #32-bit build without 64-bit types + - make -s UNITY_INCLUDE_DOUBLE= # without double + - cd ../extras/fixture/test && rake ci + - make -s default noStdlibMalloc + - make -s C89 + - cd ../../../examples/example_1 && make -s ci + - cd ../example_2 && make -s ci + - cd ../example_3 && rake diff --git a/unity/CMakeLists.txt b/unity/CMakeLists.txt new file mode 100644 index 0000000..0eddcd7 --- /dev/null +++ b/unity/CMakeLists.txt @@ -0,0 +1,70 @@ +##################################################### +# FILE NAME CMakeLists.txt # +# # +# WRITTEN BY Michael Brockus. # +# # +# PURPOSE contains CMake statements. # +# # +##################################################### +cmake_minimum_required(VERSION 3.13.2.0 FATAL_ERROR) + + + +# +# CMake: Declare project +# +project(unity LANGUAGES C DESCRIPTION "C Unit testing framework.") + + + +# +# CMake: Creation of library +# +add_library("unity" STATIC) + + + +# +# CMake: Adding source to target +# +target_sources("unity" PRIVATE "src/unity.c") + + + +# +# CMake: Including directories to target +# +target_include_directories("unity" + PUBLIC + "$" + "$" + + PRIVATE "src" +) + + + +# +# CMake: Give target an alias +# +add_library("unity::framework" ALIAS "unity") + + + +# +# CMake: export project +# +install(TARGETS "unity" EXPORT "unityConfig" + ARCHIVE DESTINATION "${CMAKE_CURRENT_SOURCE_DIR}/${CMAKE_INSTALL_LIBDIR}" + LIBRARY DESTINATION "${CMAKE_CURRENT_SOURCE_DIR}/${CMAKE_INSTALL_LIBDIR}" + RUNTIME DESTINATION "${CMAKE_CURRENT_SOURCE_DIR}/${CMAKE_INSTALL_BINDIR}" + + INCLUDES DESTINATION "${CMAKE_INSTALL_LIBDIR}" +) + +install(DIRECTORY src/ DESTINATION src) + +install(EXPORT unityConfig DESTINATION share/unityConfig/cmake) + +# This makes the project importable from the build directory +export(TARGETS unity FILE unityConfig.cmake) diff --git a/unity/LICENSE.txt b/unity/LICENSE.txt new file mode 100644 index 0000000..d66fba5 --- /dev/null +++ b/unity/LICENSE.txt @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2007-14 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/unity/README.md b/unity/README.md new file mode 100644 index 0000000..983f33d --- /dev/null +++ b/unity/README.md @@ -0,0 +1,191 @@ +Unity Test API +============== + +[![Unity Build Status](https://api.travis-ci.org/ThrowTheSwitch/Unity.png?branch=master)](https://travis-ci.org/ThrowTheSwitch/Unity) +__Copyright (c) 2007 - 2019 Unity Project by Mike Karlesky, Mark VanderVoord, and Greg Williams__ + +Getting Started +=============== +The [docs](docs/) folder contains a [getting started guide](docs/UnityGettingStartedGuide.md) +and much more tips about using Unity. + +Unity Assertion Summary +======================= +For the full list, see [UnityAssertionsReference.md](docs/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, +like when comparing arrays, 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) + +Asserts that the actual value is 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. + +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. + diff --git a/unity/auto/colour_prompt.rb b/unity/auto/colour_prompt.rb new file mode 100644 index 0000000..bf09d02 --- /dev/null +++ b/unity/auto/colour_prompt.rb @@ -0,0 +1,118 @@ +# ========================================== +# Unity Project - A Test Framework for C +# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams +# [Released under MIT License. Please refer to license.txt for details] +# ========================================== + +if RUBY_PLATFORM =~ /(win|w)32$/ + begin + require 'Win32API' + rescue LoadError + puts 'ERROR! "Win32API" library not found' + puts '"Win32API" is required for colour on a windows machine' + puts ' try => "gem install Win32API" on the command line' + puts + end + # puts + # puts 'Windows Environment Detected...' + # puts 'Win32API Library Found.' + # puts +end + +class ColourCommandLine + def initialize + return unless RUBY_PLATFORM =~ /(win|w)32$/ + get_std_handle = Win32API.new('kernel32', 'GetStdHandle', ['L'], 'L') + @set_console_txt_attrb = + Win32API.new('kernel32', 'SetConsoleTextAttribute', %w[L N], 'I') + @hout = get_std_handle.call(-11) + end + + def change_to(new_colour) + if RUBY_PLATFORM =~ /(win|w)32$/ + @set_console_txt_attrb.call(@hout, win32_colour(new_colour)) + else + "\033[30;#{posix_colour(new_colour)};22m" + end + end + + def win32_colour(colour) + case colour + when :black then 0 + when :dark_blue then 1 + when :dark_green then 2 + when :dark_cyan then 3 + when :dark_red then 4 + when :dark_purple then 5 + when :dark_yellow, :narrative then 6 + when :default_white, :default, :dark_white then 7 + when :silver then 8 + when :blue then 9 + when :green, :success then 10 + when :cyan, :output then 11 + when :red, :failure then 12 + when :purple then 13 + when :yellow then 14 + when :white then 15 + else + 0 + end + end + + def posix_colour(colour) + # ANSI Escape Codes - Foreground colors + # | Code | Color | + # | 39 | Default foreground color | + # | 30 | Black | + # | 31 | Red | + # | 32 | Green | + # | 33 | Yellow | + # | 34 | Blue | + # | 35 | Magenta | + # | 36 | Cyan | + # | 37 | Light gray | + # | 90 | Dark gray | + # | 91 | Light red | + # | 92 | Light green | + # | 93 | Light yellow | + # | 94 | Light blue | + # | 95 | Light magenta | + # | 96 | Light cyan | + # | 97 | White | + + case colour + when :black then 30 + when :red, :failure then 31 + when :green, :success then 32 + when :yellow then 33 + when :blue, :narrative then 34 + when :purple, :magenta then 35 + when :cyan, :output then 36 + when :white, :default_white then 37 + when :default then 39 + else + 39 + end + end + + def out_c(mode, colour, str) + case RUBY_PLATFORM + when /(win|w)32$/ + change_to(colour) + $stdout.puts str if mode == :puts + $stdout.print str if mode == :print + change_to(:default_white) + else + $stdout.puts("#{change_to(colour)}#{str}\033[0m") if mode == :puts + $stdout.print("#{change_to(colour)}#{str}\033[0m") if mode == :print + end + end +end + +def colour_puts(role, str) + ColourCommandLine.new.out_c(:puts, role, str) +end + +def colour_print(role, str) + ColourCommandLine.new.out_c(:print, role, str) +end diff --git a/unity/auto/colour_reporter.rb b/unity/auto/colour_reporter.rb new file mode 100644 index 0000000..1c3bc21 --- /dev/null +++ b/unity/auto/colour_reporter.rb @@ -0,0 +1,39 @@ +# ========================================== +# Unity Project - A Test Framework for C +# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams +# [Released under MIT License. Please refer to license.txt for details] +# ========================================== + +require_relative 'colour_prompt' + +$colour_output = true + +def report(message) + if !$colour_output + $stdout.puts(message) + else + message = message.join('\n') if message.class == Array + message.each_line do |line| + line.chomp! + colour = case line + when /(?:total\s+)?tests:?\s+(\d+)\s+(?:total\s+)?failures:?\s+\d+\s+Ignored:?/i + Regexp.last_match(1).to_i.zero? ? :green : :red + when /PASS/ + :green + when /^OK$/ + :green + when /(?:FAIL|ERROR)/ + :red + when /IGNORE/ + :yellow + when /^(?:Creating|Compiling|Linking)/ + :white + else + :silver + end + colour_puts(colour, line) + end + end + $stdout.flush + $stderr.flush +end diff --git a/unity/auto/generate_config.yml b/unity/auto/generate_config.yml new file mode 100644 index 0000000..4a5e474 --- /dev/null +++ b/unity/auto/generate_config.yml @@ -0,0 +1,36 @@ +#this is a sample configuration file for generate_module +#you would use it by calling generate_module with the -ygenerate_config.yml option +#files like this are useful for customizing generate_module to your environment +:generate_module: + :defaults: + #these defaults are used in place of any missing options at the command line + :path_src: ../src/ + :path_inc: ../src/ + :path_tst: ../test/ + :update_svn: true + :includes: + #use [] for no additional includes, otherwise list the includes on separate lines + :src: + - Defs.h + - Board.h + :inc: [] + :tst: + - Defs.h + - Board.h + - Exception.h + :boilerplates: + #these are inserted at the top of generated files. + #just comment out or remove if not desired. + #use %1$s where you would like the file name to appear (path/extension not included) + :src: | + //------------------------------------------- + // %1$s.c + //------------------------------------------- + :inc: | + //------------------------------------------- + // %1$s.h + //------------------------------------------- + :tst: | + //------------------------------------------- + // Test%1$s.c : Units tests for %1$s.c + //------------------------------------------- diff --git a/unity/auto/generate_module.rb b/unity/auto/generate_module.rb new file mode 100644 index 0000000..92aa514 --- /dev/null +++ b/unity/auto/generate_module.rb @@ -0,0 +1,306 @@ +# ========================================== +# Unity Project - A Test Framework for C +# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams +# [Released under MIT License. Please refer to license.txt for details] +# ========================================== + +# This script creates all the files with start code necessary for a new module. +# A simple module only requires a source file, header file, and test file. +# Triad modules require a source, header, and test file for each triad type (like model, conductor, and hardware). + +require 'rubygems' +require 'fileutils' +require 'pathname' + +# TEMPLATE_TST +TEMPLATE_TST ||= '#include "unity.h" +%2$s#include "%1$s.h" + +void setUp(void) +{ +} + +void tearDown(void) +{ +} + +void test_%1$s_NeedToImplement(void) +{ + TEST_IGNORE_MESSAGE("Need to Implement %1$s"); +} +'.freeze + +# TEMPLATE_SRC +TEMPLATE_SRC ||= '%2$s#include "%1$s.h" +'.freeze + +# TEMPLATE_INC +TEMPLATE_INC ||= '#ifndef %3$s_H +#define %3$s_H +%2$s + +#endif // %3$s_H +'.freeze + +class UnityModuleGenerator + ############################ + def initialize(options = nil) + @options = UnityModuleGenerator.default_options + case options + when NilClass then @options + when String then @options.merge!(UnityModuleGenerator.grab_config(options)) + when Hash then @options.merge!(options) + else raise 'If you specify arguments, it should be a filename or a hash of options' + end + + # Create default file paths if none were provided + @options[:path_src] = "#{__dir__}/../src/" if @options[:path_src].nil? + @options[:path_inc] = @options[:path_src] if @options[:path_inc].nil? + @options[:path_tst] = "#{__dir__}/../test/" if @options[:path_tst].nil? + @options[:path_src] += '/' unless @options[:path_src][-1] == 47 + @options[:path_inc] += '/' unless @options[:path_inc][-1] == 47 + @options[:path_tst] += '/' unless @options[:path_tst][-1] == 47 + + # Built in patterns + @patterns = { + 'src' => { + '' => { inc: [] } + }, + 'test' => { + '' => { inc: [] } + }, + 'dh' => { + 'Driver' => { inc: [create_filename('%1$s', 'Hardware.h')] }, + 'Hardware' => { inc: [] } + }, + 'dih' => { + 'Driver' => { inc: [create_filename('%1$s', 'Hardware.h'), create_filename('%1$s', 'Interrupt.h')] }, + 'Interrupt' => { inc: [create_filename('%1$s', 'Hardware.h')] }, + 'Hardware' => { inc: [] } + }, + 'mch' => { + 'Model' => { inc: [] }, + 'Conductor' => { inc: [create_filename('%1$s', 'Model.h'), create_filename('%1$s', 'Hardware.h')] }, + 'Hardware' => { inc: [] } + }, + 'mvp' => { + 'Model' => { inc: [] }, + 'Presenter' => { inc: [create_filename('%1$s', 'Model.h'), create_filename('%1$s', 'View.h')] }, + 'View' => { inc: [] } + } + } + end + + ############################ + def self.default_options + { + pattern: 'src', + includes: { + src: [], + inc: [], + tst: [] + }, + update_svn: false, + boilerplates: {}, + test_prefix: 'Test', + mock_prefix: 'Mock' + } + end + + ############################ + def self.grab_config(config_file) + options = default_options + unless config_file.nil? || config_file.empty? + require 'yaml' + yaml_guts = YAML.load_file(config_file) + options.merge!(yaml_guts[:unity] || yaml_guts[:cmock]) + raise "No :unity or :cmock section found in #{config_file}" unless options + end + options + end + + ############################ + def files_to_operate_on(module_name, pattern = nil) + # strip any leading path information from the module name and save for later + subfolder = File.dirname(module_name) + module_name = File.basename(module_name) + + # create triad definition + prefix = @options[:test_prefix] || 'Test' + triad = [{ ext: '.c', path: @options[:path_src], prefix: '', template: TEMPLATE_SRC, inc: :src, boilerplate: @options[:boilerplates][:src] }, + { ext: '.h', path: @options[:path_inc], prefix: '', template: TEMPLATE_INC, inc: :inc, boilerplate: @options[:boilerplates][:inc] }, + { ext: '.c', path: @options[:path_tst], prefix: prefix, template: TEMPLATE_TST, inc: :tst, boilerplate: @options[:boilerplates][:tst] }] + + # prepare the pattern for use + pattern = (pattern || @options[:pattern] || 'src').downcase + patterns = @patterns[pattern] + raise "ERROR: The design pattern '#{pattern}' specified isn't one that I recognize!" if patterns.nil? + + # single file patterns (currently just 'test') can reject the other parts of the triad + triad.select! { |v| v[:inc] == :tst } if pattern == 'test' + + # Assemble the path/names of the files we need to work with. + files = [] + triad.each do |cfg| + patterns.each_pair do |pattern_file, pattern_traits| + submodule_name = create_filename(module_name, pattern_file) + filename = cfg[:prefix] + submodule_name + cfg[:ext] + files << { + path: (Pathname.new("#{cfg[:path]}#{subfolder}") + filename).cleanpath, + name: submodule_name, + template: cfg[:template], + boilerplate: cfg[:boilerplate], + includes: case (cfg[:inc]) + when :src then (@options[:includes][:src] || []) | (pattern_traits[:inc].map { |f| format(f, module_name) }) + when :inc then (@options[:includes][:inc] || []) + when :tst then (@options[:includes][:tst] || []) | (pattern_traits[:inc].map { |f| format("#{@options[:mock_prefix]}#{f}", module_name) }) + end + } + end + end + + files + end + + ############################ + def create_filename(part1, part2 = '') + if part2.empty? + case (@options[:naming]) + when 'bumpy' then part1 + when 'camel' then part1 + when 'snake' then part1.downcase + when 'caps' then part1.upcase + else part1 + end + else + case (@options[:naming]) + when 'bumpy' then part1 + part2 + when 'camel' then part1 + part2 + when 'snake' then part1.downcase + '_' + part2.downcase + when 'caps' then part1.upcase + '_' + part2.upcase + else part1 + '_' + part2 + end + end + end + + ############################ + def generate(module_name, pattern = nil) + files = files_to_operate_on(module_name, pattern) + + # Abort if all of the module files already exist + all_files_exist = true + files.each do |file| + all_files_exist = false unless File.exist?(file[:path]) + end + raise "ERROR: File #{files[0][:name]} already exists. Exiting." if all_files_exist + + # Create Source Modules + files.each_with_index do |file, _i| + # If this file already exists, don't overwrite it. + if File.exist?(file[:path]) + puts "File #{file[:path]} already exists!" + next + end + # Create the path first if necessary. + FileUtils.mkdir_p(File.dirname(file[:path]), verbose: false) + File.open(file[:path], 'w') do |f| + f.write("#{file[:boilerplate]}\n" % [file[:name]]) unless file[:boilerplate].nil? + f.write(file[:template] % [file[:name], + file[:includes].map { |ff| "#include \"#{ff}\"\n" }.join, + file[:name].upcase]) + end + if @options[:update_svn] + `svn add \"#{file[:path]}\"` + if $!.exitstatus.zero? + puts "File #{file[:path]} created and added to source control" + else + puts "File #{file[:path]} created but FAILED adding to source control!" + end + else + puts "File #{file[:path]} created" + end + end + puts 'Generate Complete' + end + + ############################ + def destroy(module_name, pattern = nil) + files_to_operate_on(module_name, pattern).each do |filespec| + file = filespec[:path] + if File.exist?(file) + if @options[:update_svn] + `svn delete \"#{file}\" --force` + puts "File #{file} deleted and removed from source control" + else + FileUtils.remove(file) + puts "File #{file} deleted" + end + else + puts "File #{file} does not exist so cannot be removed." + end + end + puts 'Destroy Complete' + end +end + +############################ +# Handle As Command Line If Called That Way +if $0 == __FILE__ + destroy = false + options = {} + module_name = nil + + # Parse the command line parameters. + ARGV.each do |arg| + case arg + when /^-d/ then destroy = true + when /^-u/ then options[:update_svn] = true + when /^-p\"?(\w+)\"?/ then options[:pattern] = Regexp.last_match(1) + when /^-s\"?(.+)\"?/ then options[:path_src] = Regexp.last_match(1) + when /^-i\"?(.+)\"?/ then options[:path_inc] = Regexp.last_match(1) + when /^-t\"?(.+)\"?/ then options[:path_tst] = Regexp.last_match(1) + when /^-n\"?(.+)\"?/ then options[:naming] = Regexp.last_match(1) + when /^-y\"?(.+)\"?/ then options = UnityModuleGenerator.grab_config(Regexp.last_match(1)) + when /^(\w+)/ + raise "ERROR: You can't have more than one Module name specified!" unless module_name.nil? + module_name = arg + when /^-(h|-help)/ + ARGV = [].freeze + else + raise "ERROR: Unknown option specified '#{arg}'" + end + end + + unless ARGV[0] + puts ["\nGENERATE MODULE\n-------- ------", + "\nUsage: ruby generate_module [options] module_name", + " -i\"include\" sets the path to output headers to 'include' (DEFAULT ../src)", + " -s\"../src\" sets the path to output source to '../src' (DEFAULT ../src)", + " -t\"C:/test\" sets the path to output source to 'C:/test' (DEFAULT ../test)", + ' -p"MCH" sets the output pattern to MCH.', + ' dh - driver hardware.', + ' dih - driver interrupt hardware.', + ' mch - model conductor hardware.', + ' mvp - model view presenter.', + ' src - just a source module, header and test. (DEFAULT)', + ' test - just a test file.', + ' -d destroy module instead of creating it.', + ' -n"camel" sets the file naming convention.', + ' bumpy - BumpyCaseFilenames.', + ' camel - camelCaseFilenames.', + ' snake - snake_case_filenames.', + ' caps - CAPS_CASE_FILENAMES.', + ' -u update subversion too (requires subversion command line)', + ' -y"my.yml" selects a different yaml config file for module generation', + ''].join("\n") + exit + end + + raise 'ERROR: You must have a Module name specified! (use option -h for help)' if module_name.nil? + if destroy + UnityModuleGenerator.new(options).destroy(module_name) + else + UnityModuleGenerator.new(options).generate(module_name) + end + +end diff --git a/unity/auto/generate_test_runner.rb b/unity/auto/generate_test_runner.rb new file mode 100644 index 0000000..66e0b06 --- /dev/null +++ b/unity/auto/generate_test_runner.rb @@ -0,0 +1,475 @@ +# ========================================== +# Unity Project - A Test Framework for C +# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams +# [Released under MIT License. Please refer to license.txt for details] +# ========================================== + +class UnityTestRunnerGenerator + def initialize(options = nil) + @options = UnityTestRunnerGenerator.default_options + case options + when NilClass then @options + when String then @options.merge!(UnityTestRunnerGenerator.grab_config(options)) + when Hash then @options.merge!(options) + else raise 'If you specify arguments, it should be a filename or a hash of options' + end + require_relative 'type_sanitizer' + end + + def self.default_options + { + includes: [], + defines: [], + plugins: [], + framework: :unity, + test_prefix: 'test|spec|should', + mock_prefix: 'Mock', + mock_suffix: '', + setup_name: 'setUp', + teardown_name: 'tearDown', + test_reset_name: 'resetTest', + main_name: 'main', # set to :auto to automatically generate each time + main_export_decl: '', + cmdline_args: false, + use_param_tests: false + } + end + + def self.grab_config(config_file) + options = default_options + unless config_file.nil? || config_file.empty? + require 'yaml' + yaml_guts = YAML.load_file(config_file) + options.merge!(yaml_guts[:unity] || yaml_guts[:cmock]) + raise "No :unity or :cmock section found in #{config_file}" unless options + end + options + end + + def run(input_file, output_file, options = nil) + @options.merge!(options) unless options.nil? + + # pull required data from source file + source = File.read(input_file) + source = source.force_encoding('ISO-8859-1').encode('utf-8', replace: nil) + tests = find_tests(source) + headers = find_includes(source) + testfile_includes = (headers[:local] + headers[:system]) + used_mocks = find_mocks(testfile_includes) + testfile_includes = (testfile_includes - used_mocks) + testfile_includes.delete_if { |inc| inc =~ /(unity|cmock)/ } + + # build runner file + generate(input_file, output_file, tests, used_mocks, testfile_includes) + + # determine which files were used to return them + all_files_used = [input_file, output_file] + all_files_used += testfile_includes.map { |filename| filename + '.c' } unless testfile_includes.empty? + all_files_used += @options[:includes] unless @options[:includes].empty? + all_files_used += headers[:linkonly] unless headers[:linkonly].empty? + all_files_used.uniq + end + + def generate(input_file, output_file, tests, used_mocks, testfile_includes) + File.open(output_file, 'w') do |output| + create_header(output, used_mocks, testfile_includes) + create_externs(output, tests, used_mocks) + create_mock_management(output, used_mocks) + create_suite_setup(output) + create_suite_teardown(output) + create_reset(output, used_mocks) + create_main(output, input_file, tests, used_mocks) + end + + return unless @options[:header_file] && !@options[:header_file].empty? + + File.open(@options[:header_file], 'w') do |output| + create_h_file(output, @options[:header_file], tests, testfile_includes, used_mocks) + end + end + + def find_tests(source) + tests_and_line_numbers = [] + + # contains characters which will be substituted from within strings, doing + # this prevents these characters from interferring with scrubbers + # @ is not a valid C character, so there should be no clashes with files genuinely containing these markers + substring_subs = { '{' => '@co@', '}' => '@cc@', ';' => '@ss@', '/' => '@fs@' } + substring_re = Regexp.union(substring_subs.keys) + substring_unsubs = substring_subs.invert # the inverse map will be used to fix the strings afterwords + substring_unsubs['@quote@'] = '\\"' + substring_unsubs['@apos@'] = '\\\'' + substring_unre = Regexp.union(substring_unsubs.keys) + source_scrubbed = source.clone + source_scrubbed = source_scrubbed.gsub(/\\"/, '@quote@') # hide escaped quotes to allow capture of the full string/char + source_scrubbed = source_scrubbed.gsub(/\\'/, '@apos@') # hide escaped apostrophes to allow capture of the full string/char + source_scrubbed = source_scrubbed.gsub(/("[^"\n]*")|('[^'\n]*')/) { |s| s.gsub(substring_re, substring_subs) } # temporarily hide problematic + # characters within strings + source_scrubbed = source_scrubbed.gsub(/\/\/.*$/, '') # remove line comments + source_scrubbed = source_scrubbed.gsub(/\/\*.*?\*\//m, '') # remove block comments + lines = source_scrubbed.split(/(^\s*\#.*$) # Treat preprocessor directives as a logical line + | (;|\{|\}) /x) # Match ;, {, and } as end of lines + .map { |line| line.gsub(substring_unre, substring_unsubs) } # unhide the problematic characters previously removed + + lines.each_with_index do |line, _index| + # find tests + next unless line =~ /^((?:\s*TEST_CASE\s*\(.*?\)\s*)*)\s*void\s+((?:#{@options[:test_prefix]}).*)\s*\(\s*(.*)\s*\)/m + arguments = Regexp.last_match(1) + name = Regexp.last_match(2) + call = Regexp.last_match(3) + params = Regexp.last_match(4) + args = nil + if @options[:use_param_tests] && !arguments.empty? + args = [] + arguments.scan(/\s*TEST_CASE\s*\((.*)\)\s*$/) { |a| args << a[0] } + end + tests_and_line_numbers << { test: name, args: args, call: call, params: params, line_number: 0 } + end + tests_and_line_numbers.uniq! { |v| v[:test] } + + # determine line numbers and create tests to run + source_lines = source.split("\n") + source_index = 0 + tests_and_line_numbers.size.times do |i| + source_lines[source_index..-1].each_with_index do |line, index| + next unless line =~ /\s+#{tests_and_line_numbers[i][:test]}(?:\s|\()/ + source_index += index + tests_and_line_numbers[i][:line_number] = source_index + 1 + break + end + end + + tests_and_line_numbers + end + + def find_includes(source) + # remove comments (block and line, in three steps to ensure correct precedence) + source.gsub!(/\/\/(?:.+\/\*|\*(?:$|[^\/])).*$/, '') # remove line comments that comment out the start of blocks + source.gsub!(/\/\*.*?\*\//m, '') # remove block comments + source.gsub!(/\/\/.*$/, '') # remove line comments (all that remain) + + # parse out includes + includes = { + local: source.scan(/^\s*#include\s+\"\s*(.+)\.[hH]\s*\"/).flatten, + system: source.scan(/^\s*#include\s+<\s*(.+)\s*>/).flatten.map { |inc| "<#{inc}>" }, + linkonly: source.scan(/^TEST_FILE\(\s*\"\s*(.+)\.[cC]\w*\s*\"/).flatten + } + includes + end + + def find_mocks(includes) + mock_headers = [] + includes.each do |include_path| + include_file = File.basename(include_path) + mock_headers << include_path if include_file =~ /^#{@options[:mock_prefix]}.*#{@options[:mock_suffix]}$/i + end + mock_headers + end + + def create_header(output, mocks, testfile_includes = []) + output.puts('/* AUTOGENERATED FILE. DO NOT EDIT. */') + create_runtest(output, mocks) + output.puts("\n/*=======Automagically Detected Files To Include=====*/") + output.puts('#ifdef __WIN32__') + output.puts('#define UNITY_INCLUDE_SETUP_STUBS') + output.puts('#endif') + output.puts("#include \"#{@options[:framework]}.h\"") + output.puts('#include "cmock.h"') unless mocks.empty? + output.puts('#ifndef UNITY_EXCLUDE_SETJMP_H') + output.puts('#include ') + output.puts('#endif') + output.puts('#include ') + if @options[:defines] && !@options[:defines].empty? + @options[:defines].each { |d| output.puts("#ifndef #{d}\n#define #{d}\n#endif /* #{d} */") } + end + if @options[:header_file] && !@options[:header_file].empty? + output.puts("#include \"#{File.basename(@options[:header_file])}\"") + else + @options[:includes].flatten.uniq.compact.each do |inc| + output.puts("#include #{inc.include?('<') ? inc : "\"#{inc.gsub('.h', '')}.h\""}") + end + testfile_includes.each do |inc| + output.puts("#include #{inc.include?('<') ? inc : "\"#{inc.gsub('.h', '')}.h\""}") + end + end + mocks.each do |mock| + output.puts("#include \"#{mock.gsub('.h', '')}.h\"") + end + output.puts('#include "CException.h"') if @options[:plugins].include?(:cexception) + + return unless @options[:enforce_strict_ordering] + + output.puts('') + output.puts('int GlobalExpectCount;') + output.puts('int GlobalVerifyOrder;') + output.puts('char* GlobalOrderError;') + end + + def create_externs(output, tests, _mocks) + output.puts("\n/*=======External Functions This Runner Calls=====*/") + output.puts("extern void #{@options[:setup_name]}(void);") + output.puts("extern void #{@options[:teardown_name]}(void);") + output.puts("\n#ifdef __cplusplus\nextern \"C\"\n{\n#endif") if @options[:externc] + tests.each do |test| + output.puts("extern void #{test[:test]}(#{test[:call] || 'void'});") + end + output.puts("#ifdef __cplusplus\n}\n#endif") if @options[:externc] + output.puts('') + end + + def create_mock_management(output, mock_headers) + return if mock_headers.empty? + + output.puts("\n/*=======Mock Management=====*/") + output.puts('static void CMock_Init(void)') + output.puts('{') + + if @options[:enforce_strict_ordering] + output.puts(' GlobalExpectCount = 0;') + output.puts(' GlobalVerifyOrder = 0;') + output.puts(' GlobalOrderError = NULL;') + end + + mocks = mock_headers.map { |mock| File.basename(mock) } + mocks.each do |mock| + mock_clean = TypeSanitizer.sanitize_c_identifier(mock) + output.puts(" #{mock_clean}_Init();") + end + output.puts("}\n") + + output.puts('static void CMock_Verify(void)') + output.puts('{') + mocks.each do |mock| + mock_clean = TypeSanitizer.sanitize_c_identifier(mock) + output.puts(" #{mock_clean}_Verify();") + end + output.puts("}\n") + + output.puts('static void CMock_Destroy(void)') + output.puts('{') + mocks.each do |mock| + mock_clean = TypeSanitizer.sanitize_c_identifier(mock) + output.puts(" #{mock_clean}_Destroy();") + end + output.puts("}\n") + end + + def create_suite_setup(output) + output.puts("\n/*=======Suite Setup=====*/") + output.puts('static void suite_setup(void)') + output.puts('{') + if @options[:suite_setup].nil? + # New style, call suiteSetUp() if we can use weak symbols + output.puts('#if defined(UNITY_WEAK_ATTRIBUTE) || defined(UNITY_WEAK_PRAGMA)') + output.puts(' suiteSetUp();') + output.puts('#endif') + else + # Old style, C code embedded in the :suite_setup option + output.puts(@options[:suite_setup]) + end + output.puts('}') + end + + def create_suite_teardown(output) + output.puts("\n/*=======Suite Teardown=====*/") + output.puts('static int suite_teardown(int num_failures)') + output.puts('{') + if @options[:suite_teardown].nil? + # New style, call suiteTearDown() if we can use weak symbols + output.puts('#if defined(UNITY_WEAK_ATTRIBUTE) || defined(UNITY_WEAK_PRAGMA)') + output.puts(' return suiteTearDown(num_failures);') + output.puts('#else') + output.puts(' return num_failures;') + output.puts('#endif') + else + # Old style, C code embedded in the :suite_teardown option + output.puts(@options[:suite_teardown]) + end + output.puts('}') + end + + def create_runtest(output, used_mocks) + cexception = @options[:plugins].include? :cexception + va_args1 = @options[:use_param_tests] ? ', ...' : '' + va_args2 = @options[:use_param_tests] ? '__VA_ARGS__' : '' + output.puts("\n/*=======Test Runner Used To Run Each Test Below=====*/") + output.puts('#define RUN_TEST_NO_ARGS') if @options[:use_param_tests] + output.puts("#define RUN_TEST(TestFunc, TestLineNum#{va_args1}) \\") + output.puts('{ \\') + output.puts(" Unity.CurrentTestName = #TestFunc#{va_args2.empty? ? '' : " \"(\" ##{va_args2} \")\""}; \\") + output.puts(' Unity.CurrentTestLineNumber = TestLineNum; \\') + output.puts(' if (UnityTestMatches()) { \\') if @options[:cmdline_args] + output.puts(' Unity.NumberOfTests++; \\') + output.puts(' UNITY_EXEC_TIME_START(); \\') + output.puts(' CMock_Init(); \\') unless used_mocks.empty? + output.puts(' UNITY_CLR_DETAILS(); \\') unless used_mocks.empty? + output.puts(' if (TEST_PROTECT()) \\') + output.puts(' { \\') + output.puts(' CEXCEPTION_T e; \\') if cexception + output.puts(' Try { \\') if cexception + output.puts(" #{@options[:setup_name]}(); \\") + output.puts(" TestFunc(#{va_args2}); \\") + output.puts(' } Catch(e) { TEST_ASSERT_EQUAL_HEX32_MESSAGE(CEXCEPTION_NONE, e, "Unhandled Exception!"); } \\') if cexception + output.puts(' } \\') + output.puts(' if (TEST_PROTECT()) \\') + output.puts(' { \\') + output.puts(" #{@options[:teardown_name]}(); \\") + output.puts(' CMock_Verify(); \\') unless used_mocks.empty? + output.puts(' } \\') + output.puts(' CMock_Destroy(); \\') unless used_mocks.empty? + output.puts(' UNITY_EXEC_TIME_STOP(); \\') + output.puts(' UnityConcludeTest(); \\') + output.puts(' } \\') if @options[:cmdline_args] + output.puts("}\n") + end + + def create_reset(output, used_mocks) + output.puts("\n/*=======Test Reset Option=====*/") + output.puts("void #{@options[:test_reset_name]}(void);") + output.puts("void #{@options[:test_reset_name]}(void)") + output.puts('{') + output.puts(' CMock_Verify();') unless used_mocks.empty? + output.puts(' CMock_Destroy();') unless used_mocks.empty? + output.puts(" #{@options[:teardown_name]}();") + output.puts(' CMock_Init();') unless used_mocks.empty? + output.puts(" #{@options[:setup_name]}();") + output.puts('}') + end + + def create_main(output, filename, tests, used_mocks) + output.puts("\n\n/*=======MAIN=====*/") + main_name = @options[:main_name].to_sym == :auto ? "main_#{filename.gsub('.c', '')}" : (@options[:main_name]).to_s + if @options[:cmdline_args] + if main_name != 'main' + output.puts("#{@options[:main_export_decl]} int #{main_name}(int argc, char** argv);") + end + output.puts("#{@options[:main_export_decl]} int #{main_name}(int argc, char** argv)") + output.puts('{') + output.puts(' int parse_status = UnityParseOptions(argc, argv);') + output.puts(' if (parse_status != 0)') + output.puts(' {') + output.puts(' if (parse_status < 0)') + output.puts(' {') + output.puts(" UnityPrint(\"#{filename.gsub('.c', '')}.\");") + output.puts(' UNITY_PRINT_EOL();') + if @options[:use_param_tests] + tests.each do |test| + if test[:args].nil? || test[:args].empty? + output.puts(" UnityPrint(\" #{test[:test]}(RUN_TEST_NO_ARGS)\");") + output.puts(' UNITY_PRINT_EOL();') + else + test[:args].each do |args| + output.puts(" UnityPrint(\" #{test[:test]}(#{args})\");") + output.puts(' UNITY_PRINT_EOL();') + end + end + end + else + tests.each { |test| output.puts(" UnityPrint(\" #{test[:test]}\");\n UNITY_PRINT_EOL();") } + end + output.puts(' return 0;') + output.puts(' }') + output.puts(' return parse_status;') + output.puts(' }') + else + if main_name != 'main' + output.puts("#{@options[:main_export_decl]} int #{main_name}(void);") + end + output.puts("int #{main_name}(void)") + output.puts('{') + end + output.puts(' suite_setup();') + output.puts(" UnityBegin(\"#{filename.gsub(/\\/, '\\\\\\')}\");") + if @options[:use_param_tests] + tests.each do |test| + if test[:args].nil? || test[:args].empty? + output.puts(" RUN_TEST(#{test[:test]}, #{test[:line_number]}, RUN_TEST_NO_ARGS);") + else + test[:args].each { |args| output.puts(" RUN_TEST(#{test[:test]}, #{test[:line_number]}, #{args});") } + end + end + else + tests.each { |test| output.puts(" RUN_TEST(#{test[:test]}, #{test[:line_number]});") } + end + output.puts + output.puts(' CMock_Guts_MemFreeFinal();') unless used_mocks.empty? + output.puts(' return suite_teardown(UnityEnd());') + output.puts('}') + end + + def create_h_file(output, filename, tests, testfile_includes, used_mocks) + filename = File.basename(filename).gsub(/[-\/\\\.\,\s]/, '_').upcase + output.puts('/* AUTOGENERATED FILE. DO NOT EDIT. */') + output.puts("#ifndef _#{filename}") + output.puts("#define _#{filename}\n\n") + output.puts("#include \"#{@options[:framework]}.h\"") + output.puts('#include "cmock.h"') unless used_mocks.empty? + @options[:includes].flatten.uniq.compact.each do |inc| + output.puts("#include #{inc.include?('<') ? inc : "\"#{inc.gsub('.h', '')}.h\""}") + end + testfile_includes.each do |inc| + output.puts("#include #{inc.include?('<') ? inc : "\"#{inc.gsub('.h', '')}.h\""}") + end + output.puts "\n" + tests.each do |test| + if test[:params].nil? || test[:params].empty? + output.puts("void #{test[:test]}(void);") + else + output.puts("void #{test[:test]}(#{test[:params]});") + end + end + output.puts("#endif\n\n") + end +end + +if $0 == __FILE__ + options = { includes: [] } + + # parse out all the options first (these will all be removed as we go) + ARGV.reject! do |arg| + case arg + when '-cexception' + options[:plugins] = [:cexception] + true + when /\.*\.ya?ml/ + options = UnityTestRunnerGenerator.grab_config(arg) + true + when /--(\w+)=\"?(.*)\"?/ + options[Regexp.last_match(1).to_sym] = Regexp.last_match(2) + true + when /\.*\.h/ + options[:includes] << arg + true + else false + end + end + + # make sure there is at least one parameter left (the input file) + unless ARGV[0] + puts ["\nusage: ruby #{__FILE__} (files) (options) input_test_file (output)", + "\n input_test_file - this is the C file you want to create a runner for", + ' output - this is the name of the runner file to generate', + ' defaults to (input_test_file)_Runner', + ' files:', + ' *.yml / *.yaml - loads configuration from here in :unity or :cmock', + ' *.h - header files are added as #includes in runner', + ' options:', + ' -cexception - include cexception support', + ' -externc - add extern "C" for cpp support', + ' --setup_name="" - redefine setUp func name to something else', + ' --teardown_name="" - redefine tearDown func name to something else', + ' --main_name="" - redefine main func name to something else', + ' --test_prefix="" - redefine test prefix from default test|spec|should', + ' --test_reset_name="" - redefine resetTest func name to something else', + ' --suite_setup="" - code to execute for setup of entire suite', + ' --suite_teardown="" - code to execute for teardown of entire suite', + ' --use_param_tests=1 - enable parameterized tests (disabled by default)', + ' --header_file="" - path/name of test header file to generate too'].join("\n") + exit 1 + end + + # create the default test runner name if not specified + ARGV[1] = ARGV[0].gsub('.c', '_Runner.c') unless ARGV[1] + + UnityTestRunnerGenerator.new(options).run(ARGV[0], ARGV[1]) +end \ No newline at end of file diff --git a/unity/auto/parse_output.rb b/unity/auto/parse_output.rb new file mode 100644 index 0000000..fa07b7d --- /dev/null +++ b/unity/auto/parse_output.rb @@ -0,0 +1,322 @@ +#============================================================ +# Author: John Theofanopoulos +# A simple parser. Takes the output files generated during the +# build process and extracts information relating to the tests. +# +# Notes: +# To capture an output file under VS builds use the following: +# devenv [build instructions] > Output.txt & type Output.txt +# +# To capture an output file under Linux builds use the following: +# make | tee Output.txt +# +# This script can handle the following output formats: +# - normal output (raw unity) +# - fixture output (unity_fixture.h/.c) +# - fixture output with verbose flag set ("-v") +# +# To use this parser use the following command +# ruby parseOutput.rb [options] [file] +# options: -xml : produce a JUnit compatible XML file +# file: file to scan for results +#============================================================ + +# Parser class for handling the input file +class ParseOutput + def initialize + # internal data + @class_name_idx = 0 + @path_delim = nil + + # xml output related + @xml_out = false + @array_list = false + + # current suite name and statistics + @test_suite = nil + @total_tests = 0 + @test_passed = 0 + @test_failed = 0 + @test_ignored = 0 + end + + # Set the flag to indicate if there will be an XML output file or not + def set_xml_output + @xml_out = true + end + + # If write our output to XML + def write_xml_output + output = File.open('report.xml', 'w') + output << "\n" + @array_list.each do |item| + output << item << "\n" + end + end + + # Pushes the suite info as xml to the array list, which will be written later + def push_xml_output_suite_info + # Insert opening tag at front + heading = '' + @array_list.insert(0, heading) + # Push back the closing tag + @array_list.push '' + end + + # Pushes xml output data to the array list, which will be written later + def push_xml_output_passed(test_name) + @array_list.push ' ' + end + + # Pushes xml output data to the array list, which will be written later + def push_xml_output_failed(test_name, reason) + @array_list.push ' ' + @array_list.push ' ' + reason + '' + @array_list.push ' ' + end + + # Pushes xml output data to the array list, which will be written later + def push_xml_output_ignored(test_name, reason) + @array_list.push ' ' + @array_list.push ' ' + reason + '' + @array_list.push ' ' + end + + # This function will try and determine when the suite is changed. This is + # is the name that gets added to the classname parameter. + def test_suite_verify(test_suite_name) + # Split the path name + test_name = test_suite_name.split(@path_delim) + + # Remove the extension and extract the base_name + base_name = test_name[test_name.size - 1].split('.')[0] + + # Return if the test suite hasn't changed + return unless base_name.to_s != @test_suite.to_s + + @test_suite = base_name + printf "New Test: %s\n", @test_suite + end + + # Prepares the line for verbose fixture output ("-v") + def prepare_fixture_line(line) + line = line.sub('IGNORE_TEST(', '') + line = line.sub('TEST(', '') + line = line.sub(')', ',') + line = line.chomp + array = line.split(',') + array.map { |x| x.to_s.lstrip.chomp } + end + + # Test was flagged as having passed so format the output. + # This is using the Unity fixture output and not the original Unity output. + def test_passed_unity_fixture(array) + class_name = array[0] + test_name = array[1] + test_suite_verify(class_name) + printf "%-40s PASS\n", test_name + + push_xml_output_passed(test_name) if @xml_out + end + + # Test was flagged as having failed so format the output. + # This is using the Unity fixture output and not the original Unity output. + def test_failed_unity_fixture(array) + class_name = array[0] + test_name = array[1] + test_suite_verify(class_name) + reason_array = array[2].split(':') + reason = reason_array[-1].lstrip.chomp + ' at line: ' + reason_array[-4] + + printf "%-40s FAILED\n", test_name + + push_xml_output_failed(test_name, reason) if @xml_out + end + + # Test was flagged as being ignored so format the output. + # This is using the Unity fixture output and not the original Unity output. + def test_ignored_unity_fixture(array) + class_name = array[0] + test_name = array[1] + reason = 'No reason given' + if array.size > 2 + reason_array = array[2].split(':') + tmp_reason = reason_array[-1].lstrip.chomp + reason = tmp_reason == 'IGNORE' ? 'No reason given' : tmp_reason + end + test_suite_verify(class_name) + printf "%-40s IGNORED\n", test_name + + push_xml_output_ignored(test_name, reason) if @xml_out + end + + # Test was flagged as having passed so format the output + def test_passed(array) + last_item = array.length - 1 + test_name = array[last_item - 1] + test_suite_verify(array[@class_name_idx]) + printf "%-40s PASS\n", test_name + + return unless @xml_out + + push_xml_output_passed(test_name) if @xml_out + end + + # Test was flagged as having failed so format the line + def test_failed(array) + last_item = array.length - 1 + test_name = array[last_item - 2] + reason = array[last_item].chomp.lstrip + ' at line: ' + array[last_item - 3] + class_name = array[@class_name_idx] + + if test_name.start_with? 'TEST(' + array2 = test_name.split(' ') + + test_suite = array2[0].sub('TEST(', '') + test_suite = test_suite.sub(',', '') + class_name = test_suite + + test_name = array2[1].sub(')', '') + end + + test_suite_verify(class_name) + printf "%-40s FAILED\n", test_name + + push_xml_output_failed(test_name, reason) if @xml_out + end + + # Test was flagged as being ignored so format the output + def test_ignored(array) + last_item = array.length - 1 + test_name = array[last_item - 2] + reason = array[last_item].chomp.lstrip + class_name = array[@class_name_idx] + + if test_name.start_with? 'TEST(' + array2 = test_name.split(' ') + + test_suite = array2[0].sub('TEST(', '') + test_suite = test_suite.sub(',', '') + class_name = test_suite + + test_name = array2[1].sub(')', '') + end + + test_suite_verify(class_name) + printf "%-40s IGNORED\n", test_name + + push_xml_output_ignored(test_name, reason) if @xml_out + end + + # Adjusts the os specific members according to the current path style + # (Windows or Unix based) + def detect_os_specifics(line) + if line.include? '\\' + # Windows X:\Y\Z + @class_name_idx = 1 + @path_delim = '\\' + else + # Unix Based /X/Y/Z + @class_name_idx = 0 + @path_delim = '/' + end + end + + # Main function used to parse the file that was captured. + def process(file_name) + @array_list = [] + + puts 'Parsing file: ' + file_name + + @test_passed = 0 + @test_failed = 0 + @test_ignored = 0 + puts '' + puts '=================== RESULTS =====================' + puts '' + File.open(file_name).each do |line| + # Typical test lines look like these: + # ---------------------------------------------------- + # 1. normal output: + # /.c:36:test_tc1000_opsys:FAIL: Expected 1 Was 0 + # /.c:112:test_tc5004_initCanChannel:IGNORE: Not Yet Implemented + # /.c:115:test_tc5100_initCanVoidPtrs:PASS + # + # 2. fixture output + # /.c:63:TEST(, ):FAIL: Expected 0x00001234 Was 0x00005A5A + # /.c:36:TEST(, ):IGNORE + # Note: "PASS" information won't be generated in this mode + # + # 3. fixture output with verbose information ("-v") + # TEST()/:168::FAIL: Expected 0x8D Was 0x8C + # TEST(, )/:22::IGNORE: This Test Was Ignored On Purpose + # IGNORE_TEST() + # TEST() PASS + # + # Note: Where path is different on Unix vs Windows devices (Windows leads with a drive letter)! + detect_os_specifics(line) + line_array = line.split(':') + + # If we were able to split the line then we can look to see if any of our target words + # were found. Case is important. + next unless (line_array.size >= 4) || (line.start_with? 'TEST(') || (line.start_with? 'IGNORE_TEST(') + + # check if the output is fixture output (with verbose flag "-v") + if (line.start_with? 'TEST(') || (line.start_with? 'IGNORE_TEST(') + line_array = prepare_fixture_line(line) + if line.include? ' PASS' + test_passed_unity_fixture(line_array) + @test_passed += 1 + elsif line.include? 'FAIL' + test_failed_unity_fixture(line_array) + @test_failed += 1 + elsif line.include? 'IGNORE' + test_ignored_unity_fixture(line_array) + @test_ignored += 1 + end + # normal output / fixture output (without verbose "-v") + elsif line.include? ':PASS' + test_passed(line_array) + @test_passed += 1 + elsif line.include? ':FAIL' + test_failed(line_array) + @test_failed += 1 + elsif line.include? ':IGNORE:' + test_ignored(line_array) + @test_ignored += 1 + elsif line.include? ':IGNORE' + line_array.push('No reason given') + test_ignored(line_array) + @test_ignored += 1 + end + @total_tests = @test_passed + @test_failed + @test_ignored + end + puts '' + puts '=================== SUMMARY =====================' + puts '' + puts 'Tests Passed : ' + @test_passed.to_s + puts 'Tests Failed : ' + @test_failed.to_s + puts 'Tests Ignored : ' + @test_ignored.to_s + + return unless @xml_out + + # push information about the suite + push_xml_output_suite_info + # write xml output file + write_xml_output + end +end + +# If the command line has no values in, used a default value of Output.txt +parse_my_file = ParseOutput.new + +if ARGV.size >= 1 + ARGV.each do |arg| + if arg == '-xml' + parse_my_file.set_xml_output + else + parse_my_file.process(arg) + break + end + end +end diff --git a/unity/auto/stylize_as_junit.rb b/unity/auto/stylize_as_junit.rb new file mode 100644 index 0000000..a53f85f --- /dev/null +++ b/unity/auto/stylize_as_junit.rb @@ -0,0 +1,248 @@ +#!/usr/bin/ruby +# +# unity_to_junit.rb +# +require 'fileutils' +require 'optparse' +require 'ostruct' +require 'set' + +require 'pp' + +VERSION = 1.0 + +class ArgvParser + # + # Return a structure describing the options. + # + def self.parse(args) + # The options specified on the command line will be collected in *options*. + # We set default values here. + options = OpenStruct.new + options.results_dir = '.' + options.root_path = '.' + options.out_file = 'results.xml' + + opts = OptionParser.new do |o| + o.banner = 'Usage: unity_to_junit.rb [options]' + + o.separator '' + o.separator 'Specific options:' + + o.on('-r', '--results ', 'Look for Unity Results files here.') do |results| + # puts "results #{results}" + options.results_dir = results + end + + o.on('-p', '--root_path ', 'Prepend this path to files in results.') do |root_path| + options.root_path = root_path + end + + o.on('-o', '--output ', 'XML file to generate.') do |out_file| + # puts "out_file: #{out_file}" + options.out_file = out_file + end + + o.separator '' + o.separator 'Common options:' + + # No argument, shows at tail. This will print an options summary. + o.on_tail('-h', '--help', 'Show this message') do + puts o + exit + end + + # Another typical switch to print the version. + o.on_tail('--version', 'Show version') do + puts "unity_to_junit.rb version #{VERSION}" + exit + end + end + + opts.parse!(args) + options + end +end + +class UnityToJUnit + include FileUtils::Verbose + attr_reader :report, :total_tests, :failures, :ignored + attr_writer :targets, :root, :out_file + + def initialize + @report = '' + @unit_name = '' + end + + def run + # Clean up result file names + results = @targets.map { |target| target.tr('\\', '/') } + # puts "Output File: #{@out_file}" + f = File.new(@out_file, 'w') + write_xml_header(f) + write_suites_header(f) + results.each do |result_file| + lines = File.readlines(result_file).map(&:chomp) + + raise "Empty test result file: #{result_file}" if lines.empty? + + result_output = get_details(result_file, lines) + tests, failures, ignored = parse_test_summary(lines) + result_output[:counts][:total] = tests + result_output[:counts][:failed] = failures + result_output[:counts][:ignored] = ignored + result_output[:counts][:passed] = (result_output[:counts][:total] - result_output[:counts][:failed] - result_output[:counts][:ignored]) + + # use line[0] from the test output to get the test_file path and name + test_file_str = lines[0].tr('\\', '/') + test_file_str = test_file_str.split(':') + test_file = if test_file_str.length < 2 + result_file + else + test_file_str[0] + ':' + test_file_str[1] + end + result_output[:source][:path] = File.dirname(test_file) + result_output[:source][:file] = File.basename(test_file) + + # save result_output + @unit_name = File.basename(test_file, '.*') + + write_suite_header(result_output[:counts], f) + write_failures(result_output, f) + write_tests(result_output, f) + write_ignored(result_output, f) + write_suite_footer(f) + end + write_suites_footer(f) + f.close + end + + def usage(err_msg = nil) + puts "\nERROR: " + puts err_msg if err_msg + puts 'Usage: unity_to_junit.rb [options]' + puts '' + puts 'Specific options:' + puts ' -r, --results Look for Unity Results files here.' + puts ' -p, --root_path Prepend this path to files in results.' + puts ' -o, --output XML file to generate.' + puts '' + puts 'Common options:' + puts ' -h, --help Show this message' + puts ' --version Show version' + + exit 1 + end + + protected + + def get_details(_result_file, lines) + results = results_structure + lines.each do |line| + line = line.tr('\\', '/') + _src_file, src_line, test_name, status, msg = line.split(/:/) + case status + when 'IGNORE' then results[:ignores] << { test: test_name, line: src_line, message: msg } + when 'FAIL' then results[:failures] << { test: test_name, line: src_line, message: msg } + when 'PASS' then results[:successes] << { test: test_name, line: src_line, message: msg } + end + end + results + end + + def parse_test_summary(summary) + raise "Couldn't parse test results: #{summary}" unless summary.find { |v| v =~ /(\d+) Tests (\d+) Failures (\d+) Ignored/ } + [Regexp.last_match(1).to_i, Regexp.last_match(2).to_i, Regexp.last_match(3).to_i] + end + + private + + def results_structure + { + source: { path: '', file: '' }, + successes: [], + failures: [], + ignores: [], + counts: { total: 0, passed: 0, failed: 0, ignored: 0 }, + stdout: [] + } + end + + def write_xml_header(stream) + stream.puts "" + end + + def write_suites_header(stream) + stream.puts '' + end + + def write_suite_header(counts, stream) + stream.puts "\t" + end + + def write_failures(results, stream) + result = results[:failures] + result.each do |item| + filename = File.join(results[:source][:path], File.basename(results[:source][:file], '.*')) + stream.puts "\t\t" + stream.puts "\t\t\t" + stream.puts "\t\t\t [File] #{filename} [Line] #{item[:line]} " + stream.puts "\t\t" + end + end + + def write_tests(results, stream) + result = results[:successes] + result.each do |item| + stream.puts "\t\t" + end + end + + def write_ignored(results, stream) + result = results[:ignores] + result.each do |item| + filename = File.join(results[:source][:path], File.basename(results[:source][:file], '.*')) + puts "Writing ignored tests for test harness: #{filename}" + stream.puts "\t\t" + stream.puts "\t\t\t" + stream.puts "\t\t\t [File] #{filename} [Line] #{item[:line]} " + stream.puts "\t\t" + end + end + + def write_suite_footer(stream) + stream.puts "\t" + end + + def write_suites_footer(stream) + stream.puts '' + end +end + +if $0 == __FILE__ + # parse out the command options + options = ArgvParser.parse(ARGV) + + # create an instance to work with + utj = UnityToJUnit.new + begin + # look in the specified or current directory for result files + targets = "#{options.results_dir.tr('\\', '/')}**/*.test*" + + results = Dir[targets] + raise "No *.testpass, *.testfail, or *.testresults files found in '#{targets}'" if results.empty? + utj.targets = results + + # set the root path + utj.root = options.root_path + + # set the output XML file name + # puts "Output File from options: #{options.out_file}" + utj.out_file = options.out_file + + # run the summarizer + puts utj.run + rescue StandardError => e + utj.usage e.message + end +end diff --git a/unity/auto/test_file_filter.rb b/unity/auto/test_file_filter.rb new file mode 100644 index 0000000..5c3a79f --- /dev/null +++ b/unity/auto/test_file_filter.rb @@ -0,0 +1,25 @@ +# ========================================== +# Unity Project - A Test Framework for C +# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams +# [Released under MIT License. Please refer to license.txt for details] +# ========================================== + +require'yaml' + +module RakefileHelpers + class TestFileFilter + def initialize(all_files = false) + @all_files = all_files + + return unless @all_files + return unless File.exist?('test_file_filter.yml') + + filters = YAML.load_file('test_file_filter.yml') + @all_files = filters[:all_files] + @only_files = filters[:only_files] + @exclude_files = filters[:exclude_files] + end + + attr_accessor :all_files, :only_files, :exclude_files + end +end diff --git a/unity/auto/type_sanitizer.rb b/unity/auto/type_sanitizer.rb new file mode 100644 index 0000000..dafb882 --- /dev/null +++ b/unity/auto/type_sanitizer.rb @@ -0,0 +1,6 @@ +module TypeSanitizer + def self.sanitize_c_identifier(unsanitized) + # convert filename to valid C identifier by replacing invalid chars with '_' + unsanitized.gsub(/[-\/\\\.\,\s]/, '_') + end +end diff --git a/unity/auto/unity_test_summary.py b/unity/auto/unity_test_summary.py new file mode 100644 index 0000000..00c0da8 --- /dev/null +++ b/unity/auto/unity_test_summary.py @@ -0,0 +1,139 @@ +#! python3 +# ========================================== +# Unity Project - A Test Framework for C +# Copyright (c) 2015 Alexander Mueller / XelaRellum@web.de +# [Released under MIT License. Please refer to license.txt for details] +# Based on the ruby script by Mike Karlesky, Mark VanderVoord, Greg Williams +# ========================================== +import sys +import os +import re +from glob import glob + +class UnityTestSummary: + def __init__(self): + self.report = '' + self.total_tests = 0 + self.failures = 0 + self.ignored = 0 + + def run(self): + # Clean up result file names + results = [] + for target in self.targets: + results.append(target.replace('\\', '/')) + + # Dig through each result file, looking for details on pass/fail: + failure_output = [] + ignore_output = [] + + for result_file in results: + lines = list(map(lambda line: line.rstrip(), open(result_file, "r").read().split('\n'))) + if len(lines) == 0: + raise Exception("Empty test result file: %s" % result_file) + + details = self.get_details(result_file, lines) + failures = details['failures'] + ignores = details['ignores'] + if len(failures) > 0: failure_output.append('\n'.join(failures)) + if len(ignores) > 0: ignore_output.append('n'.join(ignores)) + tests,failures,ignored = self.parse_test_summary('\n'.join(lines)) + self.total_tests += tests + self.failures += failures + self.ignored += ignored + + if self.ignored > 0: + self.report += "\n" + self.report += "--------------------------\n" + self.report += "UNITY IGNORED TEST SUMMARY\n" + self.report += "--------------------------\n" + self.report += "\n".join(ignore_output) + + if self.failures > 0: + self.report += "\n" + self.report += "--------------------------\n" + self.report += "UNITY FAILED TEST SUMMARY\n" + self.report += "--------------------------\n" + self.report += '\n'.join(failure_output) + + self.report += "\n" + self.report += "--------------------------\n" + self.report += "OVERALL UNITY TEST SUMMARY\n" + self.report += "--------------------------\n" + self.report += "{total_tests} TOTAL TESTS {failures} TOTAL FAILURES {ignored} IGNORED\n".format(total_tests = self.total_tests, failures=self.failures, ignored=self.ignored) + self.report += "\n" + + return self.report + + def set_targets(self, target_array): + self.targets = target_array + + def set_root_path(self, path): + self.root = path + + def usage(self, err_msg=None): + print("\nERROR: ") + if err_msg: + print(err_msg) + print("\nUsage: unity_test_summary.py result_file_directory/ root_path/") + print(" result_file_directory - The location of your results files.") + print(" Defaults to current directory if not specified.") + print(" Should end in / if specified.") + print(" root_path - Helpful for producing more verbose output if using relative paths.") + sys.exit(1) + + def get_details(self, result_file, lines): + results = { 'failures': [], 'ignores': [], 'successes': [] } + for line in lines: + parts = line.split(':') + if len(parts) == 5: + src_file,src_line,test_name,status,msg = parts + elif len(parts) == 4: + src_file,src_line,test_name,status = parts + msg = '' + else: + continue + if len(self.root) > 0: + line_out = "%s%s" % (self.root, line) + else: + line_out = line + if status == 'IGNORE': + results['ignores'].append(line_out) + elif status == 'FAIL': + results['failures'].append(line_out) + elif status == 'PASS': + results['successes'].append(line_out) + return results + + def parse_test_summary(self, summary): + m = re.search(r"([0-9]+) Tests ([0-9]+) Failures ([0-9]+) Ignored", summary) + if not m: + raise Exception("Couldn't parse test results: %s" % summary) + + return int(m.group(1)), int(m.group(2)), int(m.group(3)) + + +if __name__ == '__main__': + uts = UnityTestSummary() + try: + #look in the specified or current directory for result files + if len(sys.argv) > 1: + targets_dir = sys.argv[1] + else: + targets_dir = './' + targets = list(map(lambda x: x.replace('\\', '/'), glob(targets_dir + '**/*.test*', recursive=True))) + if len(targets) == 0: + raise Exception("No *.testpass or *.testfail files found in '%s'" % targets_dir) + uts.set_targets(targets) + + #set the root path + if len(sys.argv) > 2: + root_path = sys.argv[2] + else: + root_path = os.path.split(__file__)[0] + uts.set_root_path(root_path) + + #run the summarizer + print(uts.run()) + except Exception as e: + uts.usage(e) diff --git a/unity/auto/unity_test_summary.rb b/unity/auto/unity_test_summary.rb new file mode 100644 index 0000000..810fdbd --- /dev/null +++ b/unity/auto/unity_test_summary.rb @@ -0,0 +1,132 @@ +# ========================================== +# Unity Project - A Test Framework for C +# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams +# [Released under MIT License. Please refer to license.txt for details] +# ========================================== + +# !/usr/bin/ruby +# +# unity_test_summary.rb +# +require 'fileutils' +require 'set' + +class UnityTestSummary + include FileUtils::Verbose + + attr_reader :report, :total_tests, :failures, :ignored + attr_writer :targets, :root + + def initialize(_opts = {}) + @report = '' + @total_tests = 0 + @failures = 0 + @ignored = 0 + end + + def run + # Clean up result file names + results = @targets.map { |target| target.tr('\\', '/') } + + # Dig through each result file, looking for details on pass/fail: + failure_output = [] + ignore_output = [] + + results.each do |result_file| + lines = File.readlines(result_file).map(&:chomp) + + raise "Empty test result file: #{result_file}" if lines.empty? + + output = get_details(result_file, lines) + failure_output << output[:failures] unless output[:failures].empty? + ignore_output << output[:ignores] unless output[:ignores].empty? + tests, failures, ignored = parse_test_summary(lines) + @total_tests += tests + @failures += failures + @ignored += ignored + end + + if @ignored > 0 + @report += "\n" + @report += "--------------------------\n" + @report += "UNITY IGNORED TEST SUMMARY\n" + @report += "--------------------------\n" + @report += ignore_output.flatten.join("\n") + end + + if @failures > 0 + @report += "\n" + @report += "--------------------------\n" + @report += "UNITY FAILED TEST SUMMARY\n" + @report += "--------------------------\n" + @report += failure_output.flatten.join("\n") + end + + @report += "\n" + @report += "--------------------------\n" + @report += "OVERALL UNITY TEST SUMMARY\n" + @report += "--------------------------\n" + @report += "#{@total_tests} TOTAL TESTS #{@failures} TOTAL FAILURES #{@ignored} IGNORED\n" + @report += "\n" + end + + def usage(err_msg = nil) + puts "\nERROR: " + puts err_msg if err_msg + puts "\nUsage: unity_test_summary.rb result_file_directory/ root_path/" + puts ' result_file_directory - The location of your results files.' + puts ' Defaults to current directory if not specified.' + puts ' Should end in / if specified.' + puts ' root_path - Helpful for producing more verbose output if using relative paths.' + exit 1 + end + + protected + + def get_details(_result_file, lines) + results = { failures: [], ignores: [], successes: [] } + lines.each do |line| + _src_file, _src_line, _test_name, status, _msg = line.split(/:/) + line_out = (@root && (@root != 0) ? "#{@root}#{line}" : line).gsub(/\//, '\\') + case status + when 'IGNORE' then results[:ignores] << line_out + when 'FAIL' then results[:failures] << line_out + when 'PASS' then results[:successes] << line_out + end + end + results + end + + def parse_test_summary(summary) + raise "Couldn't parse test results: #{summary}" unless summary.find { |v| v =~ /(\d+) Tests (\d+) Failures (\d+) Ignored/ } + [Regexp.last_match(1).to_i, Regexp.last_match(2).to_i, Regexp.last_match(3).to_i] + end +end + +if $0 == __FILE__ + + # parse out the command options + opts, args = ARGV.partition { |v| v =~ /^--\w+/ } + opts.map! { |v| v[2..-1].to_sym } + + # create an instance to work with + uts = UnityTestSummary.new(opts) + + begin + # look in the specified or current directory for result files + args[0] ||= './' + targets = "#{ARGV[0].tr('\\', '/')}**/*.test*" + results = Dir[targets] + raise "No *.testpass, *.testfail, or *.testresults files found in '#{targets}'" if results.empty? + uts.targets = results + + # set the root path + args[1] ||= Dir.pwd + '/' + uts.root = ARGV[1] + + # run the summarizer + puts uts.run + rescue StandardError => e + uts.usage e.message + end +end diff --git a/unity/auto/unity_to_junit.py b/unity/auto/unity_to_junit.py new file mode 100644 index 0000000..71dd568 --- /dev/null +++ b/unity/auto/unity_to_junit.py @@ -0,0 +1,146 @@ +import sys +import os +from glob import glob + +from pyparsing import * +from junit_xml import TestSuite, TestCase + + +class UnityTestSummary: + def __init__(self): + self.report = '' + self.total_tests = 0 + self.failures = 0 + self.ignored = 0 + self.targets = 0 + self.root = None + self.test_suites = dict() + + def run(self): + # Clean up result file names + results = [] + for target in self.targets: + results.append(target.replace('\\', '/')) + + # Dig through each result file, looking for details on pass/fail: + for result_file in results: + lines = list(map(lambda line: line.rstrip(), open(result_file, "r").read().split('\n'))) + if len(lines) == 0: + raise Exception("Empty test result file: %s" % result_file) + + # define an expression for your file reference + entry_one = Combine( + oneOf(list(alphas)) + ':/' + + Word(alphanums + '_-./')) + + entry_two = Word(printables + ' ', excludeChars=':') + entry = entry_one | entry_two + + delimiter = Literal(':').suppress() + tc_result_line = Group(entry.setResultsName('tc_file_name') + delimiter + entry.setResultsName( + 'tc_line_nr') + delimiter + entry.setResultsName('tc_name') + delimiter + entry.setResultsName( + 'tc_status') + Optional( + delimiter + entry.setResultsName('tc_msg'))).setResultsName("tc_line") + + eol = LineEnd().suppress() + sol = LineStart().suppress() + blank_line = sol + eol + + tc_summary_line = Group(Word(nums).setResultsName("num_of_tests") + "Tests" + Word(nums).setResultsName( + "num_of_fail") + "Failures" + Word(nums).setResultsName("num_of_ignore") + "Ignored").setResultsName( + "tc_summary") + tc_end_line = Or(Literal("FAIL"), Literal('Ok')).setResultsName("tc_result") + + # run it and see... + pp1 = tc_result_line | Optional(tc_summary_line | tc_end_line) + pp1.ignore(blank_line | OneOrMore("-")) + + result = list() + for l in lines: + result.append((pp1.parseString(l)).asDict()) + # delete empty results + result = filter(None, result) + + tc_list = list() + for r in result: + if 'tc_line' in r: + tmp_tc_line = r['tc_line'] + + # get only the file name which will be used as the classname + file_name = tmp_tc_line['tc_file_name'].split('\\').pop().split('/').pop().rsplit('.', 1)[0] + tmp_tc = TestCase(name=tmp_tc_line['tc_name'], classname=file_name) + if 'tc_status' in tmp_tc_line: + if str(tmp_tc_line['tc_status']) == 'IGNORE': + if 'tc_msg' in tmp_tc_line: + tmp_tc.add_skipped_info(message=tmp_tc_line['tc_msg'], + output=r'[File]={0}, [Line]={1}'.format( + tmp_tc_line['tc_file_name'], tmp_tc_line['tc_line_nr'])) + else: + tmp_tc.add_skipped_info(message=" ") + elif str(tmp_tc_line['tc_status']) == 'FAIL': + if 'tc_msg' in tmp_tc_line: + tmp_tc.add_failure_info(message=tmp_tc_line['tc_msg'], + output=r'[File]={0}, [Line]={1}'.format( + tmp_tc_line['tc_file_name'], tmp_tc_line['tc_line_nr'])) + else: + tmp_tc.add_failure_info(message=" ") + + tc_list.append((str(result_file), tmp_tc)) + + for k, v in tc_list: + try: + self.test_suites[k].append(v) + except KeyError: + self.test_suites[k] = [v] + ts = [] + for suite_name in self.test_suites: + ts.append(TestSuite(suite_name, self.test_suites[suite_name])) + + with open('result.xml', 'w') as f: + TestSuite.to_file(f, ts, prettyprint='True', encoding='utf-8') + + return self.report + + def set_targets(self, target_array): + self.targets = target_array + + def set_root_path(self, path): + self.root = path + + @staticmethod + def usage(err_msg=None): + print("\nERROR: ") + if err_msg: + print(err_msg) + print("\nUsage: unity_test_summary.py result_file_directory/ root_path/") + print(" result_file_directory - The location of your results files.") + print(" Defaults to current directory if not specified.") + print(" Should end in / if specified.") + print(" root_path - Helpful for producing more verbose output if using relative paths.") + sys.exit(1) + + +if __name__ == '__main__': + uts = UnityTestSummary() + try: + # look in the specified or current directory for result files + if len(sys.argv) > 1: + targets_dir = sys.argv[1] + else: + targets_dir = './' + targets = list(map(lambda x: x.replace('\\', '/'), glob(targets_dir + '*.test*'))) + if len(targets) == 0: + raise Exception("No *.testpass or *.testfail files found in '%s'" % targets_dir) + uts.set_targets(targets) + + # set the root path + if len(sys.argv) > 2: + root_path = sys.argv[2] + else: + root_path = os.path.split(__file__)[0] + uts.set_root_path(root_path) + + # run the summarizer + print(uts.run()) + except Exception as e: + UnityTestSummary.usage(e) diff --git a/unity/docs/ThrowTheSwitchCodingStandard.md b/unity/docs/ThrowTheSwitchCodingStandard.md new file mode 100644 index 0000000..bf4c099 --- /dev/null +++ b/unity/docs/ThrowTheSwitchCodingStandard.md @@ -0,0 +1,206 @@ +# 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 has +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 endeavor. 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 fulfill 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 + +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 + +- 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 + +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 + +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 + +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 + +- 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 mark down 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](https://throwtheswitch.org)* diff --git a/unity/docs/UnityAssertionsCheatSheetSuitableforPrintingandPossiblyFraming.pdf b/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/unity/docs/UnityAssertionsReference.md b/unity/docs/UnityAssertionsReference.md new file mode 100644 index 0000000..0f1aaa2 --- /dev/null +++ b/unity/docs/UnityAssertionsReference.md @@ -0,0 +1,814 @@ +# 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 (to appreciate the big +picture on this read up on the difference between +[link:Dynamic Verification and Static Analysis]). A failing assertion stops +execution and reports an error through some appropriate I/O channel (e.g. +stdout, GUI, 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](http://en.wikipedia.org/en/wiki/Assert.h) +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: + + 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:_ + + TEST_ASSERT_X( {modifiers}, {expected}, actual, {size/count} ) + +becomes messageified like thus... + + 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. + + 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. + + 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 and Ignore + +##### `TEST_FAIL()` + +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_IGNORE()` + +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). + +### 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)` + + +### 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 (expected, actual)` + +##### `TEST_ASSERT_NOT_EQUAL (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)` + + +### 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. + +##### `TEST_ASSERT_GREATER_THAN (threshold, actual)` + +##### `TEST_ASSERT_GREATER_THAN_INT (threshold, actual)` + +##### `TEST_ASSERT_GREATER_THAN_INT8 (threshold, actual)` + +##### `TEST_ASSERT_GREATER_THAN_INT16 (threshold, actual)` + +##### `TEST_ASSERT_GREATER_THAN_INT32 (threshold, actual)` + +##### `TEST_ASSERT_GREATER_THAN_UINT (threshold, actual)` + +##### `TEST_ASSERT_GREATER_THAN_UINT8 (threshold, actual)` + +##### `TEST_ASSERT_GREATER_THAN_UINT16 (threshold, actual)` + +##### `TEST_ASSERT_GREATER_THAN_UINT32 (threshold, actual)` + +##### `TEST_ASSERT_GREATER_THAN_HEX8 (threshold, actual)` + +##### `TEST_ASSERT_GREATER_THAN_HEX16 (threshold, actual)` + +##### `TEST_ASSERT_GREATER_THAN_HEX32 (threshold, actual)` + +##### `TEST_ASSERT_LESS_THAN (threshold, actual)` + +##### `TEST_ASSERT_LESS_THAN_INT (threshold, actual)` + +##### `TEST_ASSERT_LESS_THAN_INT8 (threshold, actual)` + +##### `TEST_ASSERT_LESS_THAN_INT16 (threshold, actual)` + +##### `TEST_ASSERT_LESS_THAN_INT32 (threshold, actual)` + +##### `TEST_ASSERT_LESS_THAN_UINT (threshold, actual)` + +##### `TEST_ASSERT_LESS_THAN_UINT8 (threshold, actual)` + +##### `TEST_ASSERT_LESS_THAN_UINT16 (threshold, actual)` + +##### `TEST_ASSERT_LESS_THAN_UINT32 (threshold, actual)` + +##### `TEST_ASSERT_LESS_THAN_HEX8 (threshold, actual)` + +##### `TEST_ASSERT_LESS_THAN_HEX16 (threshold, actual)` + +##### `TEST_ASSERT_LESS_THAN_HEX32 (threshold, actual)` + + +### Integer Ranges (of all sizes) + +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)` + +### 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_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)` + +##### `TEST_ASSERT_INT8_ARRAY_WITHIN (delta, expected, actual)` + +##### `TEST_ASSERT_INT16_ARRAY_WITHIN (delta, expected, actual)` + +##### `TEST_ASSERT_INT32_ARRAY_WITHIN (delta, expected, actual)` + +##### `TEST_ASSERT_INT64_ARRAY_WITHIN (delta, expected, actual)` + +##### `TEST_ASSERT_UINT_ARRAY_WITHIN (delta, expected, actual)` + +##### `TEST_ASSERT_UINT8_ARRAY_WITHIN (delta, expected, actual)` + +##### `TEST_ASSERT_UINT16_ARRAY_WITHIN (delta, expected, actual)` + +##### `TEST_ASSERT_UINT32_ARRAY_WITHIN (delta, expected, actual)` + +##### `TEST_ASSERT_UINT64_ARRAY_WITHIN (delta, expected, actual)` + +##### `TEST_ASSERT_HEX_ARRAY_WITHIN (delta, expected, actual)` + +##### `TEST_ASSERT_HEX8_ARRAY_WITHIN (delta, expected, actual)` + +##### `TEST_ASSERT_HEX16_ARRAY_WITHIN (delta, expected, actual)` + +##### `TEST_ASSERT_HEX32_ARRAY_WITHIN (delta, expected, actual)` + +##### `TEST_ASSERT_HEX64_ARRAY_WITHIN (delta, expected, actual)` + +### 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_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_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_EQUAL_FLOAT_ARRAY (expected, actual, num_elements)` + +See Array assertion section for details. Note that individual array element +float comparisons are executed using T?EST_ASSERT_EQUAL_FLOAT?.That is, user +specified delta comparison values requires a custom-implemented floating point +array assertion. + + +##### `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_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_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_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 +0 x 20 or 0 x 263.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](https://throwtheswitch.org)* diff --git a/unity/docs/UnityConfigurationGuide.md b/unity/docs/UnityConfigurationGuide.md new file mode 100644 index 0000000..1275ca7 --- /dev/null +++ b/unity/docs/UnityConfigurationGuide.md @@ -0,0 +1,520 @@ +# 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. + + +## 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. + +_Example:_ +```C +#define UNITY_POINTER_WIDTH 64 +``` + + +##### `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 +``` + + +### 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 __%i__ +- __%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) + +_Example:_ +```C +#define UNITY_INCLUDE_PRINT_FORMATTED + +int a = 0xfab1; +UnityPrintFormatted("Decimal %d\n", -7); +UnityPrintFormatted("Unsigned %u\n", 987); +UnityPrintFormatted("Float %f\n", 3.1415926535897932384); +UnityPrintFormatted("Binary %b\n", 0xA); +UnityPrintFormatted("Hex %X\n", 0xFAB); +UnityPrintFormatted("Pointer %p\n", &a); +UnityPrintFormatted("Character %c\n", 'F'); +UnityPrintFormatted("String %s\n", "My string"); +UnityPrintFormatted("Percent %%\n"); +UnityPrintFormatted("Color Red \033[41mFAIL\033[00m\n"); +UnityPrintFormatted("\n"); +UnityPrintFormatted("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_WEAK_ATTRIBUTE` + +##### `UNITY_WEAK_PRAGMA` + +##### `UNITY_NO_WEAK` + +For some targets, Unity can make the otherwise required setUp() and tearDown() +functions optional. This is a nice convenience for test writers since setUp and +tearDown don’t often actually do anything. If you’re using gcc or clang, this +option is automatically defined for you. Other compilers can also support this +behavior, if they support a C feature called weak functions. A weak function is +a function that is compiled into your executable unless a non-weak version of +the same function is defined elsewhere. If a non-weak version is found, the weak +version is ignored as if it never existed. If your compiler supports this feature, +you can let Unity know by defining UNITY_WEAK_ATTRIBUTE or UNITY_WEAK_PRAGMA as +the function attributes that would need to be applied to identify a function as +weak. If your compiler lacks support for weak functions, you will always need to +define setUp and tearDown functions (though they can be and often will be just +empty). You can also force Unity to NOT use weak functions by defining +UNITY_NO_WEAK. The most common options for this feature are: + +_Example:_ +```C +#define UNITY_WEAK_ATTRIBUTE weak +#define UNITY_WEAK_ATTRIBUTE __attribute__((weak)) +#define UNITY_WEAK_PRAGMA +#define UNITY_NO_WEAK +``` + + +##### `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_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_OUTPUT_COLOR` + +If you want to add color using ANSI escape codes you can use this define. +t +_Example:_ +```C +#define UNITY_OUTPUT_COLOR +``` + + +## 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](https://throwtheswitch.org)* diff --git a/unity/docs/UnityGettingStartedGuide.md b/unity/docs/UnityGettingStartedGuide.md new file mode 100644 index 0000000..eb7041d --- /dev/null +++ b/unity/docs/UnityGettingStartedGuide.md @@ -0,0 +1,250 @@ +# 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 a compiler +that is configured to make these functions optional, you may leave them off +completely. Not sure? Give it a try. If you 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](../auto/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 cleanup 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. + + TEST_PROTECT() + +Setup and Catch macro + + TEST_ABORT() + +Abort Test macro + +Example: + + 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](https://throwtheswitch.org)* diff --git a/unity/docs/UnityHelperScriptsGuide.md b/unity/docs/UnityHelperScriptsGuide.md new file mode 100644 index 0000000..da56db2 --- /dev/null +++ b/unity/docs/UnityHelperScriptsGuide.md @@ -0,0 +1,266 @@ +# 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](https://ruby-labg.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](http://www.yaml.org/) 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 + :suit_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. + + +##### `: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. + + +##### `: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. + + +##### `: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. + +##### `: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. + + +### `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 (ceedling.sourceforge.net) 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](https://throwtheswitch.org)* diff --git a/unity/examples/example_1/makefile b/unity/examples/example_1/makefile new file mode 100644 index 0000000..cca79b4 --- /dev/null +++ b/unity/examples/example_1/makefile @@ -0,0 +1,71 @@ +# ========================================== +# Unity Project - A Test Framework for C +# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams +# [Released under MIT License. Please refer to license.txt for details] +# ========================================== + +#We try to detect the OS we are running on, and adjust commands as needed +ifeq ($(OS),Windows_NT) + ifeq ($(shell uname -s),) # not in a bash-like shell + CLEANUP = del /F /Q + MKDIR = mkdir + else # in a bash-like shell, like msys + CLEANUP = rm -f + MKDIR = mkdir -p + endif + TARGET_EXTENSION=.exe +else + CLEANUP = rm -f + MKDIR = mkdir -p + TARGET_EXTENSION=.out +endif + +C_COMPILER=gcc +ifeq ($(shell uname -s), Darwin) +C_COMPILER=clang +endif + +UNITY_ROOT=../.. + +CFLAGS=-std=c89 +CFLAGS += -Wall +CFLAGS += -Wextra +CFLAGS += -Wpointer-arith +CFLAGS += -Wcast-align +CFLAGS += -Wwrite-strings +CFLAGS += -Wswitch-default +CFLAGS += -Wunreachable-code +CFLAGS += -Winit-self +CFLAGS += -Wmissing-field-initializers +CFLAGS += -Wno-unknown-pragmas +CFLAGS += -Wstrict-prototypes +CFLAGS += -Wundef +CFLAGS += -Wold-style-definition + +TARGET_BASE1=test1 +TARGET_BASE2=test2 +TARGET1 = $(TARGET_BASE1)$(TARGET_EXTENSION) +TARGET2 = $(TARGET_BASE2)$(TARGET_EXTENSION) +SRC_FILES1=$(UNITY_ROOT)/src/unity.c src/ProductionCode.c test/TestProductionCode.c test/test_runners/TestProductionCode_Runner.c +SRC_FILES2=$(UNITY_ROOT)/src/unity.c src/ProductionCode2.c test/TestProductionCode2.c test/test_runners/TestProductionCode2_Runner.c +INC_DIRS=-Isrc -I$(UNITY_ROOT)/src +SYMBOLS= + +all: clean default + +default: $(SRC_FILES1) $(SRC_FILES2) + $(C_COMPILER) $(CFLAGS) $(INC_DIRS) $(SYMBOLS) $(SRC_FILES1) -o $(TARGET1) + $(C_COMPILER) $(CFLAGS) $(INC_DIRS) $(SYMBOLS) $(SRC_FILES2) -o $(TARGET2) + - ./$(TARGET1) + ./$(TARGET2) + +test/test_runners/TestProductionCode_Runner.c: test/TestProductionCode.c + ruby $(UNITY_ROOT)/auto/generate_test_runner.rb test/TestProductionCode.c test/test_runners/TestProductionCode_Runner.c +test/test_runners/TestProductionCode2_Runner.c: test/TestProductionCode2.c + ruby $(UNITY_ROOT)/auto/generate_test_runner.rb test/TestProductionCode2.c test/test_runners/TestProductionCode2_Runner.c + +clean: + $(CLEANUP) $(TARGET1) $(TARGET2) + +ci: CFLAGS += -Werror +ci: default diff --git a/unity/examples/example_1/readme.txt b/unity/examples/example_1/readme.txt new file mode 100644 index 0000000..dfed815 --- /dev/null +++ b/unity/examples/example_1/readme.txt @@ -0,0 +1,5 @@ +Example 1 +========= + +Close to the simplest possible example of Unity, using only basic features. +Run make to build & run the example tests. \ No newline at end of file diff --git a/unity/examples/example_1/src/ProductionCode.c b/unity/examples/example_1/src/ProductionCode.c new file mode 100644 index 0000000..db128e5 --- /dev/null +++ b/unity/examples/example_1/src/ProductionCode.c @@ -0,0 +1,24 @@ + +#include "ProductionCode.h" + +int Counter = 0; +int NumbersToFind[9] = { 0, 34, 55, 66, 32, 11, 1, 77, 888 }; /* some obnoxious array to search that is 1-based indexing instead of 0. */ + +/* This function is supposed to search through NumbersToFind and find a particular number. + * If it finds it, the index is returned. Otherwise 0 is returned which sorta makes sense since + * NumbersToFind is indexed from 1. Unfortunately it's broken + * (and should therefore be caught by our tests) */ +int FindFunction_WhichIsBroken(int NumberToFind) +{ + int i = 0; + while (i < 8) /* Notice I should have been in braces */ + i++; + if (NumbersToFind[i] == NumberToFind) /* Yikes! I'm getting run after the loop finishes instead of during it! */ + return i; + return 0; +} + +int FunctionWhichReturnsLocalVariable(void) +{ + return Counter; +} diff --git a/unity/examples/example_1/src/ProductionCode.h b/unity/examples/example_1/src/ProductionCode.h new file mode 100644 index 0000000..250ca0d --- /dev/null +++ b/unity/examples/example_1/src/ProductionCode.h @@ -0,0 +1,3 @@ + +int FindFunction_WhichIsBroken(int NumberToFind); +int FunctionWhichReturnsLocalVariable(void); diff --git a/unity/examples/example_1/src/ProductionCode2.c b/unity/examples/example_1/src/ProductionCode2.c new file mode 100644 index 0000000..98ee7ee --- /dev/null +++ b/unity/examples/example_1/src/ProductionCode2.c @@ -0,0 +1,11 @@ + +#include "ProductionCode2.h" + +char* ThisFunctionHasNotBeenTested(int Poor, char* LittleFunction) +{ + (void)Poor; + (void)LittleFunction; + /* Since There Are No Tests Yet, This Function Could Be Empty For All We Know. + * Which isn't terribly useful... but at least we put in a TEST_IGNORE so we won't forget */ + return (char*)0; +} diff --git a/unity/examples/example_1/src/ProductionCode2.h b/unity/examples/example_1/src/ProductionCode2.h new file mode 100644 index 0000000..34ae980 --- /dev/null +++ b/unity/examples/example_1/src/ProductionCode2.h @@ -0,0 +1,2 @@ + +char* ThisFunctionHasNotBeenTested(int Poor, char* LittleFunction); diff --git a/unity/examples/example_1/test/TestProductionCode.c b/unity/examples/example_1/test/TestProductionCode.c new file mode 100644 index 0000000..404c371 --- /dev/null +++ b/unity/examples/example_1/test/TestProductionCode.c @@ -0,0 +1,62 @@ + +#include "ProductionCode.h" +#include "unity.h" + +/* sometimes you may want to get at local data in a module. + * for example: If you plan to pass by reference, this could be useful + * however, it should often be avoided */ +extern int Counter; + +void setUp(void) +{ + /* This is run before EACH TEST */ + Counter = 0x5a5a; +} + +void tearDown(void) +{ +} + +void test_FindFunction_WhichIsBroken_ShouldReturnZeroIfItemIsNotInList_WhichWorksEvenInOurBrokenCode(void) +{ + /* All of these should pass */ + TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(78)); + TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(2)); + TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(33)); + TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(999)); + TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(-1)); +} + +void test_FindFunction_WhichIsBroken_ShouldReturnTheIndexForItemsInList_WhichWillFailBecauseOurFunctionUnderTestIsBroken(void) +{ + /* You should see this line fail in your test summary */ + TEST_ASSERT_EQUAL(1, FindFunction_WhichIsBroken(34)); + + /* Notice the rest of these didn't get a chance to run because the line above failed. + * Unit tests abort each test function on the first sign of trouble. + * Then NEXT test function runs as normal. */ + TEST_ASSERT_EQUAL(8, FindFunction_WhichIsBroken(8888)); +} + +void test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValue(void) +{ + /* This should be true because setUp set this up for us before this test */ + TEST_ASSERT_EQUAL_HEX(0x5a5a, FunctionWhichReturnsLocalVariable()); + + /* This should be true because we can still change our answer */ + Counter = 0x1234; + TEST_ASSERT_EQUAL_HEX(0x1234, FunctionWhichReturnsLocalVariable()); +} + +void test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValueAgain(void) +{ + /* This should be true again because setup was rerun before this test (and after we changed it to 0x1234) */ + TEST_ASSERT_EQUAL_HEX(0x5a5a, FunctionWhichReturnsLocalVariable()); +} + +void test_FunctionWhichReturnsLocalVariable_ShouldReturnCurrentCounter_ButFailsBecauseThisTestIsActuallyFlawed(void) +{ + /* Sometimes you get the test wrong. When that happens, you get a failure too... and a quick look should tell + * you what actually happened...which in this case was a failure to setup the initial condition. */ + TEST_ASSERT_EQUAL_HEX(0x1234, FunctionWhichReturnsLocalVariable()); +} diff --git a/unity/examples/example_1/test/TestProductionCode2.c b/unity/examples/example_1/test/TestProductionCode2.c new file mode 100644 index 0000000..7d940c1 --- /dev/null +++ b/unity/examples/example_1/test/TestProductionCode2.c @@ -0,0 +1,31 @@ + +#include "ProductionCode2.h" +#include "unity.h" + +/* These should be ignored because they are commented out in various ways: +#include "whatever.h" +#include "somethingelse.h" +*/ + +void setUp(void) +{ +} + +void tearDown(void) +{ +} + +void test_IgnoredTest(void) +{ + TEST_IGNORE_MESSAGE("This Test Was Ignored On Purpose"); +} + +void test_AnotherIgnoredTest(void) +{ + TEST_IGNORE_MESSAGE("These Can Be Useful For Leaving Yourself Notes On What You Need To Do Yet"); +} + +void test_ThisFunctionHasNotBeenTested_NeedsToBeImplemented(void) +{ + TEST_IGNORE(); /* Like This */ +} diff --git a/unity/examples/example_1/test/test_runners/TestProductionCode2_Runner.c b/unity/examples/example_1/test/test_runners/TestProductionCode2_Runner.c new file mode 100644 index 0000000..cf72c21 --- /dev/null +++ b/unity/examples/example_1/test/test_runners/TestProductionCode2_Runner.c @@ -0,0 +1,53 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + if (TEST_PROTECT()) \ + { \ + setUp(); \ + TestFunc(); \ + } \ + if (TEST_PROTECT()) \ + { \ + tearDown(); \ + } \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include +#include +#include "ProductionCode2.h" + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_IgnoredTest(void); +extern void test_AnotherIgnoredTest(void); +extern void test_ThisFunctionHasNotBeenTested_NeedsToBeImplemented(void); + + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + tearDown(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + UnityBegin("test/TestProductionCode2.c"); + RUN_TEST(test_IgnoredTest, 18); + RUN_TEST(test_AnotherIgnoredTest, 23); + RUN_TEST(test_ThisFunctionHasNotBeenTested_NeedsToBeImplemented, 28); + + return (UnityEnd()); +} diff --git a/unity/examples/example_1/test/test_runners/TestProductionCode_Runner.c b/unity/examples/example_1/test/test_runners/TestProductionCode_Runner.c new file mode 100644 index 0000000..3b49af7 --- /dev/null +++ b/unity/examples/example_1/test/test_runners/TestProductionCode_Runner.c @@ -0,0 +1,57 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + if (TEST_PROTECT()) \ + { \ + setUp(); \ + TestFunc(); \ + } \ + if (TEST_PROTECT()) \ + { \ + tearDown(); \ + } \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include +#include +#include "ProductionCode.h" + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_FindFunction_WhichIsBroken_ShouldReturnZeroIfItemIsNotInList_WhichWorksEvenInOurBrokenCode(void); +extern void test_FindFunction_WhichIsBroken_ShouldReturnTheIndexForItemsInList_WhichWillFailBecauseOurFunctionUnderTestIsBroken(void); +extern void test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValue(void); +extern void test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValueAgain(void); +extern void test_FunctionWhichReturnsLocalVariable_ShouldReturnCurrentCounter_ButFailsBecauseThisTestIsActuallyFlawed(void); + + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + tearDown(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + UnityBegin("test/TestProductionCode.c"); + RUN_TEST(test_FindFunction_WhichIsBroken_ShouldReturnZeroIfItemIsNotInList_WhichWorksEvenInOurBrokenCode, 20); + RUN_TEST(test_FindFunction_WhichIsBroken_ShouldReturnTheIndexForItemsInList_WhichWillFailBecauseOurFunctionUnderTestIsBroken, 30); + RUN_TEST(test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValue, 41); + RUN_TEST(test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValueAgain, 51); + RUN_TEST(test_FunctionWhichReturnsLocalVariable_ShouldReturnCurrentCounter_ButFailsBecauseThisTestIsActuallyFlawed, 57); + + return (UnityEnd()); +} diff --git a/unity/examples/example_2/makefile b/unity/examples/example_2/makefile new file mode 100644 index 0000000..99d8d96 --- /dev/null +++ b/unity/examples/example_2/makefile @@ -0,0 +1,70 @@ +# ========================================== +# Unity Project - A Test Framework for C +# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams +# [Released under MIT License. Please refer to license.txt for details] +# ========================================== + +#We try to detect the OS we are running on, and adjust commands as needed +ifeq ($(OS),Windows_NT) + ifeq ($(shell uname -s),) # not in a bash-like shell + CLEANUP = del /F /Q + MKDIR = mkdir + else # in a bash-like shell, like msys + CLEANUP = rm -f + MKDIR = mkdir -p + endif + TARGET_EXTENSION=.exe +else + CLEANUP = rm -f + MKDIR = mkdir -p + TARGET_EXTENSION=.out +endif + +C_COMPILER=gcc +ifeq ($(shell uname -s), Darwin) +C_COMPILER=clang +endif + +UNITY_ROOT=../.. + +CFLAGS=-std=c99 +CFLAGS += -Wall +CFLAGS += -Wextra +CFLAGS += -Wpointer-arith +CFLAGS += -Wcast-align +CFLAGS += -Wwrite-strings +CFLAGS += -Wswitch-default +CFLAGS += -Wunreachable-code +CFLAGS += -Winit-self +CFLAGS += -Wmissing-field-initializers +CFLAGS += -Wno-unknown-pragmas +CFLAGS += -Wstrict-prototypes +CFLAGS += -Wundef +CFLAGS += -Wold-style-definition + +TARGET_BASE1=all_tests +TARGET1 = $(TARGET_BASE1)$(TARGET_EXTENSION) +SRC_FILES1=\ + $(UNITY_ROOT)/src/unity.c \ + $(UNITY_ROOT)/extras/fixture/src/unity_fixture.c \ + src/ProductionCode.c \ + src/ProductionCode2.c \ + test/TestProductionCode.c \ + test/TestProductionCode2.c \ + test/test_runners/TestProductionCode_Runner.c \ + test/test_runners/TestProductionCode2_Runner.c \ + test/test_runners/all_tests.c +INC_DIRS=-Isrc -I$(UNITY_ROOT)/src -I$(UNITY_ROOT)/extras/fixture/src +SYMBOLS= + +all: clean default + +default: + $(C_COMPILER) $(CFLAGS) $(INC_DIRS) $(SYMBOLS) $(SRC_FILES1) -o $(TARGET1) + - ./$(TARGET1) -v + +clean: + $(CLEANUP) $(TARGET1) + +ci: CFLAGS += -Werror +ci: default diff --git a/unity/examples/example_2/readme.txt b/unity/examples/example_2/readme.txt new file mode 100644 index 0000000..f0fce65 --- /dev/null +++ b/unity/examples/example_2/readme.txt @@ -0,0 +1,5 @@ +Example 2 +========= + +Same as the first example, but now using Unity's test fixture to group tests +together. Using the test fixture also makes writing test runners much easier. \ No newline at end of file diff --git a/unity/examples/example_2/src/ProductionCode.c b/unity/examples/example_2/src/ProductionCode.c new file mode 100644 index 0000000..500b44b --- /dev/null +++ b/unity/examples/example_2/src/ProductionCode.c @@ -0,0 +1,24 @@ + +#include "ProductionCode.h" + +int Counter = 0; +int NumbersToFind[9] = { 0, 34, 55, 66, 32, 11, 1, 77, 888 }; //some obnoxious array to search that is 1-based indexing instead of 0. + +// This function is supposed to search through NumbersToFind and find a particular number. +// If it finds it, the index is returned. Otherwise 0 is returned which sorta makes sense since +// NumbersToFind is indexed from 1. Unfortunately it's broken +// (and should therefore be caught by our tests) +int FindFunction_WhichIsBroken(int NumberToFind) +{ + int i = 0; + while (i <= 8) //Notice I should have been in braces + i++; + if (NumbersToFind[i] == NumberToFind) //Yikes! I'm getting run after the loop finishes instead of during it! + return i; + return 0; +} + +int FunctionWhichReturnsLocalVariable(void) +{ + return Counter; +} diff --git a/unity/examples/example_2/src/ProductionCode.h b/unity/examples/example_2/src/ProductionCode.h new file mode 100644 index 0000000..250ca0d --- /dev/null +++ b/unity/examples/example_2/src/ProductionCode.h @@ -0,0 +1,3 @@ + +int FindFunction_WhichIsBroken(int NumberToFind); +int FunctionWhichReturnsLocalVariable(void); diff --git a/unity/examples/example_2/src/ProductionCode2.c b/unity/examples/example_2/src/ProductionCode2.c new file mode 100644 index 0000000..77c969f --- /dev/null +++ b/unity/examples/example_2/src/ProductionCode2.c @@ -0,0 +1,11 @@ + +#include "ProductionCode2.h" + +char* ThisFunctionHasNotBeenTested(int Poor, char* LittleFunction) +{ + (void)Poor; + (void)LittleFunction; + //Since There Are No Tests Yet, This Function Could Be Empty For All We Know. + // Which isn't terribly useful... but at least we put in a TEST_IGNORE so we won't forget + return (char*)0; +} diff --git a/unity/examples/example_2/src/ProductionCode2.h b/unity/examples/example_2/src/ProductionCode2.h new file mode 100644 index 0000000..34ae980 --- /dev/null +++ b/unity/examples/example_2/src/ProductionCode2.h @@ -0,0 +1,2 @@ + +char* ThisFunctionHasNotBeenTested(int Poor, char* LittleFunction); diff --git a/unity/examples/example_2/test/TestProductionCode.c b/unity/examples/example_2/test/TestProductionCode.c new file mode 100644 index 0000000..b8fb95c --- /dev/null +++ b/unity/examples/example_2/test/TestProductionCode.c @@ -0,0 +1,64 @@ +#include "ProductionCode.h" +#include "unity.h" +#include "unity_fixture.h" + +TEST_GROUP(ProductionCode); + +//sometimes you may want to get at local data in a module. +//for example: If you plan to pass by reference, this could be useful +//however, it should often be avoided +extern int Counter; + +TEST_SETUP(ProductionCode) +{ + //This is run before EACH TEST + Counter = 0x5a5a; +} + +TEST_TEAR_DOWN(ProductionCode) +{ +} + +TEST(ProductionCode, FindFunction_WhichIsBroken_ShouldReturnZeroIfItemIsNotInList_WhichWorksEvenInOurBrokenCode) +{ + //All of these should pass + TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(78)); + TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(2)); + TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(33)); + TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(999)); + TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(-1)); +} + +TEST(ProductionCode, FindFunction_WhichIsBroken_ShouldReturnTheIndexForItemsInList_WhichWillFailBecauseOurFunctionUnderTestIsBroken) +{ + // You should see this line fail in your test summary + TEST_ASSERT_EQUAL(1, FindFunction_WhichIsBroken(34)); + + // Notice the rest of these didn't get a chance to run because the line above failed. + // Unit tests abort each test function on the first sign of trouble. + // Then NEXT test function runs as normal. + TEST_ASSERT_EQUAL(8, FindFunction_WhichIsBroken(8888)); +} + +TEST(ProductionCode, FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValue) +{ + //This should be true because setUp set this up for us before this test + TEST_ASSERT_EQUAL_HEX(0x5a5a, FunctionWhichReturnsLocalVariable()); + + //This should be true because we can still change our answer + Counter = 0x1234; + TEST_ASSERT_EQUAL_HEX(0x1234, FunctionWhichReturnsLocalVariable()); +} + +TEST(ProductionCode, FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValueAgain) +{ + //This should be true again because setup was rerun before this test (and after we changed it to 0x1234) + TEST_ASSERT_EQUAL_HEX(0x5a5a, FunctionWhichReturnsLocalVariable()); +} + +TEST(ProductionCode, FunctionWhichReturnsLocalVariable_ShouldReturnCurrentCounter_ButFailsBecauseThisTestIsActuallyFlawed) +{ + //Sometimes you get the test wrong. When that happens, you get a failure too... and a quick look should tell + // you what actually happened...which in this case was a failure to setup the initial condition. + TEST_ASSERT_EQUAL_HEX(0x1234, FunctionWhichReturnsLocalVariable()); +} diff --git a/unity/examples/example_2/test/TestProductionCode2.c b/unity/examples/example_2/test/TestProductionCode2.c new file mode 100644 index 0000000..d9f4efe --- /dev/null +++ b/unity/examples/example_2/test/TestProductionCode2.c @@ -0,0 +1,33 @@ +#include "ProductionCode2.h" +#include "unity.h" +#include "unity_fixture.h" + +TEST_GROUP(ProductionCode2); + +/* These should be ignored because they are commented out in various ways: +#include "whatever.h" +*/ +//#include "somethingelse.h" + +TEST_SETUP(ProductionCode2) +{ +} + +TEST_TEAR_DOWN(ProductionCode2) +{ +} + +TEST(ProductionCode2, IgnoredTest) +{ + TEST_IGNORE_MESSAGE("This Test Was Ignored On Purpose"); +} + +TEST(ProductionCode2, AnotherIgnoredTest) +{ + TEST_IGNORE_MESSAGE("These Can Be Useful For Leaving Yourself Notes On What You Need To Do Yet"); +} + +TEST(ProductionCode2, ThisFunctionHasNotBeenTested_NeedsToBeImplemented) +{ + TEST_IGNORE(); //Like This +} diff --git a/unity/examples/example_2/test/test_runners/TestProductionCode2_Runner.c b/unity/examples/example_2/test/test_runners/TestProductionCode2_Runner.c new file mode 100644 index 0000000..6fcc3b1 --- /dev/null +++ b/unity/examples/example_2/test/test_runners/TestProductionCode2_Runner.c @@ -0,0 +1,9 @@ +#include "unity.h" +#include "unity_fixture.h" + +TEST_GROUP_RUNNER(ProductionCode2) +{ + RUN_TEST_CASE(ProductionCode2, IgnoredTest); + RUN_TEST_CASE(ProductionCode2, AnotherIgnoredTest); + RUN_TEST_CASE(ProductionCode2, ThisFunctionHasNotBeenTested_NeedsToBeImplemented); +} \ No newline at end of file diff --git a/unity/examples/example_2/test/test_runners/TestProductionCode_Runner.c b/unity/examples/example_2/test/test_runners/TestProductionCode_Runner.c new file mode 100644 index 0000000..41a416a --- /dev/null +++ b/unity/examples/example_2/test/test_runners/TestProductionCode_Runner.c @@ -0,0 +1,11 @@ +#include "unity.h" +#include "unity_fixture.h" + +TEST_GROUP_RUNNER(ProductionCode) +{ + RUN_TEST_CASE(ProductionCode, FindFunction_WhichIsBroken_ShouldReturnZeroIfItemIsNotInList_WhichWorksEvenInOurBrokenCode); + RUN_TEST_CASE(ProductionCode, FindFunction_WhichIsBroken_ShouldReturnTheIndexForItemsInList_WhichWillFailBecauseOurFunctionUnderTestIsBroken); + RUN_TEST_CASE(ProductionCode, FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValue); + RUN_TEST_CASE(ProductionCode, FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValueAgain); + RUN_TEST_CASE(ProductionCode, FunctionWhichReturnsLocalVariable_ShouldReturnCurrentCounter_ButFailsBecauseThisTestIsActuallyFlawed); +} \ No newline at end of file diff --git a/unity/examples/example_2/test/test_runners/all_tests.c b/unity/examples/example_2/test/test_runners/all_tests.c new file mode 100644 index 0000000..e706ece --- /dev/null +++ b/unity/examples/example_2/test/test_runners/all_tests.c @@ -0,0 +1,12 @@ +#include "unity_fixture.h" + +static void RunAllTests(void) +{ + RUN_TEST_GROUP(ProductionCode); + RUN_TEST_GROUP(ProductionCode2); +} + +int main(int argc, const char * argv[]) +{ + return UnityMain(argc, argv, RunAllTests); +} diff --git a/unity/examples/example_3/helper/UnityHelper.c b/unity/examples/example_3/helper/UnityHelper.c new file mode 100644 index 0000000..9cf42c6 --- /dev/null +++ b/unity/examples/example_3/helper/UnityHelper.c @@ -0,0 +1,10 @@ +#include "unity.h" +#include "UnityHelper.h" +#include +#include + +void AssertEqualExampleStruct(const EXAMPLE_STRUCT_T expected, const EXAMPLE_STRUCT_T actual, const unsigned short line) +{ + UNITY_TEST_ASSERT_EQUAL_INT(expected.x, actual.x, line, "Example Struct Failed For Field x"); + UNITY_TEST_ASSERT_EQUAL_INT(expected.y, actual.y, line, "Example Struct Failed For Field y"); +} diff --git a/unity/examples/example_3/helper/UnityHelper.h b/unity/examples/example_3/helper/UnityHelper.h new file mode 100644 index 0000000..1516111 --- /dev/null +++ b/unity/examples/example_3/helper/UnityHelper.h @@ -0,0 +1,12 @@ +#ifndef _TESTHELPER_H +#define _TESTHELPER_H + +#include "Types.h" + +void AssertEqualExampleStruct(const EXAMPLE_STRUCT_T expected, const EXAMPLE_STRUCT_T actual, const unsigned short line); + +#define UNITY_TEST_ASSERT_EQUAL_EXAMPLE_STRUCT_T(expected, actual, line, message) AssertEqualExampleStruct(expected, actual, line); + +#define TEST_ASSERT_EQUAL_EXAMPLE_STRUCT_T(expected, actual) UNITY_TEST_ASSERT_EQUAL_EXAMPLE_STRUCT_T(expected, actual, __LINE__, NULL); + +#endif // _TESTHELPER_H diff --git a/unity/examples/example_3/rakefile.rb b/unity/examples/example_3/rakefile.rb new file mode 100644 index 0000000..d014929 --- /dev/null +++ b/unity/examples/example_3/rakefile.rb @@ -0,0 +1,40 @@ +require 'rake' +require 'rake/clean' +require_relative 'rakefile_helper' + +TEMP_DIRS = [ + File.join(__dir__, 'build') +].freeze + +TEMP_DIRS.each do |dir| + directory(dir) + CLOBBER.include(dir) +end + +task prepare_for_tests: TEMP_DIRS + +include RakefileHelpers + +# Load default configuration, for now +DEFAULT_CONFIG_FILE = 'target_gcc_32.yml'.freeze +configure_toolchain(DEFAULT_CONFIG_FILE) + +task unit: [:prepare_for_tests] do + run_tests unit_test_files +end + +desc 'Generate test summary' +task :summary do + report_summary +end + +desc 'Build and test Unity' +task all: %i[clean unit summary] +task default: %i[clobber all] +task ci: [:default] +task cruise: [:default] + +desc 'Load configuration' +task :config, :config_file do |_t, args| + configure_toolchain(args[:config_file]) +end diff --git a/unity/examples/example_3/rakefile_helper.rb b/unity/examples/example_3/rakefile_helper.rb new file mode 100644 index 0000000..f1f51d4 --- /dev/null +++ b/unity/examples/example_3/rakefile_helper.rb @@ -0,0 +1,249 @@ +require 'yaml' +require 'fileutils' +require_relative '../../auto/unity_test_summary' +require_relative '../../auto/generate_test_runner' +require_relative '../../auto/colour_reporter' + +module RakefileHelpers + C_EXTENSION = '.c'.freeze + + def load_configuration(config_file) + $cfg_file = config_file + $cfg = YAML.load(File.read($cfg_file)) + end + + def configure_clean + CLEAN.include($cfg['compiler']['build_path'] + '*.*') unless $cfg['compiler']['build_path'].nil? + end + + def configure_toolchain(config_file = DEFAULT_CONFIG_FILE) + config_file += '.yml' unless config_file =~ /\.yml$/ + load_configuration(config_file) + configure_clean + end + + def unit_test_files + path = $cfg['compiler']['unit_tests_path'] + 'Test*' + C_EXTENSION + path.tr!('\\', '/') + FileList.new(path) + end + + def local_include_dirs + include_dirs = $cfg['compiler']['includes']['items'].dup + include_dirs.delete_if { |dir| dir.is_a?(Array) } + include_dirs + end + + def extract_headers(filename) + includes = [] + lines = File.readlines(filename) + lines.each do |line| + m = line.match(/^\s*#include\s+\"\s*(.+\.[hH])\s*\"/) + includes << m[1] unless m.nil? + end + includes + end + + def find_source_file(header, paths) + paths.each do |dir| + src_file = dir + header.ext(C_EXTENSION) + return src_file if File.exist?(src_file) + end + nil + end + + def tackit(strings) + result = if strings.is_a?(Array) + "\"#{strings.join}\"" + else + strings + end + result + end + + def squash(prefix, items) + result = '' + items.each { |item| result += " #{prefix}#{tackit(item)}" } + result + end + + def build_compiler_fields + command = tackit($cfg['compiler']['path']) + defines = if $cfg['compiler']['defines']['items'].nil? + '' + else + squash($cfg['compiler']['defines']['prefix'], $cfg['compiler']['defines']['items']) + end + options = squash('', $cfg['compiler']['options']) + includes = squash($cfg['compiler']['includes']['prefix'], $cfg['compiler']['includes']['items']) + includes = includes.gsub(/\\ /, ' ').gsub(/\\\"/, '"').gsub(/\\$/, '') # Remove trailing slashes (for IAR) + + { command: command, defines: defines, options: options, includes: includes } + end + + def compile(file, _defines = []) + compiler = build_compiler_fields + cmd_str = "#{compiler[:command]}#{compiler[:defines]}#{compiler[:options]}#{compiler[:includes]} #{file} " \ + "#{$cfg['compiler']['object_files']['prefix']}#{$cfg['compiler']['object_files']['destination']}" + obj_file = "#{File.basename(file, C_EXTENSION)}#{$cfg['compiler']['object_files']['extension']}" + execute(cmd_str + obj_file) + obj_file + end + + def build_linker_fields + command = tackit($cfg['linker']['path']) + options = if $cfg['linker']['options'].nil? + '' + else + squash('', $cfg['linker']['options']) + end + includes = if $cfg['linker']['includes'].nil? || $cfg['linker']['includes']['items'].nil? + '' + else + squash($cfg['linker']['includes']['prefix'], $cfg['linker']['includes']['items']) + end.gsub(/\\ /, ' ').gsub(/\\\"/, '"').gsub(/\\$/, '') # Remove trailing slashes (for IAR) + + { command: command, options: options, includes: includes } + end + + def link_it(exe_name, obj_list) + linker = build_linker_fields + cmd_str = "#{linker[:command]}#{linker[:options]}#{linker[:includes]} " + + (obj_list.map { |obj| "#{$cfg['linker']['object_files']['path']}#{obj} " }).join + + $cfg['linker']['bin_files']['prefix'] + ' ' + + $cfg['linker']['bin_files']['destination'] + + exe_name + $cfg['linker']['bin_files']['extension'] + execute(cmd_str) + end + + def build_simulator_fields + return nil if $cfg['simulator'].nil? + command = if $cfg['simulator']['path'].nil? + '' + else + (tackit($cfg['simulator']['path']) + ' ') + end + pre_support = if $cfg['simulator']['pre_support'].nil? + '' + else + squash('', $cfg['simulator']['pre_support']) + end + post_support = if $cfg['simulator']['post_support'].nil? + '' + else + squash('', $cfg['simulator']['post_support']) + end + + { command: command, pre_support: pre_support, post_support: post_support } + end + + def execute(command_string, verbose = true, raise_on_fail = true) + report command_string + output = `#{command_string}`.chomp + report(output) if verbose && !output.nil? && !output.empty? + if !$?.exitstatus.zero? && raise_on_fail + raise "Command failed. (Returned #{$?.exitstatus})" + end + output + end + + def report_summary + summary = UnityTestSummary.new + summary.root = __dir__ + results_glob = "#{$cfg['compiler']['build_path']}*.test*" + results_glob.tr!('\\', '/') + results = Dir[results_glob] + summary.targets = results + summary.run + fail_out 'FAIL: There were failures' if summary.failures > 0 + end + + def run_tests(test_files) + report 'Running system tests...' + + # Tack on TEST define for compiling unit tests + load_configuration($cfg_file) + test_defines = ['TEST'] + $cfg['compiler']['defines']['items'] = [] if $cfg['compiler']['defines']['items'].nil? + $cfg['compiler']['defines']['items'] << 'TEST' + + include_dirs = local_include_dirs + + # Build and execute each unit test + test_files.each do |test| + obj_list = [] + + # Detect dependencies and build required required modules + extract_headers(test).each do |header| + # Compile corresponding source file if it exists + src_file = find_source_file(header, include_dirs) + obj_list << compile(src_file, test_defines) unless src_file.nil? + end + + # Build the test runner (generate if configured to do so) + test_base = File.basename(test, C_EXTENSION) + runner_name = test_base + '_Runner.c' + if $cfg['compiler']['runner_path'].nil? + runner_path = $cfg['compiler']['build_path'] + runner_name + test_gen = UnityTestRunnerGenerator.new($cfg_file) + test_gen.run(test, runner_path) + else + runner_path = $cfg['compiler']['runner_path'] + runner_name + end + + obj_list << compile(runner_path, test_defines) + + # Build the test module + obj_list << compile(test, test_defines) + + # Link the test executable + link_it(test_base, obj_list) + + # Execute unit test and generate results file + simulator = build_simulator_fields + executable = $cfg['linker']['bin_files']['destination'] + test_base + $cfg['linker']['bin_files']['extension'] + cmd_str = if simulator.nil? + executable + else + "#{simulator[:command]} #{simulator[:pre_support]} #{executable} #{simulator[:post_support]}" + end + output = execute(cmd_str, true, false) + test_results = $cfg['compiler']['build_path'] + test_base + test_results += if output.match(/OK$/m).nil? + '.testfail' + else + '.testpass' + end + File.open(test_results, 'w') { |f| f.print output } + end + end + + def build_application(main) + report 'Building application...' + + obj_list = [] + load_configuration($cfg_file) + main_path = $cfg['compiler']['source_path'] + main + C_EXTENSION + + # Detect dependencies and build required required modules + include_dirs = get_local_include_dirs + extract_headers(main_path).each do |header| + src_file = find_source_file(header, include_dirs) + obj_list << compile(src_file) unless src_file.nil? + end + + # Build the main source file + main_base = File.basename(main_path, C_EXTENSION) + obj_list << compile(main_path) + + # Create the executable + link_it(main_base, obj_list) + end + + def fail_out(msg) + puts msg + puts 'Not returning exit code so continuous integration can pass' + # exit(-1) # Only removed to pass example_3, which has failing tests on purpose. + # Still fail if the build fails for any other reason. + end +end diff --git a/unity/examples/example_3/readme.txt b/unity/examples/example_3/readme.txt new file mode 100644 index 0000000..7371fea --- /dev/null +++ b/unity/examples/example_3/readme.txt @@ -0,0 +1,13 @@ +Example 3 +========= + +This example project gives an example of some passing, ignored, and failing tests. +It's simple and meant for you to look over and get an idea for what all of this stuff does. + +You can build and test using rake. The rake version will let you test with gcc or a couple +versions of IAR. You can tweak the yaml files to get those versions running. + +Ruby is required if you're using the rake version (obviously). This version shows off most of +Unity's advanced features (automatically creating test runners, fancy summaries, etc.) +Without ruby, you have to maintain your own test runners. Do that for a while and you'll learn +why you really want to start using the Ruby tools. diff --git a/unity/examples/example_3/src/ProductionCode.c b/unity/examples/example_3/src/ProductionCode.c new file mode 100644 index 0000000..500b44b --- /dev/null +++ b/unity/examples/example_3/src/ProductionCode.c @@ -0,0 +1,24 @@ + +#include "ProductionCode.h" + +int Counter = 0; +int NumbersToFind[9] = { 0, 34, 55, 66, 32, 11, 1, 77, 888 }; //some obnoxious array to search that is 1-based indexing instead of 0. + +// This function is supposed to search through NumbersToFind and find a particular number. +// If it finds it, the index is returned. Otherwise 0 is returned which sorta makes sense since +// NumbersToFind is indexed from 1. Unfortunately it's broken +// (and should therefore be caught by our tests) +int FindFunction_WhichIsBroken(int NumberToFind) +{ + int i = 0; + while (i <= 8) //Notice I should have been in braces + i++; + if (NumbersToFind[i] == NumberToFind) //Yikes! I'm getting run after the loop finishes instead of during it! + return i; + return 0; +} + +int FunctionWhichReturnsLocalVariable(void) +{ + return Counter; +} diff --git a/unity/examples/example_3/src/ProductionCode.h b/unity/examples/example_3/src/ProductionCode.h new file mode 100644 index 0000000..250ca0d --- /dev/null +++ b/unity/examples/example_3/src/ProductionCode.h @@ -0,0 +1,3 @@ + +int FindFunction_WhichIsBroken(int NumberToFind); +int FunctionWhichReturnsLocalVariable(void); diff --git a/unity/examples/example_3/src/ProductionCode2.c b/unity/examples/example_3/src/ProductionCode2.c new file mode 100644 index 0000000..77c969f --- /dev/null +++ b/unity/examples/example_3/src/ProductionCode2.c @@ -0,0 +1,11 @@ + +#include "ProductionCode2.h" + +char* ThisFunctionHasNotBeenTested(int Poor, char* LittleFunction) +{ + (void)Poor; + (void)LittleFunction; + //Since There Are No Tests Yet, This Function Could Be Empty For All We Know. + // Which isn't terribly useful... but at least we put in a TEST_IGNORE so we won't forget + return (char*)0; +} diff --git a/unity/examples/example_3/src/ProductionCode2.h b/unity/examples/example_3/src/ProductionCode2.h new file mode 100644 index 0000000..34ae980 --- /dev/null +++ b/unity/examples/example_3/src/ProductionCode2.h @@ -0,0 +1,2 @@ + +char* ThisFunctionHasNotBeenTested(int Poor, char* LittleFunction); diff --git a/unity/examples/example_3/target_gcc_32.yml b/unity/examples/example_3/target_gcc_32.yml new file mode 100644 index 0000000..d7568ab --- /dev/null +++ b/unity/examples/example_3/target_gcc_32.yml @@ -0,0 +1,47 @@ +# Copied from ~Unity/targets/gcc_32.yml +unity_root: &unity_root '../..' +unity_source: &unity_source '../../src/' +compiler: + path: gcc + source_path: &source_path 'src/' + unit_tests_path: &unit_tests_path 'test/' + build_path: &build_path 'build/' + options: + - '-c' + - '-m32' + - '-Wall' + - '-Wno-address' + - '-std=c99' + - '-pedantic' + includes: + prefix: '-I' + items: + - *source_path + - *unity_source + - *unit_tests_path + defines: + prefix: '-D' + items: + - UNITY_INCLUDE_DOUBLE + - UNITY_SUPPORT_TEST_CASES + object_files: + prefix: '-o' + extension: '.o' + destination: *build_path +linker: + path: gcc + options: + - -lm + - '-m32' + includes: + prefix: '-I' + object_files: + path: *build_path + extension: '.o' + bin_files: + prefix: '-o' + extension: '.exe' + destination: *build_path +colour: true +:unity: + :plugins: [] diff --git a/unity/examples/example_3/test/TestProductionCode.c b/unity/examples/example_3/test/TestProductionCode.c new file mode 100644 index 0000000..28a5581 --- /dev/null +++ b/unity/examples/example_3/test/TestProductionCode.c @@ -0,0 +1,62 @@ + +#include "ProductionCode.h" +#include "unity.h" + +//sometimes you may want to get at local data in a module. +//for example: If you plan to pass by reference, this could be useful +//however, it should often be avoided +extern int Counter; + +void setUp(void) +{ + //This is run before EACH TEST + Counter = 0x5a5a; +} + +void tearDown(void) +{ +} + +void test_FindFunction_WhichIsBroken_ShouldReturnZeroIfItemIsNotInList_WhichWorksEvenInOurBrokenCode(void) +{ + //All of these should pass + TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(78)); + TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(1)); + TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(33)); + TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(999)); + TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(-1)); +} + +void test_FindFunction_WhichIsBroken_ShouldReturnTheIndexForItemsInList_WhichWillFailBecauseOurFunctionUnderTestIsBroken(void) +{ + // You should see this line fail in your test summary + TEST_ASSERT_EQUAL(1, FindFunction_WhichIsBroken(34)); + + // Notice the rest of these didn't get a chance to run because the line above failed. + // Unit tests abort each test function on the first sign of trouble. + // Then NEXT test function runs as normal. + TEST_ASSERT_EQUAL(8, FindFunction_WhichIsBroken(8888)); +} + +void test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValue(void) +{ + //This should be true because setUp set this up for us before this test + TEST_ASSERT_EQUAL_HEX(0x5a5a, FunctionWhichReturnsLocalVariable()); + + //This should be true because we can still change our answer + Counter = 0x1234; + TEST_ASSERT_EQUAL_HEX(0x1234, FunctionWhichReturnsLocalVariable()); +} + +void test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValueAgain(void) +{ + //This should be true again because setup was rerun before this test (and after we changed it to 0x1234) + TEST_ASSERT_EQUAL_HEX(0x5a5a, FunctionWhichReturnsLocalVariable()); +} + +void test_FunctionWhichReturnsLocalVariable_ShouldReturnCurrentCounter_ButFailsBecauseThisTestIsActuallyFlawed(void) +{ + //Sometimes you get the test wrong. When that happens, you get a failure too... and a quick look should tell + // you what actually happened...which in this case was a failure to setup the initial condition. + TEST_ASSERT_EQUAL_HEX(0x1234, FunctionWhichReturnsLocalVariable()); +} diff --git a/unity/examples/example_3/test/TestProductionCode2.c b/unity/examples/example_3/test/TestProductionCode2.c new file mode 100644 index 0000000..e2119cc --- /dev/null +++ b/unity/examples/example_3/test/TestProductionCode2.c @@ -0,0 +1,31 @@ + +#include "ProductionCode2.h" +#include "unity.h" + +/* These should be ignored because they are commented out in various ways: +#include "whatever.h" +*/ +//#include "somethingelse.h" + +void setUp(void) +{ +} + +void tearDown(void) +{ +} + +void test_IgnoredTest(void) +{ + TEST_IGNORE_MESSAGE("This Test Was Ignored On Purpose"); +} + +void test_AnotherIgnoredTest(void) +{ + TEST_IGNORE_MESSAGE("These Can Be Useful For Leaving Yourself Notes On What You Need To Do Yet"); +} + +void test_ThisFunctionHasNotBeenTested_NeedsToBeImplemented(void) +{ + TEST_IGNORE(); //Like This +} diff --git a/unity/examples/unity_config.h b/unity/examples/unity_config.h new file mode 100644 index 0000000..bc66e7f --- /dev/null +++ b/unity/examples/unity_config.h @@ -0,0 +1,263 @@ +/* Unity Configuration + * As of May 11th, 2016 at ThrowTheSwitch/Unity commit 837c529 + * Update: December 29th, 2016 + * See Also: Unity/docs/UnityConfigurationGuide.pdf + * + * 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 in order 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. + */ + +#ifndef UNITY_CONFIG_H +#define UNITY_CONFIG_H + +/* ************************* AUTOMATIC INTEGER TYPES *************************** + * 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. + **************************************************************************** */ + +/* The first attempt to guess your types is to check `limits.h`. Some compilers + * that don't support `stdint.h` could include `limits.h`. If you don't + * want Unity to check this file, define this to make it skip the inclusion. + * Unity looks at UINT_MAX & ULONG_MAX, which were available since C89. + */ +/* #define UNITY_EXCLUDE_LIMITS_H */ + +/* The second thing that Unity does to guess your types is check `stdint.h`. + * This file defines `UINTPTR_MAX`, since C99, that Unity can make use of to + * learn about your system. It's possible you don't want it to do this or 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. + */ +/* #define UNITY_EXCLUDE_STDINT_H */ + +/* ********************** MANUAL INTEGER TYPE DEFINITION *********************** + * If you've disabled all of the automatic options above, you're going to have + * to do the configuration yourself. There are just a handful of defines that + * you are going to specify if you don't like the defaults. + **************************************************************************** */ + + /* Define this to be the number of bits an `int` takes up on your system. The + * default, if not auto-detected, is 32 bits. + * + * Example: + */ +/* #define UNITY_INT_WIDTH 16 */ + +/* 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: + */ +/* #define UNITY_LONG_WIDTH 16 */ + +/* 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. + * + * Example: + */ +/* #define UNITY_POINTER_WIDTH 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. + */ +/* #define UNITY_INCLUDE_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. + **************************************************************************** */ + + /* 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, just float, + * or both, as suits your needs. + */ +/* #define UNITY_EXCLUDE_FLOAT */ +/* #define UNITY_INCLUDE_DOUBLE */ +/* #define UNITY_EXCLUDE_DOUBLE */ + +/* For features that are enabled, the following floating point options also + * become available. + */ + +/* 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. To keep Unity universal, though, we eventually chose to develop + * our own floating point print routines. Still, the display of floating point + * values during a failure are optional. By default, Unity will print the + * actual results of floating point assertion failures. So a failed assertion + * will produce a message like "Expected 4.0 Was 4.25". If you would like less + * verbose failure messages for floating point assertions, use this option to + * give a failure message `"Values Not Within Delta"` and trim the binary size. + */ +/* #define UNITY_EXCLUDE_FLOAT_PRINT */ + +/* 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: + */ +/* #define UNITY_FLOAT_TYPE float16_t */ + +/* 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: + */ +/* #define UNITY_DOUBLE_TYPE long double */ + +/* If you look up `UNITY_ASSERT_EQUAL_FLOAT` and `UNITY_ASSERT_EQUAL_DOUBLE` as + * documented in the 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: + */ +/* #define UNITY_FLOAT_PRECISION 0.001f */ +/* #define UNITY_DOUBLE_PRECISION 0.001f */ + + +/* *************************** MISCELLANEOUS *********************************** + * Miscellaneous configuration options for Unity + **************************************************************************** */ + +/* Unity uses the stddef.h header included in the C standard library for the + * "NULL" macro. Define this in order to disable the include of stddef.h. If you + * do this, you have to make sure to provide your own "NULL" definition. + */ +/* #define UNITY_EXCLUDE_STDDEF_H */ + +/* Define this to enable the unity formatted print function: + * "UnityPrintFormatted" + */ +/* #define UNITY_INCLUDE_PRINT_FORMATTED */ + + +/* *************************** 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 operate properly. These macros will help in those + * situations. + **************************************************************************** */ + +/* 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: + */ +/* #define UNITY_OUTPUT_CHAR(a) RS232_putc(a) */ +/* #define UNITY_OUTPUT_CHAR_HEADER_DECLARATION RS232_putc(int) */ +/* #define UNITY_OUTPUT_FLUSH() RS232_flush() */ +/* #define UNITY_OUTPUT_FLUSH_HEADER_DECLARATION RS232_flush(void) */ +/* #define UNITY_OUTPUT_START() RS232_config(115200,1,8,0) */ +/* #define UNITY_OUTPUT_COMPLETE() RS232_close() */ + +/* For some targets, Unity can make the otherwise required `setUp()` and + * `tearDown()` functions optional. This is a nice convenience for test writers + * since `setUp` and `tearDown` don't often actually _do_ anything. If you're + * using gcc or clang, this option is automatically defined for you. Other + * compilers can also support this behavior, if they support a C feature called + * weak functions. A weak function is a function that is compiled into your + * executable _unless_ a non-weak version of the same function is defined + * elsewhere. If a non-weak version is found, the weak version is ignored as if + * it never existed. If your compiler supports this feature, you can let Unity + * know by defining `UNITY_SUPPORT_WEAK` as the function attributes that would + * need to be applied to identify a function as weak. If your compiler lacks + * support for weak functions, you will always need to define `setUp` and + * `tearDown` functions (though they can be and often will be just empty). The + * most common options for this feature are: + */ +/* #define UNITY_SUPPORT_WEAK weak */ +/* #define UNITY_SUPPORT_WEAK __attribute__((weak)) */ +/* #define UNITY_NO_WEAK */ + +/* 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: + */ +/* #define UNITY_PTR_ATTRIBUTE __attribute__((far)) */ +/* #define UNITY_PTR_ATTRIBUTE near */ + +/* Print execution time of each test when executed in verbose mode + * + * Example: + * + * TEST - PASS (10 ms) + */ +/* #define UNITY_INCLUDE_EXEC_TIME */ + +#endif /* UNITY_CONFIG_H */ diff --git a/unity/extras/eclipse/error_parsers.txt b/unity/extras/eclipse/error_parsers.txt new file mode 100644 index 0000000..94e34ff --- /dev/null +++ b/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/unity/extras/fixture/rakefile.rb b/unity/extras/fixture/rakefile.rb new file mode 100644 index 0000000..8b5319c --- /dev/null +++ b/unity/extras/fixture/rakefile.rb @@ -0,0 +1,46 @@ +# ========================================== +# Unity Project - A Test Framework for C +# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams +# [Released under MIT License. Please refer to license.txt for details] +# ========================================== + +require 'rake' +require 'rake/clean' +require 'rake/testtask' +require_relative 'rakefile_helper' + +TEMP_DIRS = [ + File.join(__dir__, 'build') +].freeze + +TEMP_DIRS.each do |dir| + directory(dir) + CLOBBER.include(dir) +end + +task prepare_for_tests: TEMP_DIRS + +include RakefileHelpers + +# Load default configuration, for now +DEFAULT_CONFIG_FILE = 'gcc_auto_stdint.yml'.freeze +configure_toolchain(DEFAULT_CONFIG_FILE) + +task unit: [:prepare_for_tests] do + run_tests +end + +desc 'Build and test Unity Framework' +task all: %i[clean unit] +task default: %i[clobber all] +task ci: %i[no_color default] +task cruise: %i[no_color default] + +desc 'Load configuration' +task :config, :config_file do |_t, args| + configure_toolchain(args[:config_file]) +end + +task :no_color do + $colour_output = false +end diff --git a/unity/extras/fixture/rakefile_helper.rb b/unity/extras/fixture/rakefile_helper.rb new file mode 100644 index 0000000..71e752b --- /dev/null +++ b/unity/extras/fixture/rakefile_helper.rb @@ -0,0 +1,178 @@ +# ========================================== +# Unity Project - A Test Framework for C +# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams +# [Released under MIT License. Please refer to license.txt for details] +# ========================================== + +require 'yaml' +require 'fileutils' +require_relative '../../auto/unity_test_summary' +require_relative '../../auto/generate_test_runner' +require_relative '../../auto/colour_reporter' + +module RakefileHelpers + C_EXTENSION = '.c'.freeze + + def load_configuration(config_file) + return if $configured + + $cfg_file = "#{__dir__}/../../test/targets/#{config_file}" unless config_file =~ /[\\|\/]/ + $cfg = YAML.load(File.read($cfg_file)) + $colour_output = false unless $cfg['colour'] + $configured = true if config_file != DEFAULT_CONFIG_FILE + end + + def configure_clean + CLEAN.include($cfg['compiler']['build_path'] + '*.*') unless $cfg['compiler']['build_path'].nil? + end + + def configure_toolchain(config_file = DEFAULT_CONFIG_FILE) + config_file += '.yml' unless config_file =~ /\.yml$/ + config_file = config_file unless config_file =~ /[\\|\/]/ + load_configuration(config_file) + configure_clean + end + + def tackit(strings) + result = if strings.is_a?(Array) + "\"#{strings.join}\"" + else + strings + end + result + end + + def squash(prefix, items) + result = '' + items.each { |item| result += " #{prefix}#{tackit(item)}" } + result + end + + def build_compiler_fields + command = tackit($cfg['compiler']['path']) + defines = if $cfg['compiler']['defines']['items'].nil? + '' + else + squash($cfg['compiler']['defines']['prefix'], $cfg['compiler']['defines']['items'] + ['UNITY_OUTPUT_CHAR=UnityOutputCharSpy_OutputChar'] + ['UNITY_OUTPUT_CHAR_HEADER_DECLARATION=UnityOutputCharSpy_OutputChar\(int\)']) + end + options = squash('', $cfg['compiler']['options']) + includes = squash($cfg['compiler']['includes']['prefix'], $cfg['compiler']['includes']['items']) + includes = includes.gsub(/\\ /, ' ').gsub(/\\\"/, '"').gsub(/\\$/, '') # Remove trailing slashes (for IAR) + + { command: command, defines: defines, options: options, includes: includes } + end + + def compile(file, _defines = []) + compiler = build_compiler_fields + unity_include = $cfg['compiler']['includes']['prefix'] + '../../src' + cmd_str = "#{compiler[:command]}#{compiler[:defines]}#{compiler[:options]}#{compiler[:includes]} #{unity_include} #{file} " \ + "#{$cfg['compiler']['object_files']['prefix']}#{$cfg['compiler']['object_files']['destination']}" \ + "#{File.basename(file, C_EXTENSION)}#{$cfg['compiler']['object_files']['extension']}" + + execute(cmd_str) + end + + def build_linker_fields + command = tackit($cfg['linker']['path']) + options = if $cfg['linker']['options'].nil? + '' + else + squash('', $cfg['linker']['options']) + end + includes = if $cfg['linker']['includes'].nil? || $cfg['linker']['includes']['items'].nil? + '' + else + squash($cfg['linker']['includes']['prefix'], $cfg['linker']['includes']['items']) + end.gsub(/\\ /, ' ').gsub(/\\\"/, '"').gsub(/\\$/, '') # Remove trailing slashes (for IAR) + + { command: command, options: options, includes: includes } + end + + def link_it(exe_name, obj_list) + linker = build_linker_fields + cmd_str = "#{linker[:command]}#{linker[:options]}#{linker[:includes]} " + + (obj_list.map { |obj| "#{$cfg['linker']['object_files']['path']}#{obj} " }).join + + $cfg['linker']['bin_files']['prefix'] + ' ' + + $cfg['linker']['bin_files']['destination'] + + exe_name + $cfg['linker']['bin_files']['extension'] + execute(cmd_str) + end + + def build_simulator_fields + return nil if $cfg['simulator'].nil? + command = if $cfg['simulator']['path'].nil? + '' + else + (tackit($cfg['simulator']['path']) + ' ') + end + pre_support = if $cfg['simulator']['pre_support'].nil? + '' + else + squash('', $cfg['simulator']['pre_support']) + end + post_support = if $cfg['simulator']['post_support'].nil? + '' + else + squash('', $cfg['simulator']['post_support']) + end + { command: command, pre_support: pre_support, post_support: post_support } + end + + def execute(command_string, verbose = true) + report command_string + output = `#{command_string}`.chomp + report(output) if verbose && !output.nil? && !output.empty? + raise "Command failed. (Returned #{$?.exitstatus})" if $?.exitstatus != 0 + output + end + + def report_summary + summary = UnityTestSummary.new + summary.root = __dir__ + results_glob = "#{$cfg['compiler']['build_path']}*.test*" + results_glob.tr!('\\', '/') + results = Dir[results_glob] + summary.targets = results + summary.run + end + + def run_tests + report 'Running Unity system tests...' + + # Tack on TEST define for compiling unit tests + load_configuration($cfg_file) + test_defines = ['TEST'] + $cfg['compiler']['defines']['items'] = [] if $cfg['compiler']['defines']['items'].nil? + + # Get a list of all source files needed + src_files = Dir["#{__dir__}/src/*.c"] + src_files += Dir["#{__dir__}/test/*.c"] + src_files += Dir["#{__dir__}/test/main/*.c"] + src_files << '../../src/unity.c' + + # Build object files + src_files.each { |f| compile(f, test_defines) } + obj_list = src_files.map { |f| File.basename(f.ext($cfg['compiler']['object_files']['extension'])) } + + # Link the test executable + test_base = 'framework_test' + link_it(test_base, obj_list) + + # Execute unit test and generate results file + simulator = build_simulator_fields + executable = $cfg['linker']['bin_files']['destination'] + test_base + $cfg['linker']['bin_files']['extension'] + cmd_str = if simulator.nil? + executable + ' -v -r' + else + "#{simulator[:command]} #{simulator[:pre_support]} #{executable} #{simulator[:post_support]}" + end + output = execute(cmd_str) + test_results = $cfg['compiler']['build_path'] + test_base + test_results += if output.match(/OK$/m).nil? + '.testfail' + else + '.testpass' + end + File.open(test_results, 'w') { |f| f.print output } + end +end diff --git a/unity/extras/fixture/readme.txt b/unity/extras/fixture/readme.txt new file mode 100644 index 0000000..6b9a78c --- /dev/null +++ b/unity/extras/fixture/readme.txt @@ -0,0 +1,9 @@ +Copyright (c) 2010 James Grenning and Contributed to Unity Project + +Unity Project - A Test Framework for C +Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams +[Released under MIT License. Please refer to license.txt for details] + +This Framework is an optional add-on to Unity. By including unity_framework.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. \ No newline at end of file diff --git a/unity/extras/fixture/src/unity_fixture.c b/unity/extras/fixture/src/unity_fixture.c new file mode 100644 index 0000000..0a16f6c --- /dev/null +++ b/unity/extras/fixture/src/unity_fixture.c @@ -0,0 +1,455 @@ +/* Copyright (c) 2010 James Grenning and Contributed to Unity Project + * ========================================== + * Unity Project - A Test Framework for C + * Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams + * [Released under MIT License. Please refer to license.txt for details] + * ========================================== */ + +#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; */ + +#if !defined(UNITY_WEAK_ATTRIBUTE) && !defined(UNITY_WEAK_PRAGMA) +void setUp(void) { /*does nothing*/ } +void tearDown(void) { /*does nothing*/ } +#endif + +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++; + UnityMalloc_StartTest(); + UnityPointer_Init(); + + UNITY_EXEC_TIME_START(); + + if (TEST_PROTECT()) + { + setup(); + testBody(); + } + if (TEST_PROTECT()) + { + teardown(); + } + if (TEST_PROTECT()) + { + UnityPointer_UndoAllSets(); + if (!Unity.CurrentTestFailed) + UnityMalloc_EndTest(); + } + 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('!'); + } + } +} + + +/*------------------------------------------------- */ +/* Malloc and free stuff */ +#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; + + +static const char end[] = "END"; + +void* unity_malloc(size_t size) +{ + char* mem; + Guard* guard; + size_t total_size = size + sizeof(Guard) + 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 + { + guard = (Guard*)&unity_heap[heap_index]; + heap_index += total_size; + } +#else + guard = (Guard*)UNITY_FIXTURE_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 + if (mem == unity_heap + heap_index - guard->size - sizeof(end)) + { + heap_index -= (guard->size + sizeof(Guard) + sizeof(end)); + } +#else + UNITY_FIXTURE_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 */ + if (oldMem == unity_heap + heap_index - guard->size - sizeof(end) && + heap_index + size - guard->size <= 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; +} + + +/*-------------------------------------------------------- */ +/*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], "-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/unity/extras/fixture/src/unity_fixture.h b/unity/extras/fixture/src/unity_fixture.h new file mode 100644 index 0000000..2dcf473 --- /dev/null +++ b/unity/extras/fixture/src/unity_fixture.h @@ -0,0 +1,83 @@ +/* Copyright (c) 2010 James Grenning and Contributed to Unity Project + * ========================================== + * Unity Project - A Test Framework for C + * Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams + * [Released under MIT License. Please refer to license.txt for details] + * ========================================== */ + +#ifndef UNITY_FIXTURE_H_ +#define UNITY_FIXTURE_H_ + +#include "unity.h" +#include "unity_internals.h" +#include "unity_fixture_malloc_overrides.h" +#include "unity_fixture_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 + +/* You must compile with malloc replacement, as defined in unity_fixture_malloc_overrides.h */ +void UnityMalloc_MakeMallocFailAfterCount(int countdown); + +#endif /* UNITY_FIXTURE_H_ */ diff --git a/unity/extras/fixture/src/unity_fixture_internals.h b/unity/extras/fixture/src/unity_fixture_internals.h new file mode 100644 index 0000000..98d4d44 --- /dev/null +++ b/unity/extras/fixture/src/unity_fixture_internals.h @@ -0,0 +1,52 @@ +/* Copyright (c) 2010 James Grenning and Contributed to Unity Project + * ========================================== + * Unity Project - A Test Framework for C + * Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams + * [Released under MIT License. Please refer to license.txt for details] + * ========================================== */ + +#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); +void UnityMalloc_StartTest(void); +void UnityMalloc_EndTest(void); +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/unity/extras/fixture/src/unity_fixture_malloc_overrides.h b/unity/extras/fixture/src/unity_fixture_malloc_overrides.h new file mode 100644 index 0000000..7daba50 --- /dev/null +++ b/unity/extras/fixture/src/unity_fixture_malloc_overrides.h @@ -0,0 +1,47 @@ +/* Copyright (c) 2010 James Grenning and Contributed to Unity Project + * ========================================== + * Unity Project - A Test Framework for C + * Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams + * [Released under MIT License. Please refer to license.txt for details] + * ========================================== */ + +#ifndef UNITY_FIXTURE_MALLOC_OVERRIDES_H_ +#define UNITY_FIXTURE_MALLOC_OVERRIDES_H_ + +#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 the Unity Fixture to allocate and release memory + * on the heap and can be overridden with platform-specific implementations. + * For example, when using FreeRTOS UNITY_FIXTURE_MALLOC becomes pvPortMalloc() + * and UNITY_FIXTURE_FREE becomes vPortFree(). */ +#if !defined(UNITY_FIXTURE_MALLOC) || !defined(UNITY_FIXTURE_FREE) + #include + #define UNITY_FIXTURE_MALLOC(size) malloc(size) + #define UNITY_FIXTURE_FREE(ptr) free(ptr) +#else + extern void* UNITY_FIXTURE_MALLOC(size_t size); + extern void UNITY_FIXTURE_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); + +#endif /* UNITY_FIXTURE_MALLOC_OVERRIDES_H_ */ diff --git a/unity/extras/fixture/test/Makefile b/unity/extras/fixture/test/Makefile new file mode 100644 index 0000000..e6c6255 --- /dev/null +++ b/unity/extras/fixture/test/Makefile @@ -0,0 +1,75 @@ +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 +DEFINES += -D UNITY_OUTPUT_CHAR_HEADER_DECLARATION=UnityOutputCharSpy_OutputChar\(int\) +SRC = ../src/unity_fixture.c \ + ../../../src/unity.c \ + unity_fixture_Test.c \ + unity_fixture_TestRunner.c \ + unity_output_Spy.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/unity/extras/fixture/test/main/AllTests.c b/unity/extras/fixture/test/main/AllTests.c new file mode 100644 index 0000000..e30dd85 --- /dev/null +++ b/unity/extras/fixture/test/main/AllTests.c @@ -0,0 +1,22 @@ +/* Copyright (c) 2010 James Grenning and Contributed to Unity Project + * ========================================== + * Unity Project - A Test Framework for C + * Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams + * [Released under MIT License. Please refer to license.txt for details] + * ========================================== */ + +#include "unity_fixture.h" + +static void runAllTests(void) +{ + RUN_TEST_GROUP(UnityFixture); + RUN_TEST_GROUP(UnityCommandOptions); + RUN_TEST_GROUP(LeakDetection); + RUN_TEST_GROUP(InternalMalloc); +} + +int main(int argc, const char* argv[]) +{ + return UnityMain(argc, argv, runAllTests); +} + diff --git a/unity/extras/fixture/test/template_fixture_tests.c b/unity/extras/fixture/test/template_fixture_tests.c new file mode 100644 index 0000000..18bbb89 --- /dev/null +++ b/unity/extras/fixture/test/template_fixture_tests.c @@ -0,0 +1,39 @@ +/* Copyright (c) 2010 James Grenning and Contributed to Unity Project + * ========================================== + * Unity Project - A Test Framework for C + * Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams + * [Released under MIT License. Please refer to license.txt for details] + * ========================================== */ + +#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/unity/extras/fixture/test/unity_fixture_Test.c b/unity/extras/fixture/test/unity_fixture_Test.c new file mode 100644 index 0000000..a842b08 --- /dev/null +++ b/unity/extras/fixture/test/unity_fixture_Test.c @@ -0,0 +1,543 @@ +/* Copyright (c) 2010 James Grenning and Contributed to Unity Project + * ========================================== + * Unity Project - A Test Framework for C + * Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams + * [Released under MIT License. Please refer to license.txt for details] + * ========================================== */ + +#include "unity_fixture.h" +#include "unity_output_Spy.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); +} + +TEST(UnityFixture, ForceMallocFail) +{ + void* m; + void* mfails; + UnityMalloc_MakeMallocFailAfterCount(1); + m = malloc(10); + CHECK(m); + mfails = malloc(10); + TEST_ASSERT_POINTERS_EQUAL(0, mfails); + free(m); +} + +TEST(UnityFixture, ReallocSmallerIsUnchanged) +{ + void* m1 = malloc(10); + void* m2 = realloc(m1, 5); + TEST_ASSERT_POINTERS_EQUAL(m1, m2); + free(m2); +} + +TEST(UnityFixture, ReallocSameIsUnchanged) +{ + void* m1 = malloc(10); + void* m2 = realloc(m1, 10); + TEST_ASSERT_POINTERS_EQUAL(m1, m2); + free(m2); +} + +TEST(UnityFixture, ReallocLargerNeeded) +{ + void* m1 = malloc(10); + void* m2; + CHECK(m1); + strcpy((char*)m1, "123456789"); + m2 = realloc(m1, 15); + /* CHECK(m1 != m2); //Depends on implementation */ + STRCMP_EQUAL("123456789", m2); + free(m2); +} + +TEST(UnityFixture, ReallocNullPointerIsLikeMalloc) +{ + void* m = realloc(0, 15); + CHECK(m != 0); + free(m); +} + +TEST(UnityFixture, ReallocSizeZeroFreesMemAndReturnsNullPointer) +{ + void* m1 = malloc(10); + void* m2 = realloc(m1, 0); + TEST_ASSERT_POINTERS_EQUAL(0, m2); +} + +TEST(UnityFixture, CallocFillsWithZero) +{ + void* m = calloc(3, sizeof(char)); + char* s = (char*)m; + CHECK(m); + TEST_ASSERT_BYTES_EQUAL(0, s[0]); + TEST_ASSERT_BYTES_EQUAL(0, s[1]); + TEST_ASSERT_BYTES_EQUAL(0, s[2]); + free(m); +} + +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; + UnityOutputCharSpy_Enable(1); + Unity.CurrentTestFailed = 1; + UnityConcludeFixtureTest(); /* Resets TestFailed for this test to pass */ + Unity.CurrentTestIgnored = 1; + UnityConcludeFixtureTest(); /* Resets TestIgnored */ + UnityOutputCharSpy_Enable(0); + 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!"); +} + +/*------------------------------------------------------------ */ + +TEST_GROUP(LeakDetection); + +TEST_SETUP(LeakDetection) +{ +#ifdef UNITY_EXCLUDE_STDLIB_MALLOC + UnityOutputCharSpy_Create(200); +#else + UnityOutputCharSpy_Create(1000); +#endif +} + +TEST_TEAR_DOWN(LeakDetection) +{ + UnityOutputCharSpy_Destroy(); +} + +#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__ + +#if __STDC_VERSION__ >= 199901L +#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 /* >= 199901 */ + +#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__ */ + +TEST(LeakDetection, DetectsLeak) +{ +#ifndef USING_OUTPUT_SPY + TEST_IGNORE_MESSAGE("Build with '-D UNITY_OUTPUT_CHAR=UnityOutputCharSpy_OutputChar' to enable tests"); +#else + 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; + CHECK(strstr(UnityOutputCharSpy_Get(), "This test leaks!")); + free(m); +#endif +} + +TEST(LeakDetection, BufferOverrunFoundDuringFree) +{ +#ifndef USING_OUTPUT_SPY + TEST_IGNORE(); +#else + 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; + CHECK(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during free()")); +#endif +} + +TEST(LeakDetection, BufferOverrunFoundDuringRealloc) +{ +#ifndef USING_OUTPUT_SPY + TEST_IGNORE(); +#else + 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; + CHECK(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during realloc()")); +#endif +} + +TEST(LeakDetection, BufferGuardWriteFoundDuringFree) +{ +#ifndef USING_OUTPUT_SPY + TEST_IGNORE(); +#else + 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; + CHECK(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during free()")); +#endif +} + +TEST(LeakDetection, BufferGuardWriteFoundDuringRealloc) +{ +#ifndef USING_OUTPUT_SPY + TEST_IGNORE(); +#else + 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; + CHECK(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during realloc()")); +#endif +} + +TEST(LeakDetection, PointerSettingMax) +{ +#ifndef USING_OUTPUT_SPY + TEST_IGNORE(); +#else + int i; + for (i = 0; i < UNITY_MAX_POINTERS; i++) UT_PTR_SET(pointer1, &int1); + UnityOutputCharSpy_Enable(1); + EXPECT_ABORT_BEGIN + UT_PTR_SET(pointer1, &int1); + EXPECT_ABORT_END + UnityOutputCharSpy_Enable(0); + Unity.CurrentTestFailed = 0; + CHECK(strstr(UnityOutputCharSpy_Get(), "Too many pointers set")); +#endif +} + +/*------------------------------------------------------------ */ + +TEST_GROUP(InternalMalloc); +#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"); + + +TEST_SETUP(InternalMalloc) { } +TEST_TEAR_DOWN(InternalMalloc) { } + +TEST(InternalMalloc, MallocPastBufferFails) +{ +#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); +#endif +} + +TEST(InternalMalloc, CallocPastBufferFails) +{ +#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); +#endif +} + +TEST(InternalMalloc, MallocThenReallocGrowsMemoryInPlace) +{ +#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); +#endif +} + +TEST(InternalMalloc, ReallocFailDoesNotFreeMem) +{ +#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); +#endif +} diff --git a/unity/extras/fixture/test/unity_fixture_TestRunner.c b/unity/extras/fixture/test/unity_fixture_TestRunner.c new file mode 100644 index 0000000..e8713e1 --- /dev/null +++ b/unity/extras/fixture/test/unity_fixture_TestRunner.c @@ -0,0 +1,57 @@ +/* Copyright (c) 2010 James Grenning and Contributed to Unity Project + * ========================================== + * Unity Project - A Test Framework for C + * Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams + * [Released under MIT License. Please refer to license.txt for details] + * ========================================== */ + +#include "unity_fixture.h" + +TEST_GROUP_RUNNER(UnityFixture) +{ + RUN_TEST_CASE(UnityFixture, PointerSetting); + RUN_TEST_CASE(UnityFixture, ForceMallocFail); + RUN_TEST_CASE(UnityFixture, ReallocSmallerIsUnchanged); + RUN_TEST_CASE(UnityFixture, ReallocSameIsUnchanged); + RUN_TEST_CASE(UnityFixture, ReallocLargerNeeded); + RUN_TEST_CASE(UnityFixture, ReallocNullPointerIsLikeMalloc); + RUN_TEST_CASE(UnityFixture, ReallocSizeZeroFreesMemAndReturnsNullPointer); + RUN_TEST_CASE(UnityFixture, CallocFillsWithZero); + 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); +} + +TEST_GROUP_RUNNER(LeakDetection) +{ + RUN_TEST_CASE(LeakDetection, DetectsLeak); + RUN_TEST_CASE(LeakDetection, BufferOverrunFoundDuringFree); + RUN_TEST_CASE(LeakDetection, BufferOverrunFoundDuringRealloc); + RUN_TEST_CASE(LeakDetection, BufferGuardWriteFoundDuringFree); + RUN_TEST_CASE(LeakDetection, BufferGuardWriteFoundDuringRealloc); + RUN_TEST_CASE(LeakDetection, PointerSettingMax); +} + +TEST_GROUP_RUNNER(InternalMalloc) +{ + RUN_TEST_CASE(InternalMalloc, MallocPastBufferFails); + RUN_TEST_CASE(InternalMalloc, CallocPastBufferFails); + RUN_TEST_CASE(InternalMalloc, MallocThenReallocGrowsMemoryInPlace); + RUN_TEST_CASE(InternalMalloc, ReallocFailDoesNotFreeMem); +} diff --git a/unity/extras/fixture/test/unity_output_Spy.c b/unity/extras/fixture/test/unity_output_Spy.c new file mode 100644 index 0000000..be87bd5 --- /dev/null +++ b/unity/extras/fixture/test/unity_output_Spy.c @@ -0,0 +1,57 @@ +/* Copyright (c) 2010 James Grenning and Contributed to Unity Project + * ========================================== + * Unity Project - A Test Framework for C + * Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams + * [Released under MIT License. Please refer to license.txt for details] + * ========================================== */ + + +#include "unity_output_Spy.h" +#include "unity_fixture.h" + +#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/unity/extras/fixture/test/unity_output_Spy.h b/unity/extras/fixture/test/unity_output_Spy.h new file mode 100644 index 0000000..b30a7f1 --- /dev/null +++ b/unity/extras/fixture/test/unity_output_Spy.h @@ -0,0 +1,17 @@ +/* Copyright (c) 2010 James Grenning and Contributed to Unity Project + * ========================================== + * Unity Project - A Test Framework for C + * Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams + * [Released under MIT License. Please refer to license.txt for details] + * ========================================== */ + +#ifndef D_unity_output_Spy_H +#define D_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/unity/release/build.info b/unity/release/build.info new file mode 100644 index 0000000..56d5912 --- /dev/null +++ b/unity/release/build.info @@ -0,0 +1,2 @@ +122 + diff --git a/unity/release/version.info b/unity/release/version.info new file mode 100644 index 0000000..cf12b30 --- /dev/null +++ b/unity/release/version.info @@ -0,0 +1,2 @@ +2.4.3 + diff --git a/unity/src/unity.c b/unity/src/unity.c new file mode 100644 index 0000000..1fd508f --- /dev/null +++ b/unity/src/unity.c @@ -0,0 +1,1985 @@ +/* ========================================================================= + Unity Project - A Test Framework for C + Copyright (c) 2007-19 Mike Karlesky, Mark VanderVoord, Greg Williams + [Released under MIT License. Please refer to license.txt for details] +============================================================================ */ + +#define UNITY_INCLUDE_SETUP_STUBS +#include "unity.h" +#include + +/* 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 { Unity.CurrentTestFailed = 1; UNITY_OUTPUT_FLUSH(); TEST_ABORT(); } +#define UNITY_IGNORE_AND_BAIL { Unity.CurrentTestIgnored = 1; UNITY_OUTPUT_FLUSH(); TEST_ABORT(); } +#define RETURN_IF_FAIL_OR_IGNORE if (Unity.CurrentTestFailed || Unity.CurrentTestIgnored) return + +struct UNITY_STORAGE_T Unity; + +#ifdef UNITY_OUTPUT_COLOR +const char UnityStrOk[] = "\033[42mOK\033[00m"; +const char UnityStrPass[] = "\033[42mPASS\033[00m"; +const char UnityStrFail[] = "\033[41mFAIL\033[00m"; +const char UnityStrIgnore[] = "\033[43mIGNORE\033[00m"; +#else +const char UnityStrOk[] = "OK"; +const char UnityStrPass[] = "PASS"; +const char UnityStrFail[] = "FAIL"; +const char UnityStrIgnore[] = "IGNORE"; +#endif +static const char UnityStrNull[] = "NULL"; +static const char UnityStrSpacer[] = ". "; +static const char UnityStrExpected[] = " Expected "; +static const char UnityStrWas[] = " Was "; +static const char UnityStrGt[] = " to be greater than "; +static const char UnityStrLt[] = " to be less than "; +static const char UnityStrOrEqual[] = "or equal to "; +static const char UnityStrElement[] = " Element "; +static const char UnityStrByte[] = " Byte "; +static const char UnityStrMemory[] = " Memory Mismatch."; +static const char UnityStrDelta[] = " Values Not Within Delta "; +static const char UnityStrPointless[] = " You Asked Me To Compare Nothing, Which Was Pointless."; +static const char UnityStrNullPointerForExpected[] = " Expected pointer to be NULL"; +static const char UnityStrNullPointerForActual[] = " Actual pointer was NULL"; +#ifndef UNITY_EXCLUDE_FLOAT +static const char UnityStrNot[] = "Not "; +static const char UnityStrInf[] = "Infinity"; +static const char UnityStrNegInf[] = "Negative Infinity"; +static const char UnityStrNaN[] = "NaN"; +static const char UnityStrDet[] = "Determinate"; +static const char UnityStrInvalidFloatTrait[] = "Invalid Float Trait"; +#endif +const char UnityStrErrFloat[] = "Unity Floating Point Disabled"; +const char UnityStrErrDouble[] = "Unity Double Precision Disabled"; +const char UnityStrErr64[] = "Unity 64-bit Support Disabled"; +static const char UnityStrBreaker[] = "-----------------------"; +static const char UnityStrResultsTests[] = " Tests "; +static const char UnityStrResultsFailures[] = " Failures "; +static const char UnityStrResultsIgnored[] = " Ignored "; +static const char UnityStrDetail1Name[] = UNITY_DETAIL1_NAME " "; +static const char UnityStrDetail2Name[] = " " UNITY_DETAIL2_NAME " "; + +/*----------------------------------------------- + * 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++; + } + } +} + +/*-----------------------------------------------*/ +#ifdef UNITY_INCLUDE_PRINT_FORMATTED +void UnityPrintFormatted(const char* format, ...) +{ + const char* pch = format; + va_list va; + va_start(va, format); + + if (pch != NULL) + { + while (*pch) + { + /* format identification character */ + if (*pch == '%') + { + pch++; + + if (pch != NULL) + { + switch (*pch) + { + case 'd': + case 'i': + { + const int number = va_arg(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': + { + const unsigned int number = va_arg(va, unsigned int); + UnityPrintNumberUnsigned((UNITY_UINT)number); + break; + } + case 'b': + { + const unsigned int number = va_arg(va, unsigned int); + const UNITY_UINT mask = (UNITY_UINT)0 - (UNITY_UINT)1; + UNITY_OUTPUT_CHAR('0'); + UNITY_OUTPUT_CHAR('b'); + UnityPrintMask(mask, (UNITY_UINT)number); + break; + } + case 'x': + case 'X': + case 'p': + { + const unsigned int number = va_arg(va, unsigned int); + UNITY_OUTPUT_CHAR('0'); + UNITY_OUTPUT_CHAR('x'); + UnityPrintNumberHex((UNITY_UINT)number, 8); + 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++; + } + } + + va_end(va); +} +#endif /* ! UNITY_INCLUDE_PRINT_FORMATTED */ + +/*-----------------------------------------------*/ +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) + { + 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 = (UNITY_UINT)-number_to_print; + } + 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 (including for negative zero) */ + if ((number < 0.0f) || ((number == 0.0f) && ((1.0f / number) < 0.0f))) + { + UNITY_OUTPUT_CHAR('-'); + number = -number; + } + + /* handle zero, NaN, and +/- infinity */ + if (number == 0.0f) + { + UnityPrint("0"); + } + else if (isnan(number)) + { + UnityPrint("nan"); + } + else if (isinf(number)) + { + UnityPrint("inf"); + } + else + { + UNITY_INT32 n_int = 0, n; + int exponent = 0; + int decimals, 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 + 1))) + { + buf[digits++] = (char)('0' + n % 10); + n /= 10; + } + while (digits > 0) + { + if (digits == decimals) { UNITY_OUTPUT_CHAR('.'); } + UNITY_OUTPUT_CHAR(buf[--digits]); + } + + /* print exponent if needed */ + if (exponent != 0) + { + UNITY_OUTPUT_CHAR('e'); + + if (exponent < 0) + { + UNITY_OUTPUT_CHAR('-'); + exponent = -exponent; + } + else + { + UNITY_OUTPUT_CHAR('+'); + } + + digits = 0; + while ((exponent != 0) || (digits < 2)) + { + buf[digits++] = (char)('0' + exponent % 10); + exponent /= 10; + } + while (digits > 0) + { + UNITY_OUTPUT_CHAR(buf[--digits]); + } + } + } +} +#endif /* ! UNITY_EXCLUDE_FLOAT_PRINT */ + +/*-----------------------------------------------*/ +static void UnityTestResultsBegin(const char* file, const UNITY_LINE_TYPE line) +{ + UnityPrint(file); + UNITY_OUTPUT_CHAR(':'); + UnityPrintNumber((UNITY_INT)line); + UNITY_OUTPUT_CHAR(':'); + UnityPrint(Unity.CurrentTestName); + UNITY_OUTPUT_CHAR(':'); +} + +/*-----------------------------------------------*/ +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) +{ + if (msg) + { + UnityPrint(UnityStrSpacer); +#ifndef UNITY_EXCLUDE_DETAILS + if (Unity.CurrentDetail1) + { + UnityPrint(UnityStrDetail1Name); + UnityPrint(Unity.CurrentDetail1); + if (Unity.CurrentDetail2) + { + UnityPrint(UnityStrDetail2Name); + UnityPrint(Unity.CurrentDetail2); + } + UnityPrint(UnityStrSpacer); + } +#endif + 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); } + UnityPrintNumberByStyle(threshold, style); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +#define UnityPrintPointlessAndBail() \ +{ \ + UnityTestResultsFailBegin(lineNumber); \ + UnityPrint(UnityStrPointless); \ + UnityAddMsgIfSpecified(msg); \ + UNITY_FAIL_AND_BAIL; } + +/*-----------------------------------------------*/ +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) + { + UnityPrintPointlessAndBail(); + } + + 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; + 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; + 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; + 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 (isinf(expected) && isinf(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 !(isnan(diff) || isinf(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 isnan(expected) && isnan(actual) +#else + #define UNITY_NAN_CHECK 0 +#endif + +#ifndef UNITY_EXCLUDE_FLOAT_PRINT + #define UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT(expected, actual) \ + { \ + UnityPrint(UnityStrExpected); \ + UnityPrintFloat(expected); \ + UnityPrint(UnityStrWas); \ + UnityPrintFloat(actual); } +#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 UnityAssertEqualFloatArray(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; + + RETURN_IF_FAIL_OR_IGNORE; + + if (elements == 0) + { + 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; + } + + while (elements--) + { + if (!UnityFloatsWithin(*ptr_expected * UNITY_FLOAT_PRECISION, *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 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 = isinf(actual) && (actual > 0); + break; + case UNITY_FLOAT_IS_NEG_INF: + case UNITY_FLOAT_IS_NOT_NEG_INF: + is_trait = isinf(actual) && (actual < 0); + break; + + case UNITY_FLOAT_IS_NAN: + case UNITY_FLOAT_IS_NOT_NAN: + is_trait = isnan(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 = !isinf(actual) && !isnan(actual); + break; + + default: + 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 UnityAssertEqualDoubleArray(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; + + RETURN_IF_FAIL_OR_IGNORE; + + if (elements == 0) + { + 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; + } + + while (elements--) + { + if (!UnityDoublesWithin(*ptr_expected * UNITY_DOUBLE_PRECISION, *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 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 = isinf(actual) && (actual > 0); + break; + case UNITY_FLOAT_IS_NEG_INF: + case UNITY_FLOAT_IS_NOT_NEG_INF: + is_trait = isinf(actual) && (actual < 0); + break; + + case UNITY_FLOAT_IS_NAN: + case UNITY_FLOAT_IS_NOT_NAN: + is_trait = isnan(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 = !isinf(actual) && !isnan(actual); + break; + + default: + 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; + + RETURN_IF_FAIL_OR_IGNORE; + if (num_elements == 0) + { + UnityPrintPointlessAndBail(); + } + + 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; + break; + case 2: + expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT16*)expected; + actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT16*)actual; + 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; + break; +#endif + default: /* length 4 bytes */ + expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT32*)expected; + actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT32*)actual; + 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 < sizeof(expect_val))) + { /* 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; + } + if (flags == UNITY_ARRAY_TO_ARRAY) + { + expected = (UNITY_INTERNAL_PTR)(length + (const char*)expected); + } + actual = (UNITY_INTERNAL_PTR)(length + (const char*)actual); + } + +} + +/*-----------------------------------------------*/ +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 + { /* handle case of one pointers being null (if both null, test should pass) */ + 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 + { /* handle case of one pointers being null (if both null, test should pass) */ + 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) + { + UnityPrintPointlessAndBail(); + } + + 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) || (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 + +/*----------------------------------------------- + * 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(':'); + +#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 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(); +} + +/*-----------------------------------------------*/ +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 UnityParseOptions(int argc, char** argv) +{ + UnityOptionIncludeNamed = NULL; + UnityOptionExcludeNamed = NULL; + int i; + + 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 */ + 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(); + return 1; + } + } + } + + return 0; +} + +/*-----------------------------------------------*/ +int IsStringInBiggerString(const char* longstring, const char* shortstring) +{ + const char* lptr = longstring; + const char* sptr = shortstring; + const char* lnext = lptr; + + if (*sptr == '*') + { + return 1; + } + + while (*lptr) + { + lnext = lptr + 1; + + /* If they current bytes match, go on to the next bytes */ + while (*lptr && *sptr && (*lptr == *sptr)) + { + lptr++; + sptr++; + + /* We're done if we match the entire string or up to a wildcard */ + if (*sptr == '*') + return 1; + if (*sptr == ',') + return 1; + if (*sptr == '"') + return 1; + if (*sptr == '\'') + return 1; + if (*sptr == ':') + return 2; + if (*sptr == 0) + return 1; + } + + /* Otherwise we start in the long pointer 1 character further and try again */ + lptr = lnext; + sptr = shortstring; + } + + return 0; +} + +/*-----------------------------------------------*/ +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/unity/src/unity.h b/unity/src/unity.h new file mode 100644 index 0000000..0f64653 --- /dev/null +++ b/unity/src/unity.h @@ -0,0 +1,539 @@ +/* ========================================== + Unity Project - A Test Framework for C + Copyright (c) 2007-19 Mike Karlesky, Mark VanderVoord, Greg Williams + [Released under MIT License. Please refer to license.txt for details] +========================================== */ + +#ifndef UNITY_FRAMEWORK_H +#define UNITY_FRAMEWORK_H +#define UNITY + +#ifdef __cplusplus +extern "C" +{ +#endif + +#include "unity_internals.h" + +/*------------------------------------------------------- + * Test Setup / Teardown + *-------------------------------------------------------*/ + +/* These functions are intended to be called before and after each test. */ +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(). */ +void suiteSetUp(void); +int suiteTearDown(int num_failures); + +/* If the compiler supports it, the following block provides stub + * implementations of the above functions as weak symbols. Note that on + * some platforms (MinGW for example), weak function implementations need + * to be in the same translation unit they are called from. This can be + * achieved by defining UNITY_INCLUDE_SETUP_STUBS before including unity.h. */ +#ifdef UNITY_INCLUDE_SETUP_STUBS + #ifdef UNITY_WEAK_ATTRIBUTE + UNITY_WEAK_ATTRIBUTE void setUp(void) { } + UNITY_WEAK_ATTRIBUTE void tearDown(void) { } + UNITY_WEAK_ATTRIBUTE void suiteSetUp(void) { } + UNITY_WEAK_ATTRIBUTE int suiteTearDown(int num_failures) { return num_failures; } + #elif defined(UNITY_WEAK_PRAGMA) + #pragma weak setUp + void setUp(void) { } + #pragma weak tearDown + void tearDown(void) { } + #pragma weak suiteSetUp + void suiteSetUp(void) { } + #pragma weak suiteTearDown + int suiteTearDown(int num_failures) { return num_failures; } + #endif +#endif + +/*------------------------------------------------------- + * 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(...) 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_ONLY() + +/* 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() + +/* This macro does nothing, but it is useful for build tools (like Ceedling) to make use of this to figure out + * which files should be linked to in order to perform a test. Use it like TEST_FILE("sandwiches.c") */ +#define TEST_FILE(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") + +/* 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(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") +#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_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_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_UINT32)(-1), (actual), __LINE__, NULL) +#define TEST_ASSERT_BITS_LOW(mask, actual) UNITY_TEST_ASSERT_BITS((mask), (UNITY_UINT32)(0), (actual), __LINE__, NULL) +#define TEST_ASSERT_BIT_HIGH(bit, actual) UNITY_TEST_ASSERT_BITS(((UNITY_UINT32)1 << (bit)), (UNITY_UINT32)(-1), (actual), __LINE__, NULL) +#define TEST_ASSERT_BIT_LOW(bit, actual) UNITY_TEST_ASSERT_BITS(((UNITY_UINT32)1 << (bit)), (UNITY_UINT32)(0), (actual), __LINE__, NULL) + +/* 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_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_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_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_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_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_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_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) + +/* 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_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) + +/* 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_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) + + +/* 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_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) + +/* 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_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) + +/* 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_EQUAL_FLOAT(expected, actual) UNITY_TEST_ASSERT_EQUAL_FLOAT((expected), (actual), __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_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_EQUAL_DOUBLE(expected, actual) UNITY_TEST_ASSERT_EQUAL_DOUBLE((expected), (actual), __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_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) + +/*------------------------------------------------------- + * 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)) + +/* 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_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)) +#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_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)) + +/* 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_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_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_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_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_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_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_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)) + +/* 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_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)) + +/* 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_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)) + + +/* 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_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)) + +/* 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_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)) + +/* 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_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_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_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_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)) + +/* end of UNITY_FRAMEWORK_H */ +#ifdef __cplusplus +} +#endif +#endif diff --git a/unity/src/unity_internals.h b/unity/src/unity_internals.h new file mode 100644 index 0000000..050fbdb --- /dev/null +++ b/unity/src/unity_internals.h @@ -0,0 +1,990 @@ +/* ========================================== + Unity Project - A Test Framework for C + Copyright (c) 2007-19 Mike Karlesky, Mark VanderVoord, Greg Williams + [Released under MIT License. Please refer to license.txt for details] +========================================== */ + +#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 + +/*------------------------------------------------------- + * 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. + * 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 + +/*------------------------------------------------------- + * 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; + +/* isinf & isnan macros should be provided by math.h */ +#ifndef isinf +/* The value of Inf - Inf is NaN */ +#define isinf(n) (isnan((n) - (n)) && !isnan(n)) +#endif + +#ifndef isnan +/* NaN is the only floating point value that does NOT equal itself. + * Therefore if n != n, then it is NaN. */ +#define isnan(n) ((n != n) ? 1 : 0) +#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() + #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__) + #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{}while(0) +#endif + +#ifndef UNITY_EXEC_TIME_STOP +#define UNITY_EXEC_TIME_STOP() do{}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{}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 + +/*------------------------------------------------------- + * Language Features Available + *-------------------------------------------------------*/ +#if !defined(UNITY_WEAK_ATTRIBUTE) && !defined(UNITY_WEAK_PRAGMA) +# if defined(__GNUC__) || defined(__ghs__) /* __GNUC__ includes clang */ +# if !(defined(__WIN32__) && defined(__clang__)) && !defined(__TMS470__) +# define UNITY_WEAK_ATTRIBUTE __attribute__((weak)) +# endif +# endif +#endif + +#ifdef UNITY_NO_WEAK +# undef UNITY_WEAK_ATTRIBUTE +# undef UNITY_WEAK_PRAGMA +#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) + +typedef enum +{ + UNITY_DISPLAY_STYLE_INT = sizeof(int) + 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 = sizeof(unsigned) + 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_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_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 UnityConcludeTest(void); +void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int FuncLineNum); + +/*------------------------------------------------------- + * 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() { Unity.CurrentDetail1 = 0; Unity.CurrentDetail2 = 0; } +#define UNITY_SET_DETAIL(d1) { Unity.CurrentDetail1 = (d1); Unity.CurrentDetail2 = 0; } +#define UNITY_SET_DETAILS(d1,d2) { Unity.CurrentDetail1 = (d1); Unity.CurrentDetail2 = (d2); } + +#ifndef UNITY_DETAIL1_NAME +#define UNITY_DETAIL1_NAME "Function" +#endif + +#ifndef UNITY_DETAIL2_NAME +#define UNITY_DETAIL2_NAME "Argument" +#endif +#endif + +/*------------------------------------------------------- + * Test Output + *-------------------------------------------------------*/ + +void UnityPrint(const char* string); + +#ifdef UNITY_INCLUDE_PRINT_FORMATTED +void UnityPrintFormatted(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); + +void UnityFail(const char* message, const UNITY_LINE_TYPE line); + +void UnityIgnore(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 UnityAssertEqualFloatArray(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 UnityAssertEqualDoubleArray(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[]; + +/*------------------------------------------------------- + * Test Running Macros + *-------------------------------------------------------*/ + +#ifndef UNITY_EXCLUDE_SETJMP_H +#define TEST_PROTECT() (setjmp(Unity.AbortFrame) == 0) +#define TEST_ABORT() longjmp(Unity.AbortFrame, 1) +#else +#define TEST_PROTECT() 1 +#define TEST_ABORT() return +#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 __STDC_VERSION__ +#if __STDC_VERSION__ >= 199901L +#define RUN_TEST(...) UnityDefaultTestRun(RUN_TEST_FIRST(__VA_ARGS__), RUN_TEST_SECOND(__VA_ARGS__)) +#define RUN_TEST_FIRST(...) RUN_TEST_FIRST_HELPER(__VA_ARGS__, throwaway) +#define RUN_TEST_FIRST_HELPER(first, ...) (first), #first +#define RUN_TEST_SECOND(...) RUN_TEST_SECOND_HELPER(__VA_ARGS__, __LINE__, throwaway) +#define RUN_TEST_SECOND_HELPER(first, second, ...) (second) +#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 + +/*----------------------------------------------- + * 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) if (condition) {} else {UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), (message));} +#define UNITY_TEST_ASSERT_NULL(pointer, line, message) UNITY_TEST_ASSERT(((pointer) == NULL), (UNITY_LINE_TYPE)(line), (message)) +#define UNITY_TEST_ASSERT_NOT_NULL(pointer, line, message) UNITY_TEST_ASSERT(((pointer) != NULL), (UNITY_LINE_TYPE)(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_BITS(mask, expected, actual, line, message) UnityAssertBits((UNITY_INT)(mask), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line)) + +#define UNITY_TEST_ASSERT_GREATER_THAN_INT(threshold, actual, line, message) 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_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_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_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_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_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_UINT16)(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_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_EACH_EQUAL_INT(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT) (expected), sizeof(int)), (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), sizeof(unsigned int)), (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), sizeof(int*)), (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) + +#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_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_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_UINT64_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_HEX64_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_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_EQUAL_FLOAT(expected, actual, 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_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_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_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualFloatArray((UNITY_FLOAT*)(expected), (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) UnityAssertEqualFloatArray(UnityFloatToPtr(expected), (UNITY_FLOAT*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL) +#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_EQUAL_DOUBLE(expected, actual, 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_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_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_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualDoubleArray((UNITY_DOUBLE*)(expected), (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) UnityAssertEqualDoubleArray(UnityDoubleToPtr(expected), (UNITY_DOUBLE*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL) +#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/unity/test/.rubocop.yml b/unity/test/.rubocop.yml new file mode 100644 index 0000000..3bfe31a --- /dev/null +++ b/unity/test/.rubocop.yml @@ -0,0 +1,58 @@ +# This is the configuration used to check the rubocop source code. + +#inherit_from: .rubocop_todo.yml + +AllCops: + TargetRubyVersion: 2.1 + +# These are areas where ThrowTheSwitch's coding style diverges from the Ruby standard +Style/SpecialGlobalVars: + EnforcedStyle: use_perl_names +Style/FormatString: + Enabled: false +Style/GlobalVars: + Enabled: false +Style/RegexpLiteral: + AllowInnerSlashes: true +Style/HashSyntax: + EnforcedStyle: no_mixed_keys + +# This is disabled because it seems to get confused over nested hashes +Layout/AlignHash: + Enabled: false + EnforcedHashRocketStyle: table + EnforcedColonStyle: table + +# We purposefully use these insecure features because they're what makes Ruby awesome +Security/Eval: + Enabled: false +Security/YAMLLoad: + Enabled: false + +# At this point, we're not ready to enforce inline documentation requirements +Style/Documentation: + Enabled: false +Style/DocumentationMethod: + Enabled: false + +# At this point, we're not ready to enforce any metrics +Metrics/AbcSize: + Enabled: false +Metrics/BlockLength: + Enabled: false +Metrics/BlockNesting: + Enabled: false +Metrics/ClassLength: + Enabled: false +Metrics/CyclomaticComplexity: + Enabled: false +Metrics/LineLength: + Enabled: false +Metrics/MethodLength: + Enabled: false +Metrics/ModuleLength: + Enabled: false +Metrics/ParameterLists: + Enabled: false +Metrics/PerceivedComplexity: + Enabled: false diff --git a/unity/test/Makefile b/unity/test/Makefile new file mode 100644 index 0000000..89ece81 --- /dev/null +++ b/unity/test/Makefile @@ -0,0 +1,68 @@ +CC = gcc +ifeq ($(shell uname -s), Darwin) +CC = clang +endif +ifeq ($(findstring clang, $(CC)), clang) +E = -Weverything +CFLAGS += $E -Wno-unknown-warning-option -Wno-missing-prototypes +CFLAGS += -Wno-unused-macros -Wno-padded -Wno-missing-noreturn +endif +CFLAGS += -std=c99 -pedantic -Wall -Wextra -Wconversion -Werror +CFLAGS += -Wno-switch-enum -Wno-double-promotion +CFLAGS += -Wbad-function-cast -Wcast-qual -Wold-style-definition -Wshadow -Wstrict-overflow \ + -Wstrict-prototypes -Wswitch-default -Wundef +#DEBUG = -O0 -g +CFLAGS += $(DEBUG) +DEFINES = -D UNITY_OUTPUT_CHAR=putcharSpy +DEFINES += -D UNITY_OUTPUT_CHAR_HEADER_DECLARATION=putcharSpy\(int\) +DEFINES += -D UNITY_OUTPUT_FLUSH=flushSpy +DEFINES += -D UNITY_OUTPUT_FLUSH_HEADER_DECLARATION=flushSpy\(void\) +DEFINES += $(UNITY_SUPPORT_64) $(UNITY_INCLUDE_DOUBLE) +UNITY_SUPPORT_64 = -D UNITY_SUPPORT_64 +UNITY_INCLUDE_DOUBLE = -D UNITY_INCLUDE_DOUBLE +SRC = ../src/unity.c tests/testunity.c build/testunityRunner.c +INC_DIR = -I ../src +COV_FLAGS = -fprofile-arcs -ftest-coverage -I ../../src +BUILD_DIR = build +TARGET = build/testunity-cov.exe + +# To generate coverage, call 'make -s', the default target runs. +# For verbose output of all the tests, run 'make test'. +default: coverage +.PHONY: default coverage test clean +coverage: DEFINES += -D UNITY_NO_WEAK +coverage: $(BUILD_DIR)/testunityRunner.c + cd $(BUILD_DIR) && \ + $(CC) $(CFLAGS) $(DEFINES) $(foreach i,$(SRC), ../$i) $(COV_FLAGS) -o ../$(TARGET) + rm -f $(BUILD_DIR)/*.gcda + ./$(TARGET) | grep 'Tests\|]]]' -A1 + cd $(BUILD_DIR) && \ + gcov unity.c | head -3 + grep '###' $(BUILD_DIR)/unity.c.gcov -C2 || true + +test: $(BUILD_DIR)/testunityRunner.c + $(CC) $(CFLAGS) $(DEFINES) $(INC_DIR) $(SRC) -o $(TARGET) + ./$(TARGET) + +# Compile only, for testing that preprocessor detection works +UNITY_C_ONLY =-c ../src/unity.c -o $(BUILD_DIR)/unity.o +intDetection: + $(CC) $(CFLAGS) $(INC_DIR) $(UNITY_C_ONLY) -D UNITY_EXCLUDE_STDINT_H + $(CC) $(CFLAGS) $(INC_DIR) $(UNITY_C_ONLY) -D UNITY_EXCLUDE_LIMITS_H + +$(BUILD_DIR)/testunityRunner.c: tests/testunity.c | $(BUILD_DIR) + awk $(AWK_SCRIPT) tests/testunity.c > $@ + +AWK_SCRIPT=\ + '/^void test/{ declarations[d++]=$$0; gsub(/\(?void\)? ?/,""); tests[t++]=$$0; line[u++]=NR } \ + END{ print "\#include \"unity.h\" /* Autogenerated by awk in Makefile */" ; \ + for (i=0; i +#include +#include "CException.h" +#include "funky.h" +#include "stanky.h" +#include + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); +extern void test_TheThirdThingToTest(void); +extern void test_TheFourthThingToTest(void); + + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + tearDown(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + UnityBegin("testdata/testsample.c"); + RUN_TEST(test_TheFirstThingToTest, 21); + RUN_TEST(test_TheSecondThingToTest, 43); + RUN_TEST(test_TheThirdThingToTest, 53); + RUN_TEST(test_TheFourthThingToTest, 58); + + return (UnityEnd()); +} diff --git a/unity/test/expectdata/testsample_def.c b/unity/test/expectdata/testsample_def.c new file mode 100644 index 0000000..b8ad559 --- /dev/null +++ b/unity/test/expectdata/testsample_def.c @@ -0,0 +1,57 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + if (TEST_PROTECT()) \ + { \ + setUp(); \ + TestFunc(); \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + } \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include +#include +#include "funky.h" +#include "stanky.h" +#include + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); +extern void test_TheThirdThingToTest(void); +extern void test_TheFourthThingToTest(void); + + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + tearDown(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + UnityBegin("testdata/testsample.c"); + RUN_TEST(test_TheFirstThingToTest, 21); + RUN_TEST(test_TheSecondThingToTest, 43); + RUN_TEST(test_TheThirdThingToTest, 53); + RUN_TEST(test_TheFourthThingToTest, 58); + + return (UnityEnd()); +} diff --git a/unity/test/expectdata/testsample_head1.c b/unity/test/expectdata/testsample_head1.c new file mode 100644 index 0000000..1d01551 --- /dev/null +++ b/unity/test/expectdata/testsample_head1.c @@ -0,0 +1,55 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + if (TEST_PROTECT()) \ + { \ + setUp(); \ + TestFunc(); \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + } \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include +#include +#include "testsample_head1.h" + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); +extern void test_TheThirdThingToTest(void); +extern void test_TheFourthThingToTest(void); + + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + tearDown(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + UnityBegin("testdata/testsample.c"); + RUN_TEST(test_TheFirstThingToTest, 21); + RUN_TEST(test_TheSecondThingToTest, 43); + RUN_TEST(test_TheThirdThingToTest, 53); + RUN_TEST(test_TheFourthThingToTest, 58); + + return (UnityEnd()); +} diff --git a/unity/test/expectdata/testsample_head1.h b/unity/test/expectdata/testsample_head1.h new file mode 100644 index 0000000..da6b7ab --- /dev/null +++ b/unity/test/expectdata/testsample_head1.h @@ -0,0 +1,15 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ +#ifndef _TESTSAMPLE_HEAD1_H +#define _TESTSAMPLE_HEAD1_H + +#include "unity.h" +#include "funky.h" +#include "stanky.h" +#include + +void test_TheFirstThingToTest(void); +void test_TheSecondThingToTest(void); +void test_TheThirdThingToTest(void); +void test_TheFourthThingToTest(void); +#endif + diff --git a/unity/test/expectdata/testsample_mock_cmd.c b/unity/test/expectdata/testsample_mock_cmd.c new file mode 100644 index 0000000..45a09af --- /dev/null +++ b/unity/test/expectdata/testsample_mock_cmd.c @@ -0,0 +1,80 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + CMock_Init(); \ + UNITY_CLR_DETAILS(); \ + if (TEST_PROTECT()) \ + { \ + CEXCEPTION_T e; \ + Try { \ + setUp(); \ + TestFunc(); \ + } Catch(e) { TEST_ASSERT_EQUAL_HEX32_MESSAGE(CEXCEPTION_NONE, e, "Unhandled Exception!"); } \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + CMock_Verify(); \ + } \ + CMock_Destroy(); \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include "cmock.h" +#include +#include +#include "CException.h" +#include "funky.h" +#include +#include "Mockstanky.h" + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); + + +/*=======Mock Management=====*/ +static void CMock_Init(void) +{ + Mockstanky_Init(); +} +static void CMock_Verify(void) +{ + Mockstanky_Verify(); +} +static void CMock_Destroy(void) +{ + Mockstanky_Destroy(); +} + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + CMock_Verify(); + CMock_Destroy(); + tearDown(); + CMock_Init(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + UnityBegin("testdata/mocksample.c"); + RUN_TEST(test_TheFirstThingToTest, 21); + RUN_TEST(test_TheSecondThingToTest, 43); + + CMock_Guts_MemFreeFinal(); + return (UnityEnd()); +} diff --git a/unity/test/expectdata/testsample_mock_def.c b/unity/test/expectdata/testsample_mock_def.c new file mode 100644 index 0000000..a7a2607 --- /dev/null +++ b/unity/test/expectdata/testsample_mock_def.c @@ -0,0 +1,76 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + CMock_Init(); \ + UNITY_CLR_DETAILS(); \ + if (TEST_PROTECT()) \ + { \ + setUp(); \ + TestFunc(); \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + CMock_Verify(); \ + } \ + CMock_Destroy(); \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include "cmock.h" +#include +#include +#include "funky.h" +#include +#include "Mockstanky.h" + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); + + +/*=======Mock Management=====*/ +static void CMock_Init(void) +{ + Mockstanky_Init(); +} +static void CMock_Verify(void) +{ + Mockstanky_Verify(); +} +static void CMock_Destroy(void) +{ + Mockstanky_Destroy(); +} + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + CMock_Verify(); + CMock_Destroy(); + tearDown(); + CMock_Init(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + UnityBegin("testdata/mocksample.c"); + RUN_TEST(test_TheFirstThingToTest, 21); + RUN_TEST(test_TheSecondThingToTest, 43); + + CMock_Guts_MemFreeFinal(); + return (UnityEnd()); +} diff --git a/unity/test/expectdata/testsample_mock_head1.c b/unity/test/expectdata/testsample_mock_head1.c new file mode 100644 index 0000000..45829fe --- /dev/null +++ b/unity/test/expectdata/testsample_mock_head1.c @@ -0,0 +1,75 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + CMock_Init(); \ + UNITY_CLR_DETAILS(); \ + if (TEST_PROTECT()) \ + { \ + setUp(); \ + TestFunc(); \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + CMock_Verify(); \ + } \ + CMock_Destroy(); \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include "cmock.h" +#include +#include +#include "testsample_mock_head1.h" +#include "Mockstanky.h" + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); + + +/*=======Mock Management=====*/ +static void CMock_Init(void) +{ + Mockstanky_Init(); +} +static void CMock_Verify(void) +{ + Mockstanky_Verify(); +} +static void CMock_Destroy(void) +{ + Mockstanky_Destroy(); +} + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + CMock_Verify(); + CMock_Destroy(); + tearDown(); + CMock_Init(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + UnityBegin("testdata/mocksample.c"); + RUN_TEST(test_TheFirstThingToTest, 21); + RUN_TEST(test_TheSecondThingToTest, 43); + + CMock_Guts_MemFreeFinal(); + return (UnityEnd()); +} diff --git a/unity/test/expectdata/testsample_mock_head1.h b/unity/test/expectdata/testsample_mock_head1.h new file mode 100644 index 0000000..30c509a --- /dev/null +++ b/unity/test/expectdata/testsample_mock_head1.h @@ -0,0 +1,13 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ +#ifndef _TESTSAMPLE_MOCK_HEAD1_H +#define _TESTSAMPLE_MOCK_HEAD1_H + +#include "unity.h" +#include "cmock.h" +#include "funky.h" +#include + +void test_TheFirstThingToTest(void); +void test_TheSecondThingToTest(void); +#endif + diff --git a/unity/test/expectdata/testsample_mock_new1.c b/unity/test/expectdata/testsample_mock_new1.c new file mode 100644 index 0000000..0061822 --- /dev/null +++ b/unity/test/expectdata/testsample_mock_new1.c @@ -0,0 +1,89 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + CMock_Init(); \ + UNITY_CLR_DETAILS(); \ + if (TEST_PROTECT()) \ + { \ + CEXCEPTION_T e; \ + Try { \ + setUp(); \ + TestFunc(); \ + } Catch(e) { TEST_ASSERT_EQUAL_HEX32_MESSAGE(CEXCEPTION_NONE, e, "Unhandled Exception!"); } \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + CMock_Verify(); \ + } \ + CMock_Destroy(); \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include "cmock.h" +#include +#include +#include "CException.h" +#include "one.h" +#include "two.h" +#include "funky.h" +#include +#include "Mockstanky.h" + +int GlobalExpectCount; +int GlobalVerifyOrder; +char* GlobalOrderError; + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); + + +/*=======Mock Management=====*/ +static void CMock_Init(void) +{ + GlobalExpectCount = 0; + GlobalVerifyOrder = 0; + GlobalOrderError = NULL; + Mockstanky_Init(); +} +static void CMock_Verify(void) +{ + Mockstanky_Verify(); +} +static void CMock_Destroy(void) +{ + Mockstanky_Destroy(); +} + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + CMock_Verify(); + CMock_Destroy(); + tearDown(); + CMock_Init(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + UnityBegin("testdata/mocksample.c"); + RUN_TEST(test_TheFirstThingToTest, 21); + RUN_TEST(test_TheSecondThingToTest, 43); + + CMock_Guts_MemFreeFinal(); + return (UnityEnd()); +} diff --git a/unity/test/expectdata/testsample_mock_new2.c b/unity/test/expectdata/testsample_mock_new2.c new file mode 100644 index 0000000..ee63cdc --- /dev/null +++ b/unity/test/expectdata/testsample_mock_new2.c @@ -0,0 +1,89 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + CMock_Init(); \ + UNITY_CLR_DETAILS(); \ + if (TEST_PROTECT()) \ + { \ + setUp(); \ + TestFunc(); \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + CMock_Verify(); \ + } \ + CMock_Destroy(); \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include "cmock.h" +#include +#include +#include "funky.h" +#include +#include "Mockstanky.h" + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); + + +/*=======Mock Management=====*/ +static void CMock_Init(void) +{ + Mockstanky_Init(); +} +static void CMock_Verify(void) +{ + Mockstanky_Verify(); +} +static void CMock_Destroy(void) +{ + Mockstanky_Destroy(); +} + +/*=======Suite Setup=====*/ +static int suite_setup(void) +{ +a_custom_setup(); +} + +/*=======Suite Teardown=====*/ +static int suite_teardown(int num_failures) +{ +a_custom_teardown(); +} + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + CMock_Verify(); + CMock_Destroy(); + tearDown(); + CMock_Init(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + suite_setup(); + UnityBegin("testdata/mocksample.c"); + RUN_TEST(test_TheFirstThingToTest, 21); + RUN_TEST(test_TheSecondThingToTest, 43); + + CMock_Guts_MemFreeFinal(); + return suite_teardown(UnityEnd()); +} diff --git a/unity/test/expectdata/testsample_mock_param.c b/unity/test/expectdata/testsample_mock_param.c new file mode 100644 index 0000000..a42b7de --- /dev/null +++ b/unity/test/expectdata/testsample_mock_param.c @@ -0,0 +1,77 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST_NO_ARGS +#define RUN_TEST(TestFunc, TestLineNum, ...) \ +{ \ + Unity.CurrentTestName = #TestFunc "(" #__VA_ARGS__ ")"; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + CMock_Init(); \ + UNITY_CLR_DETAILS(); \ + if (TEST_PROTECT()) \ + { \ + setUp(); \ + TestFunc(__VA_ARGS__); \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + CMock_Verify(); \ + } \ + CMock_Destroy(); \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include "cmock.h" +#include +#include +#include "funky.h" +#include +#include "Mockstanky.h" + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); + + +/*=======Mock Management=====*/ +static void CMock_Init(void) +{ + Mockstanky_Init(); +} +static void CMock_Verify(void) +{ + Mockstanky_Verify(); +} +static void CMock_Destroy(void) +{ + Mockstanky_Destroy(); +} + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + CMock_Verify(); + CMock_Destroy(); + tearDown(); + CMock_Init(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + UnityBegin("testdata/mocksample.c"); + RUN_TEST(test_TheFirstThingToTest, 21, RUN_TEST_NO_ARGS); + RUN_TEST(test_TheSecondThingToTest, 43, RUN_TEST_NO_ARGS); + + CMock_Guts_MemFreeFinal(); + return (UnityEnd()); +} diff --git a/unity/test/expectdata/testsample_mock_run1.c b/unity/test/expectdata/testsample_mock_run1.c new file mode 100644 index 0000000..0061822 --- /dev/null +++ b/unity/test/expectdata/testsample_mock_run1.c @@ -0,0 +1,89 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + CMock_Init(); \ + UNITY_CLR_DETAILS(); \ + if (TEST_PROTECT()) \ + { \ + CEXCEPTION_T e; \ + Try { \ + setUp(); \ + TestFunc(); \ + } Catch(e) { TEST_ASSERT_EQUAL_HEX32_MESSAGE(CEXCEPTION_NONE, e, "Unhandled Exception!"); } \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + CMock_Verify(); \ + } \ + CMock_Destroy(); \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include "cmock.h" +#include +#include +#include "CException.h" +#include "one.h" +#include "two.h" +#include "funky.h" +#include +#include "Mockstanky.h" + +int GlobalExpectCount; +int GlobalVerifyOrder; +char* GlobalOrderError; + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); + + +/*=======Mock Management=====*/ +static void CMock_Init(void) +{ + GlobalExpectCount = 0; + GlobalVerifyOrder = 0; + GlobalOrderError = NULL; + Mockstanky_Init(); +} +static void CMock_Verify(void) +{ + Mockstanky_Verify(); +} +static void CMock_Destroy(void) +{ + Mockstanky_Destroy(); +} + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + CMock_Verify(); + CMock_Destroy(); + tearDown(); + CMock_Init(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + UnityBegin("testdata/mocksample.c"); + RUN_TEST(test_TheFirstThingToTest, 21); + RUN_TEST(test_TheSecondThingToTest, 43); + + CMock_Guts_MemFreeFinal(); + return (UnityEnd()); +} diff --git a/unity/test/expectdata/testsample_mock_run2.c b/unity/test/expectdata/testsample_mock_run2.c new file mode 100644 index 0000000..ee63cdc --- /dev/null +++ b/unity/test/expectdata/testsample_mock_run2.c @@ -0,0 +1,89 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + CMock_Init(); \ + UNITY_CLR_DETAILS(); \ + if (TEST_PROTECT()) \ + { \ + setUp(); \ + TestFunc(); \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + CMock_Verify(); \ + } \ + CMock_Destroy(); \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include "cmock.h" +#include +#include +#include "funky.h" +#include +#include "Mockstanky.h" + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); + + +/*=======Mock Management=====*/ +static void CMock_Init(void) +{ + Mockstanky_Init(); +} +static void CMock_Verify(void) +{ + Mockstanky_Verify(); +} +static void CMock_Destroy(void) +{ + Mockstanky_Destroy(); +} + +/*=======Suite Setup=====*/ +static int suite_setup(void) +{ +a_custom_setup(); +} + +/*=======Suite Teardown=====*/ +static int suite_teardown(int num_failures) +{ +a_custom_teardown(); +} + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + CMock_Verify(); + CMock_Destroy(); + tearDown(); + CMock_Init(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + suite_setup(); + UnityBegin("testdata/mocksample.c"); + RUN_TEST(test_TheFirstThingToTest, 21); + RUN_TEST(test_TheSecondThingToTest, 43); + + CMock_Guts_MemFreeFinal(); + return suite_teardown(UnityEnd()); +} diff --git a/unity/test/expectdata/testsample_mock_yaml.c b/unity/test/expectdata/testsample_mock_yaml.c new file mode 100644 index 0000000..a24bb5a --- /dev/null +++ b/unity/test/expectdata/testsample_mock_yaml.c @@ -0,0 +1,90 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + CMock_Init(); \ + UNITY_CLR_DETAILS(); \ + if (TEST_PROTECT()) \ + { \ + CEXCEPTION_T e; \ + Try { \ + setUp(); \ + TestFunc(); \ + } Catch(e) { TEST_ASSERT_EQUAL_HEX32_MESSAGE(CEXCEPTION_NONE, e, "Unhandled Exception!"); } \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + CMock_Verify(); \ + } \ + CMock_Destroy(); \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include "cmock.h" +#include +#include +#include "CException.h" +#include "two.h" +#include "three.h" +#include +#include "funky.h" +#include +#include "Mockstanky.h" + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); + + +/*=======Mock Management=====*/ +static void CMock_Init(void) +{ + Mockstanky_Init(); +} +static void CMock_Verify(void) +{ + Mockstanky_Verify(); +} +static void CMock_Destroy(void) +{ + Mockstanky_Destroy(); +} + +/*=======Suite Setup=====*/ +static int suite_setup(void) +{ +a_yaml_setup(); +} + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + CMock_Verify(); + CMock_Destroy(); + tearDown(); + CMock_Init(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + suite_setup(); + UnityBegin("testdata/mocksample.c"); + RUN_TEST(test_TheFirstThingToTest, 21); + RUN_TEST(test_TheSecondThingToTest, 43); + + CMock_Guts_MemFreeFinal(); + return (UnityEnd()); +} diff --git a/unity/test/expectdata/testsample_new1.c b/unity/test/expectdata/testsample_new1.c new file mode 100644 index 0000000..7dcd3fd --- /dev/null +++ b/unity/test/expectdata/testsample_new1.c @@ -0,0 +1,67 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + if (TEST_PROTECT()) \ + { \ + CEXCEPTION_T e; \ + Try { \ + setUp(); \ + TestFunc(); \ + } Catch(e) { TEST_ASSERT_EQUAL_HEX32_MESSAGE(CEXCEPTION_NONE, e, "Unhandled Exception!"); } \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + } \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include +#include +#include "CException.h" +#include "one.h" +#include "two.h" +#include "funky.h" +#include "stanky.h" +#include + +int GlobalExpectCount; +int GlobalVerifyOrder; +char* GlobalOrderError; + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); +extern void test_TheThirdThingToTest(void); +extern void test_TheFourthThingToTest(void); + + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + tearDown(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + UnityBegin("testdata/testsample.c"); + RUN_TEST(test_TheFirstThingToTest, 21); + RUN_TEST(test_TheSecondThingToTest, 43); + RUN_TEST(test_TheThirdThingToTest, 53); + RUN_TEST(test_TheFourthThingToTest, 58); + + return (UnityEnd()); +} diff --git a/unity/test/expectdata/testsample_new2.c b/unity/test/expectdata/testsample_new2.c new file mode 100644 index 0000000..c98c697 --- /dev/null +++ b/unity/test/expectdata/testsample_new2.c @@ -0,0 +1,70 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + if (TEST_PROTECT()) \ + { \ + setUp(); \ + TestFunc(); \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + } \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include +#include +#include "funky.h" +#include "stanky.h" +#include + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); +extern void test_TheThirdThingToTest(void); +extern void test_TheFourthThingToTest(void); + + +/*=======Suite Setup=====*/ +static int suite_setup(void) +{ +a_custom_setup(); +} + +/*=======Suite Teardown=====*/ +static int suite_teardown(int num_failures) +{ +a_custom_teardown(); +} + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + tearDown(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + suite_setup(); + UnityBegin("testdata/testsample.c"); + RUN_TEST(test_TheFirstThingToTest, 21); + RUN_TEST(test_TheSecondThingToTest, 43); + RUN_TEST(test_TheThirdThingToTest, 53); + RUN_TEST(test_TheFourthThingToTest, 58); + + return suite_teardown(UnityEnd()); +} diff --git a/unity/test/expectdata/testsample_param.c b/unity/test/expectdata/testsample_param.c new file mode 100644 index 0000000..adf6c26 --- /dev/null +++ b/unity/test/expectdata/testsample_param.c @@ -0,0 +1,58 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST_NO_ARGS +#define RUN_TEST(TestFunc, TestLineNum, ...) \ +{ \ + Unity.CurrentTestName = #TestFunc "(" #__VA_ARGS__ ")"; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + if (TEST_PROTECT()) \ + { \ + setUp(); \ + TestFunc(__VA_ARGS__); \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + } \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include +#include +#include "funky.h" +#include "stanky.h" +#include + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); +extern void test_TheThirdThingToTest(void); +extern void test_TheFourthThingToTest(void); + + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + tearDown(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + UnityBegin("testdata/testsample.c"); + RUN_TEST(test_TheFirstThingToTest, 21, RUN_TEST_NO_ARGS); + RUN_TEST(test_TheSecondThingToTest, 43, RUN_TEST_NO_ARGS); + RUN_TEST(test_TheThirdThingToTest, 53, RUN_TEST_NO_ARGS); + RUN_TEST(test_TheFourthThingToTest, 58, RUN_TEST_NO_ARGS); + + return (UnityEnd()); +} diff --git a/unity/test/expectdata/testsample_run1.c b/unity/test/expectdata/testsample_run1.c new file mode 100644 index 0000000..7dcd3fd --- /dev/null +++ b/unity/test/expectdata/testsample_run1.c @@ -0,0 +1,67 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + if (TEST_PROTECT()) \ + { \ + CEXCEPTION_T e; \ + Try { \ + setUp(); \ + TestFunc(); \ + } Catch(e) { TEST_ASSERT_EQUAL_HEX32_MESSAGE(CEXCEPTION_NONE, e, "Unhandled Exception!"); } \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + } \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include +#include +#include "CException.h" +#include "one.h" +#include "two.h" +#include "funky.h" +#include "stanky.h" +#include + +int GlobalExpectCount; +int GlobalVerifyOrder; +char* GlobalOrderError; + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); +extern void test_TheThirdThingToTest(void); +extern void test_TheFourthThingToTest(void); + + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + tearDown(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + UnityBegin("testdata/testsample.c"); + RUN_TEST(test_TheFirstThingToTest, 21); + RUN_TEST(test_TheSecondThingToTest, 43); + RUN_TEST(test_TheThirdThingToTest, 53); + RUN_TEST(test_TheFourthThingToTest, 58); + + return (UnityEnd()); +} diff --git a/unity/test/expectdata/testsample_run2.c b/unity/test/expectdata/testsample_run2.c new file mode 100644 index 0000000..c98c697 --- /dev/null +++ b/unity/test/expectdata/testsample_run2.c @@ -0,0 +1,70 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + if (TEST_PROTECT()) \ + { \ + setUp(); \ + TestFunc(); \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + } \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include +#include +#include "funky.h" +#include "stanky.h" +#include + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); +extern void test_TheThirdThingToTest(void); +extern void test_TheFourthThingToTest(void); + + +/*=======Suite Setup=====*/ +static int suite_setup(void) +{ +a_custom_setup(); +} + +/*=======Suite Teardown=====*/ +static int suite_teardown(int num_failures) +{ +a_custom_teardown(); +} + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + tearDown(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + suite_setup(); + UnityBegin("testdata/testsample.c"); + RUN_TEST(test_TheFirstThingToTest, 21); + RUN_TEST(test_TheSecondThingToTest, 43); + RUN_TEST(test_TheThirdThingToTest, 53); + RUN_TEST(test_TheFourthThingToTest, 58); + + return suite_teardown(UnityEnd()); +} diff --git a/unity/test/expectdata/testsample_yaml.c b/unity/test/expectdata/testsample_yaml.c new file mode 100644 index 0000000..3316024 --- /dev/null +++ b/unity/test/expectdata/testsample_yaml.c @@ -0,0 +1,71 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + if (TEST_PROTECT()) \ + { \ + CEXCEPTION_T e; \ + Try { \ + setUp(); \ + TestFunc(); \ + } Catch(e) { TEST_ASSERT_EQUAL_HEX32_MESSAGE(CEXCEPTION_NONE, e, "Unhandled Exception!"); } \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + } \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include +#include +#include "CException.h" +#include "two.h" +#include "three.h" +#include +#include "funky.h" +#include "stanky.h" +#include + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); +extern void test_TheThirdThingToTest(void); +extern void test_TheFourthThingToTest(void); + + +/*=======Suite Setup=====*/ +static int suite_setup(void) +{ +a_yaml_setup(); +} + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + tearDown(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + suite_setup(); + UnityBegin("testdata/testsample.c"); + RUN_TEST(test_TheFirstThingToTest, 21); + RUN_TEST(test_TheSecondThingToTest, 43); + RUN_TEST(test_TheThirdThingToTest, 53); + RUN_TEST(test_TheFourthThingToTest, 58); + + return (UnityEnd()); +} diff --git a/unity/test/rakefile b/unity/test/rakefile new file mode 100644 index 0000000..770fead --- /dev/null +++ b/unity/test/rakefile @@ -0,0 +1,124 @@ +# ========================================== +# Unity Project - A Test Framework for C +# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams +# [Released under MIT License. Please refer to license.txt for details] +# ========================================== + +$verbose = false + +require 'rake' +require 'rake/clean' +require_relative 'rakefile_helper' +require 'rspec/core/rake_task' + +TEMP_DIRS = [ + File.join(__dir__, 'build'), + File.join(__dir__, 'sandbox') +] + +TEMP_DIRS.each do |dir| + directory(dir) + CLOBBER.include(dir) +end + +task :prepare_for_tests => TEMP_DIRS + +include RakefileHelpers + +# Load proper GCC as defult configuration +DEFAULT_CONFIG_FILE = 'gcc_auto_stdint.yml' +configure_toolchain(DEFAULT_CONFIG_FILE) + +desc "Test unity with its own unit tests" +task :unit => [:prepare_for_tests] do + run_tests unit_test_files +end + +desc "Test unity's helper scripts" +task :scripts => [:prepare_for_tests] do + Dir['tests/test_*.rb'].each do |scriptfile| + require "./"+scriptfile + end +end + +desc "Run all rspecs" +RSpec::Core::RakeTask.new(:spec) do |t| + t.pattern = 'spec/**/*_spec.rb' +end + +desc "Generate test summary" +task :summary do + report_summary +end + +desc "Build and test Unity" +task :all => [:clean, :prepare_for_tests, :scripts, :unit, :style, :summary] +task :default => [:clobber, :all] +task :ci => [:no_color, :default] +task :cruise => [:no_color, :default] + +desc "Load configuration" +task :config, :config_file do |t, args| + configure_toolchain(args[:config_file]) +end + +task :no_color do + $colour_output = false +end + +task :verbose do + $verbose = true +end + +namespace :style do + desc "Check style" + task :check do + report "\nVERIFYING RUBY STYLE" + report execute("rubocop ../auto ../examples ../extras --config .rubocop.yml", true) + report "Styling Ruby:PASS" + end + + namespace :check do + Dir['../**/*.rb'].each do |f| + filename = File.basename(f, '.rb') + desc "Check Style of #{filename}" + task filename.to_sym => ['style:clean'] do + report execute("rubocop #{f} --color --config .rubocop.yml", true) + report "Style Checked for #{f}" + end + end + end + + desc "Fix Style of all C Code" + task :c do + run_astyle("../src/*.* ../extras/fixture/src/*.*") + end + + namespace :c do + Dir['../{src,extras/**}/*.{c,h}'].each do |f| + filename = File.basename(f)[0..-3] + desc "Check Style of #{filename}" + task filename.to_sym do + run_astyle f + end + end + end + + desc "Attempt to Autocorrect style" + task :auto => ['style:clean'] do + execute("rubocop ../auto ../examples ../extras --auto-correct --config .rubocop.yml") + report "Autocorrected What We Could." + end + + desc "Update style todo list" + task :todo => ['style:clean'] do + execute("rubocop ../auto ../examples ../extras --auto-gen-config --config .rubocop.yml") + report "Updated Style TODO List." + end + + task :clean do + File.delete(".rubocop_todo.yml") if File.exists?(".rubocop_todo.yml") + end +end + +task :style => ['style:check'] diff --git a/unity/test/rakefile_helper.rb b/unity/test/rakefile_helper.rb new file mode 100644 index 0000000..d4335ec --- /dev/null +++ b/unity/test/rakefile_helper.rb @@ -0,0 +1,260 @@ +# ========================================== +# Unity Project - A Test Framework for C +# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams +# [Released under MIT License. Please refer to license.txt for details] +# ========================================== + +require 'yaml' +require 'fileutils' +require_relative '../auto/unity_test_summary' +require_relative '../auto/generate_test_runner' +require_relative '../auto/colour_reporter' + +module RakefileHelpers + C_EXTENSION = '.c'.freeze + def load_configuration(config_file) + return if $configured + + $cfg_file = "targets/#{config_file}" unless config_file =~ /[\\|\/]/ + $cfg = YAML.load(File.read($cfg_file)) + $colour_output = false unless $cfg['colour'] + $configured = true if config_file != DEFAULT_CONFIG_FILE + end + + def configure_clean + CLEAN.include($cfg['compiler']['build_path'] + '*.*') unless $cfg['compiler']['build_path'].nil? + end + + def configure_toolchain(config_file = DEFAULT_CONFIG_FILE) + config_file += '.yml' unless config_file =~ /\.yml$/ + config_file = config_file unless config_file =~ /[\\|\/]/ + load_configuration(config_file) + configure_clean + end + + def unit_test_files + path = $cfg['compiler']['unit_tests_path'] + 'test*' + C_EXTENSION + path.tr!('\\', '/') + FileList.new(path) + end + + def local_include_dirs + include_dirs = $cfg['compiler']['includes']['items'].dup + include_dirs.delete_if { |dir| dir.is_a?(Array) } + include_dirs + end + + def extract_headers(filename) + includes = [] + lines = File.readlines(filename) + lines.each do |line| + m = line.match(/^\s*#include\s+\"\s*(.+\.[hH])\s*\"/) + includes << m[1] unless m.nil? + end + includes + end + + def find_source_file(header, paths) + paths.each do |dir| + src_file = dir + header.ext(C_EXTENSION) + return src_file if File.exist?(src_file) + end + nil + end + + def tackit(strings) + result = if strings.is_a?(Array) + "\"#{strings.join}\"" + else + strings + end + result + end + + def squash(prefix, items) + result = '' + items.each { |item| result += " #{prefix}#{tackit(item)}" } + result + end + + def should(behave, &block) + if block + puts 'Should ' + behave + yield block + else + puts "UNIMPLEMENTED CASE: Should #{behave}" + end + end + + def build_compiler_fields(inject_defines) + command = tackit($cfg['compiler']['path']) + defines = if $cfg['compiler']['defines']['items'].nil? + '' + else + squash($cfg['compiler']['defines']['prefix'], $cfg['compiler']['defines']['items'] + ['UNITY_OUTPUT_CHAR=putcharSpy'] + ['UNITY_OUTPUT_CHAR_HEADER_DECLARATION=putcharSpy\(int\)'] + inject_defines) + end + options = squash('', $cfg['compiler']['options']) + includes = squash($cfg['compiler']['includes']['prefix'], $cfg['compiler']['includes']['items']) + includes = includes.gsub(/\\ /, ' ').gsub(/\\\"/, '"').gsub(/\\$/, '') # Remove trailing slashes (for IAR) + + { :command => command, :defines => defines, :options => options, :includes => includes } + end + + def compile(file, defines = []) + compiler = build_compiler_fields(defines) + cmd_str = "#{compiler[:command]}#{compiler[:defines]}#{compiler[:options]}#{compiler[:includes]} #{file} " \ + "#{$cfg['compiler']['object_files']['prefix']}#{$cfg['compiler']['object_files']['destination']}" + obj_file = "#{File.basename(file, C_EXTENSION)}#{$cfg['compiler']['object_files']['extension']}" + execute(cmd_str + obj_file) + + obj_file + end + + def build_linker_fields + command = tackit($cfg['linker']['path']) + options = if $cfg['linker']['options'].nil? + '' + else + squash('', $cfg['linker']['options']) + end + includes = if $cfg['linker']['includes'].nil? || $cfg['linker']['includes']['items'].nil? + '' + else + squash($cfg['linker']['includes']['prefix'], $cfg['linker']['includes']['items']) + end.gsub(/\\ /, ' ').gsub(/\\\"/, '"').gsub(/\\$/, '') # Remove trailing slashes (for IAR) + + { :command => command, :options => options, :includes => includes } + end + + def link_it(exe_name, obj_list) + linker = build_linker_fields + cmd_str = "#{linker[:command]}#{linker[:options]}#{linker[:includes]} " + + (obj_list.map { |obj| "#{$cfg['linker']['object_files']['path']}#{obj} " }).join + + $cfg['linker']['bin_files']['prefix'] + ' ' + + $cfg['linker']['bin_files']['destination'] + + exe_name + $cfg['linker']['bin_files']['extension'] + execute(cmd_str) + end + + def build_simulator_fields + return nil if $cfg['simulator'].nil? + command = if $cfg['simulator']['path'].nil? + '' + else + (tackit($cfg['simulator']['path']) + ' ') + end + pre_support = if $cfg['simulator']['pre_support'].nil? + '' + else + squash('', $cfg['simulator']['pre_support']) + end + post_support = if $cfg['simulator']['post_support'].nil? + '' + else + squash('', $cfg['simulator']['post_support']) + end + + { :command => command, :pre_support => pre_support, :post_support => post_support } + end + + def run_astyle(style_what) + report "Styling C Code..." + command = "AStyle " \ + "--style=allman --indent=spaces=4 --indent-switches --indent-preproc-define --indent-preproc-block " \ + "--pad-oper --pad-comma --unpad-paren --pad-header " \ + "--align-pointer=type --align-reference=name " \ + "--add-brackets --mode=c --suffix=none " \ + "#{style_what}" + execute(command, false) + report "Styling C:PASS" + end + + def execute(command_string, ok_to_fail = false) + report command_string if $verbose + output = `#{command_string}`.chomp + report(output) if $verbose && !output.nil? && !output.empty? + raise "Command failed. (Returned #{$?.exitstatus})" if !$?.exitstatus.zero? && !ok_to_fail + output + end + + def report_summary + summary = UnityTestSummary.new + summary.root = __dir__ + results_glob = "#{$cfg['compiler']['build_path']}*.test*" + results_glob.tr!('\\', '/') + results = Dir[results_glob] + summary.targets = results + report summary.run + end + + def run_tests(test_files) + report 'Running Unity system tests...' + + # Tack on TEST define for compiling unit tests + load_configuration($cfg_file) + test_defines = ['TEST'] + $cfg['compiler']['defines']['items'] ||= [] + $cfg['compiler']['defines']['items'] << 'TEST' + + include_dirs = local_include_dirs + + # Build and execute each unit test + test_files.each do |test| + obj_list = [] + + unless $cfg['compiler']['aux_sources'].nil? + $cfg['compiler']['aux_sources'].each do |aux| + obj_list << compile(aux, test_defines) + end + end + + # Detect dependencies and build required modules + extract_headers(test).each do |header| + # Compile corresponding source file if it exists + src_file = find_source_file(header, include_dirs) + + obj_list << compile(src_file, test_defines) unless src_file.nil? + end + + # Build the test runner (generate if configured to do so) + test_base = File.basename(test, C_EXTENSION) + + runner_name = test_base + '_Runner.c' + + runner_path = if $cfg['compiler']['runner_path'].nil? + $cfg['compiler']['build_path'] + runner_name + else + $cfg['compiler']['runner_path'] + runner_name + end + + options = $cfg[:unity] + options[:use_param_tests] = test =~ /parameterized/ ? true : false + UnityTestRunnerGenerator.new(options).run(test, runner_path) + obj_list << compile(runner_path, test_defines) + + # Build the test module + obj_list << compile(test, test_defines) + + # Link the test executable + link_it(test_base, obj_list) + + # Execute unit test and generate results file + simulator = build_simulator_fields + executable = $cfg['linker']['bin_files']['destination'] + test_base + $cfg['linker']['bin_files']['extension'] + cmd_str = if simulator.nil? + executable + else + "#{simulator[:command]} #{simulator[:pre_support]} #{executable} #{simulator[:post_support]}" + end + output = execute(cmd_str) + test_results = $cfg['compiler']['build_path'] + test_base + if output.match(/OK$/m).nil? + test_results += '.testfail' + else + report output unless $verbose # Verbose already prints this line, as does a failure + test_results += '.testpass' + end + File.open(test_results, 'w') { |f| f.print output } + end + end +end diff --git a/unity/test/spec/generate_module_existing_file_spec.rb b/unity/test/spec/generate_module_existing_file_spec.rb new file mode 100644 index 0000000..74e7fc8 --- /dev/null +++ b/unity/test/spec/generate_module_existing_file_spec.rb @@ -0,0 +1,158 @@ + +require '../auto/generate_module.rb' +require 'fileutils' + +def touch_src(file) + FileUtils.touch "sandbox/src/#{file}" +end + +def touch_test(file) + FileUtils.touch "sandbox/test/#{file}" +end + +def create_src_with_known_content(file) + File.open("sandbox/src/#{file}", "w") {|f| f.write("the original #{file}")} +end + +def create_test_with_known_content(file) + File.open("sandbox/test/#{file}", "w") {|f| f.write("the original #{file}")} +end + +def expect_src_content_didnt_change(file) + expect(File.read("sandbox/src/#{file}")).to eq("the original #{file}") +end + +def expect_test_content_didnt_change(file) + expect(File.read("sandbox/test/#{file}")).to eq("the original #{file}") +end + +def expect_src_file_to_exist(file) + expect(File.exist?("sandbox/src/#{file}")).to be true +end + +def expect_test_file_to_exist(file) + expect(File.exist?("sandbox/test/#{file}")).to be true +end + +describe "UnityModuleGenerator" do + + before do + # clean sandbox and setup our "project" folders + FileUtils.rm_rf "sandbox" + FileUtils.mkdir_p "sandbox" + FileUtils.mkdir_p "sandbox/src" + FileUtils.mkdir_p "sandbox/test" + + @options = { + :path_src => "sandbox/src", + :path_tst => "sandbox/test", + } + end + + context "with src pattern" do + before do + @options[:pattern] = "src" + end + + it "fails when all files already exist" do + # create an existing triad of files + touch_src "meh.c" + touch_src "meh.h" + touch_test "Testmeh.c" + expect { + UnityModuleGenerator.new(@options).generate("meh") + }.to raise_error("ERROR: File meh already exists. Exiting.") + end + + it "creates the test file if the source and header files exist" do + # Create the existing files. + touch_src "meh.c" + touch_src "meh.h" + + UnityModuleGenerator.new(@options).generate("meh") + + expect_test_file_to_exist "Testmeh.c" + end + + it "does not alter existing files" do + # Create some files with known content. + create_src_with_known_content "meh.c" + create_src_with_known_content "meh.h" + + UnityModuleGenerator.new(@options).generate("meh") + + expect_src_content_didnt_change "meh.c" + expect_src_content_didnt_change "meh.c" + end + + it "does not alter existing test files" do + # Create some files with known content. + create_test_with_known_content "Testmeh.c" + + UnityModuleGenerator.new(@options).generate("meh") + + expect_test_content_didnt_change "Testmeh.c" + end + + end + + context "with mch pattern" do + before do + @options[:pattern] = "mch" + end + + it "fails when all files exist" do + touch_src "meh_model.c" + touch_src "meh_conductor.c" + touch_src "meh_hardware.c" + touch_src "meh_model.h" + touch_src "meh_conductor.h" + touch_src "meh_hardware.h" + touch_test "Testmeh_model.c" + touch_test "Testmeh_conductor.c" + touch_test "Testmeh_hardware.c" + expect { + UnityModuleGenerator.new(@options).generate("meh") + }.to raise_error("ERROR: File meh_model already exists. Exiting.") + end + + it "creates files that don't exist" do + touch_src "meh_model.c" + touch_src "meh_conductor.c" + touch_src "meh_hardware.c" + touch_src "meh_model.h" + touch_src "meh_conductor.h" + + UnityModuleGenerator.new(@options).generate("meh") + + expect_src_file_to_exist "meh_hardware.h" + expect_test_file_to_exist "Testmeh_model.c" + expect_test_file_to_exist "Testmeh_conductor.c" + expect_test_file_to_exist "Testmeh_hardware.c" + end + + it "does not alter existing source files" do + create_src_with_known_content "meh_model.c" + create_src_with_known_content "meh_model.c" + create_src_with_known_content "meh_model.c" + create_src_with_known_content "meh_model.h" + create_src_with_known_content "meh_model.c" + + UnityModuleGenerator.new(@options).generate("meh") + + expect_src_content_didnt_change "meh_model.c" + expect_src_content_didnt_change "meh_model.c" + expect_src_content_didnt_change "meh_model.c" + expect_src_content_didnt_change "meh_model.c" + end + + it "does not alter existing test files" do + create_test_with_known_content "Testmeh_model.c" + + UnityModuleGenerator.new(@options).generate("meh") + + expect_test_content_didnt_change "Testmeh_model.c" + end + + end +end diff --git a/unity/test/targets/clang_file.yml b/unity/test/targets/clang_file.yml new file mode 100644 index 0000000..df1bd24 --- /dev/null +++ b/unity/test/targets/clang_file.yml @@ -0,0 +1,78 @@ +--- +compiler: + path: clang + source_path: '../src/' + unit_tests_path: &unit_tests_path 'tests/' + build_path: &build_path 'build/' + options: + - '-c' + - '-Wall' + - '-Wextra' + - '-Werror' + - '-Wcast-qual' + - '-Wconversion' + - '-Wdisabled-optimization' + - '-Wformat=2' + - '-Winit-self' + - '-Winline' + - '-Winvalid-pch' + - '-Wmissing-include-dirs' + - '-Wnonnull' + - '-Wpacked' + - '-Wpointer-arith' + - '-Wswitch-default' + - '-Wstrict-aliasing' + - '-Wstrict-overflow=5' + - '-Wuninitialized' + - '-Wunused' +# - '-Wunreachable-code' + - '-Wreturn-type' + - '-Wshadow' + - '-Wundef' + - '-Wwrite-strings' + - '-Wno-nested-externs' + - '-Wno-unused-parameter' + - '-Wno-variadic-macros' + - '-Wbad-function-cast' + - '-fms-extensions' + - '-fno-omit-frame-pointer' + - '-ffloat-store' + - '-fno-common' + - '-fstrict-aliasing' + - '-std=gnu99' + - '-pedantic' + - '-O0' + includes: + prefix: '-I' + items: + - 'src/' + - '../src/' + - 'testdata/' + - *unit_tests_path + defines: + prefix: '-D' + items: + - UNITY_INCLUDE_DOUBLE + - UNITY_SUPPORT_64 + - UNITY_OUTPUT_RESULTS_FILE + object_files: + prefix: '-o' + extension: '.o' + destination: *build_path +linker: + path: clang + options: + - -lm + - '-m64' + includes: + prefix: '-I' + object_files: + path: *build_path + extension: '.o' + bin_files: + prefix: '-o' + extension: '.exe' + destination: *build_path +colour: true +:unity: + :plugins: [] diff --git a/unity/test/targets/clang_strict.yml b/unity/test/targets/clang_strict.yml new file mode 100644 index 0000000..ee05b2a --- /dev/null +++ b/unity/test/targets/clang_strict.yml @@ -0,0 +1,78 @@ +--- +compiler: + path: clang + source_path: '../src/' + unit_tests_path: &unit_tests_path 'tests/' + build_path: &build_path 'build/' + options: + - '-c' + - '-Wall' + - '-Wextra' + - '-Werror' + - '-Wcast-qual' + - '-Wconversion' + - '-Wdisabled-optimization' + - '-Wformat=2' + - '-Winit-self' + - '-Winline' + - '-Winvalid-pch' + - '-Wmissing-include-dirs' + - '-Wnonnull' + - '-Wpacked' + - '-Wpointer-arith' + - '-Wswitch-default' + - '-Wstrict-aliasing' + - '-Wstrict-overflow=5' + - '-Wuninitialized' + - '-Wunused' +# - '-Wunreachable-code' + - '-Wreturn-type' + - '-Wshadow' + - '-Wundef' + - '-Wwrite-strings' + - '-Wno-nested-externs' + - '-Wno-unused-parameter' + - '-Wno-variadic-macros' + - '-Wbad-function-cast' + - '-fms-extensions' + - '-fno-omit-frame-pointer' + #- '-ffloat-store' + - '-fno-common' + - '-fstrict-aliasing' + - '-std=gnu99' + - '-pedantic' + - '-O0' + includes: + prefix: '-I' + items: + - 'src/' + - '../src/' + - 'testdata/' + - *unit_tests_path + defines: + prefix: '-D' + items: + - UNITY_INCLUDE_DOUBLE + - UNITY_SUPPORT_TEST_CASES + - UNITY_SUPPORT_64 + object_files: + prefix: '-o' + extension: '.o' + destination: *build_path +linker: + path: clang + options: + - -lm + - '-m64' + includes: + prefix: '-I' + object_files: + path: *build_path + extension: '.o' + bin_files: + prefix: '-o' + extension: '.exe' + destination: *build_path +colour: true +:unity: + :plugins: [] diff --git a/unity/test/targets/gcc_32.yml b/unity/test/targets/gcc_32.yml new file mode 100644 index 0000000..ec1165d --- /dev/null +++ b/unity/test/targets/gcc_32.yml @@ -0,0 +1,49 @@ +compiler: + path: gcc + source_path: '../src/' + unit_tests_path: &unit_tests_path 'tests/' + build_path: &build_path 'build/' + options: + - '-c' + - '-m32' + - '-Wall' + - '-Wno-address' + - '-std=c99' + - '-pedantic' + includes: + prefix: '-I' + items: + - 'src/' + - '../src/' + - 'testdata/' + - *unit_tests_path + defines: + prefix: '-D' + items: + - UNITY_EXCLUDE_STDINT_H + - UNITY_EXCLUDE_LIMITS_H + - UNITY_INCLUDE_DOUBLE + - UNITY_SUPPORT_TEST_CASES + - UNITY_INT_WIDTH=32 + - UNITY_LONG_WIDTH=32 + object_files: + prefix: '-o' + extension: '.o' + destination: *build_path +linker: + path: gcc + options: + - -lm + - '-m32' + includes: + prefix: '-I' + object_files: + path: *build_path + extension: '.o' + bin_files: + prefix: '-o' + extension: '.exe' + destination: *build_path +colour: true +:unity: + :plugins: [] diff --git a/unity/test/targets/gcc_64.yml b/unity/test/targets/gcc_64.yml new file mode 100644 index 0000000..0e273de --- /dev/null +++ b/unity/test/targets/gcc_64.yml @@ -0,0 +1,50 @@ +compiler: + path: gcc + source_path: '../src/' + unit_tests_path: &unit_tests_path 'tests/' + build_path: &build_path 'build/' + options: + - '-c' + - '-m64' + - '-Wall' + - '-Wno-address' + - '-std=c99' + - '-pedantic' + includes: + prefix: '-I' + items: + - 'src/' + - '../src/' + - 'testdata/' + - *unit_tests_path + defines: + prefix: '-D' + items: + - UNITY_EXCLUDE_STDINT_H + - UNITY_EXCLUDE_LIMITS_H + - UNITY_INCLUDE_DOUBLE + - UNITY_SUPPORT_TEST_CASES + - UNITY_SUPPORT_64 + - UNITY_INT_WIDTH=32 + - UNITY_LONG_WIDTH=64 + object_files: + prefix: '-o' + extension: '.o' + destination: *build_path +linker: + path: gcc + options: + - -lm + - '-m64' + includes: + prefix: '-I' + object_files: + path: *build_path + extension: '.o' + bin_files: + prefix: '-o' + extension: '.exe' + destination: *build_path +colour: true +:unity: + :plugins: [] diff --git a/unity/test/targets/gcc_auto_limits.yml b/unity/test/targets/gcc_auto_limits.yml new file mode 100644 index 0000000..40088ac --- /dev/null +++ b/unity/test/targets/gcc_auto_limits.yml @@ -0,0 +1,47 @@ +compiler: + path: gcc + source_path: '../src/' + unit_tests_path: &unit_tests_path 'tests/' + build_path: &build_path 'build/' + options: + - '-c' + - '-m64' + - '-Wall' + - '-Wno-address' + - '-std=c99' + - '-pedantic' + includes: + prefix: '-I' + items: + - 'src/' + - '../src/' + - 'testdata/' + - *unit_tests_path + defines: + prefix: '-D' + items: + - UNITY_EXCLUDE_STDINT_H + - UNITY_INCLUDE_DOUBLE + - UNITY_SUPPORT_TEST_CASES + - UNITY_SUPPORT_64 + object_files: + prefix: '-o' + extension: '.o' + destination: *build_path +linker: + path: gcc + options: + - -lm + - '-m64' + includes: + prefix: '-I' + object_files: + path: *build_path + extension: '.o' + bin_files: + prefix: '-o' + extension: '.exe' + destination: *build_path +colour: true +:unity: + :plugins: [] diff --git a/unity/test/targets/gcc_auto_stdint.yml b/unity/test/targets/gcc_auto_stdint.yml new file mode 100644 index 0000000..f12165c --- /dev/null +++ b/unity/test/targets/gcc_auto_stdint.yml @@ -0,0 +1,59 @@ +compiler: + path: gcc + source_path: '../src/' + unit_tests_path: &unit_tests_path 'tests/' + build_path: &build_path 'build/' + options: + - '-c' + - '-m64' + - '-Wall' + - '-Wno-address' + - '-std=c99' + - '-pedantic' + - '-Wextra' + - '-Werror' + - '-Wpointer-arith' + - '-Wcast-align' + - '-Wwrite-strings' + - '-Wswitch-default' + - '-Wunreachable-code' + - '-Winit-self' + - '-Wmissing-field-initializers' + - '-Wno-unknown-pragmas' + - '-Wstrict-prototypes' + - '-Wundef' + - '-Wold-style-definition' + includes: + prefix: '-I' + items: + - 'src/' + - '../src/' + - 'testdata/' + - *unit_tests_path + defines: + prefix: '-D' + items: + - UNITY_INCLUDE_DOUBLE + - UNITY_SUPPORT_TEST_CASES + - UNITY_SUPPORT_64 + object_files: + prefix: '-o' + extension: '.o' + destination: *build_path +linker: + path: gcc + options: + - -lm + - '-m64' + includes: + prefix: '-I' + object_files: + path: *build_path + extension: '.o' + bin_files: + prefix: '-o' + extension: '.exe' + destination: *build_path +colour: true +:unity: + :plugins: [] diff --git a/unity/test/targets/gcc_manual_math.yml b/unity/test/targets/gcc_manual_math.yml new file mode 100644 index 0000000..b379e3f --- /dev/null +++ b/unity/test/targets/gcc_manual_math.yml @@ -0,0 +1,47 @@ +compiler: + path: gcc + source_path: '../src/' + unit_tests_path: &unit_tests_path 'tests/' + build_path: &build_path 'build/' + options: + - '-c' + - '-m64' + - '-Wall' + - '-Wno-address' + - '-std=c99' + - '-pedantic' + includes: + prefix: '-I' + items: + - 'src/' + - '../src/' + - 'testdata/' + - *unit_tests_path + defines: + prefix: '-D' + items: + - UNITY_EXCLUDE_MATH_H + - UNITY_INCLUDE_DOUBLE + - UNITY_SUPPORT_TEST_CASES + - UNITY_SUPPORT_64 + object_files: + prefix: '-o' + extension: '.o' + destination: *build_path +linker: + path: gcc + options: + - -lm + - '-m64' + includes: + prefix: '-I' + object_files: + path: *build_path + extension: '.o' + bin_files: + prefix: '-o' + extension: '.exe' + destination: *build_path +colour: true +:unity: + :plugins: [] diff --git a/unity/test/targets/hitech_picc18.yml b/unity/test/targets/hitech_picc18.yml new file mode 100644 index 0000000..2fd4aa3 --- /dev/null +++ b/unity/test/targets/hitech_picc18.yml @@ -0,0 +1,101 @@ +# rumor has it that this yaml file works for the standard edition of the +# hitech PICC18 compiler, but not the pro version. +# +compiler: + path: cd build && picc18 + source_path: '..\src\' + unit_tests_path: &unit_tests_path 'tests\' + build_path: &build_path 'build\' + options: + - --chip=18F87J10 + - --ide=hitide + - --q #quiet please + - --asmlist + - --codeoffset=0 + - --emi=wordwrite # External memory interface protocol + - --warn=0 # allow all normal warning messages + - --errors=10 # Number of errors before aborting compile + - --char=unsigned + - -Bl # Large memory model + - -G # generate symbol file + - --cp=16 # 16-bit pointers + - --double=24 + - -N255 # 255-char symbol names + - --opt=none # Do not use any compiler optimziations + - -c # compile only + - -M + includes: + prefix: '-I' + items: + - 'c:/Projects/NexGen/Prototypes/CMockTest/src/' + - 'c:/Projects/NexGen/Prototypes/CMockTest/mocks/' + - 'c:/CMock/src/' + - 'c:/CMock/examples/src/' + - 'c:/CMock/vendor/unity/src/' + - 'c:/CMock/vendor/unity/examples/helper/' + - *unit_tests_path + defines: + prefix: '-D' + items: + - UNITY_INT_WIDTH=16 + - UNITY_POINTER_WIDTH=16 + - CMOCK_MEM_STATIC + - CMOCK_MEM_SIZE=3000 + - UNITY_SUPPORT_TEST_CASES + - _PICC18 + object_files: + # prefix: '-O' # Hi-Tech doesn't want a prefix. They key off of filename .extensions, instead + extension: '.obj' + destination: *build_path + +linker: + path: cd build && picc18 + options: + - --chip=18F87J10 + - --ide=hitide + - --cp=24 # 24-bit pointers. Is this needed for linker?? + - --double=24 # Is this needed for linker?? + - -Lw # Scan the pic87*w.lib in the lib/ of the compiler installation directory + - --summary=mem,file # info listing + - --summary=+psect + - --summary=+hex + - --output=+intel + - --output=+mcof + - --runtime=+init # Directs startup code to copy idata, ibigdata and ifardata psects from ROM to RAM. + - --runtime=+clear # Directs startup code to clear bss, bigbss, rbss and farbss psects + - --runtime=+clib # link in the c-runtime + - --runtime=+keep # Keep the generated startup src after its obj is linked + - -G # Generate src-level symbol file + - -MIWasTheLastToBuild.map + - --warn=0 # allow all normal warning messages + - -Bl # Large memory model (probably not needed for linking) + includes: + prefix: '-I' + object_files: + path: *build_path + extension: '.obj' + bin_files: + prefix: '-O' + extension: '.hex' + destination: *build_path + +simulator: + path: + pre_support: + - 'java -client -jar ' # note space + - ['C:\Program Files\HI-TECH Software\HI-TIDE\3.15\lib\', 'simpic18.jar'] + - 18F87J10 + post_support: + +:cmock: + :plugins: [] + :includes: + - Types.h + :suite_teardown: | + if (num_failures) + _FAILED_TEST(); + else + _PASSED_TESTS(); + return 0; + +colour: true diff --git a/unity/test/targets/iar_arm_v4.yml b/unity/test/targets/iar_arm_v4.yml new file mode 100644 index 0000000..2f9f881 --- /dev/null +++ b/unity/test/targets/iar_arm_v4.yml @@ -0,0 +1,90 @@ +tools_root: &tools_root 'C:\Program Files\IAR Systems\Embedded Workbench 4.0 Kickstart\' +compiler: + path: [*tools_root, 'arm\bin\iccarm.exe'] + source_path: '..\src\' + unit_tests_path: &unit_tests_path 'tests\' + build_path: &build_path 'build\' + options: + - --dlib_config + - [*tools_root, 'arm\lib\dl4tptinl8n.h'] + - -z3 + - --no_cse + - --no_unroll + - --no_inline + - --no_code_motion + - --no_tbaa + - --no_clustering + - --no_scheduling + - --debug + - --cpu_mode thumb + - --endian little + - --cpu ARM7TDMI + - --stack_align 4 + - --interwork + - -e + - --silent + - --warnings_are_errors + - --fpu None + - --diag_suppress Pa050 + includes: + prefix: '-I' + items: + - [*tools_root, 'arm\inc\'] + - 'src\' + - '..\src\' + - 'testdata/' + - *unit_tests_path + - 'vendor\unity\src\' + defines: + prefix: '-D' + items: + - UNITY_SUPPORT_64 + - 'UNITY_SUPPORT_TEST_CASES' + object_files: + prefix: '-o' + extension: '.r79' + destination: *build_path +linker: + path: [*tools_root, 'common\bin\xlink.exe'] + options: + - -rt + - [*tools_root, 'arm\lib\dl4tptinl8n.r79'] + - -D_L_EXTMEM_START=0 + - -D_L_EXTMEM_SIZE=0 + - -D_L_HEAP_SIZE=120 + - -D_L_STACK_SIZE=32 + - -e_small_write=_formatted_write + - -s + - __program_start + - -f + - [*tools_root, '\arm\config\lnkarm.xcl'] + includes: + prefix: '-I' + items: + - [*tools_root, 'arm\config\'] + - [*tools_root, 'arm\lib\'] + object_files: + path: *build_path + extension: '.r79' + bin_files: + prefix: '-o' + extension: '.d79' + destination: *build_path +simulator: + path: [*tools_root, 'common\bin\CSpyBat.exe'] + pre_support: + - --silent + - [*tools_root, 'arm\bin\armproc.dll'] + - [*tools_root, 'arm\bin\armsim.dll'] + post_support: + - --plugin + - [*tools_root, 'arm\bin\armbat.dll'] + - --backend + - -B + - -p + - [*tools_root, 'arm\config\ioat91sam7X256.ddf'] + - -d + - sim +colour: true +:unity: + :plugins: [] diff --git a/unity/test/targets/iar_arm_v5.yml b/unity/test/targets/iar_arm_v5.yml new file mode 100644 index 0000000..223f1a6 --- /dev/null +++ b/unity/test/targets/iar_arm_v5.yml @@ -0,0 +1,80 @@ +tools_root: &tools_root 'C:\Program Files\IAR Systems\Embedded Workbench 5.3\' +compiler: + path: [*tools_root, 'arm\bin\iccarm.exe'] + source_path: '..\src\' + unit_tests_path: &unit_tests_path 'tests\' + build_path: &build_path 'build\' + options: + - --dlib_config + - [*tools_root, 'arm\inc\DLib_Config_Normal.h'] + - --no_cse + - --no_unroll + - --no_inline + - --no_code_motion + - --no_tbaa + - --no_clustering + - --no_scheduling + - --debug + - --cpu_mode thumb + - --endian=little + - --cpu=ARM7TDMI + - --interwork + - --warnings_are_errors + - --fpu=None + - --diag_suppress=Pa050 + - --diag_suppress=Pe111 + - -e + - -On + includes: + prefix: '-I' + items: + - [*tools_root, 'arm\inc\'] + - 'src\' + - '..\src\' + - 'testdata/' + - *unit_tests_path + - 'vendor\unity\src\' + - 'iar\iar_v5\incIAR\' + defines: + prefix: '-D' + items: + - UNITY_SUPPORT_64 + - 'UNITY_SUPPORT_TEST_CASES' + object_files: + prefix: '-o' + extension: '.r79' + destination: *build_path +linker: + path: [*tools_root, 'arm\bin\ilinkarm.exe'] + options: + - --redirect _Printf=_PrintfLarge + - --redirect _Scanf=_ScanfSmall + - --semihosting + - --entry __iar_program_start + - --config + - [*tools_root, 'arm\config\generic.icf'] + object_files: + path: *build_path + extension: '.o' + bin_files: + prefix: '-o' + extension: '.out' + destination: *build_path +simulator: + path: [*tools_root, 'common\bin\CSpyBat.exe'] + pre_support: + - --silent + - [*tools_root, 'arm\bin\armproc.dll'] + - [*tools_root, 'arm\bin\armsim.dll'] + post_support: + - --plugin + - [*tools_root, 'arm\bin\armbat.dll'] + - --backend + - -B + - -p + - [*tools_root, 'arm\config\debugger\atmel\ioat91sam7X256.ddf'] + - -d + - sim +colour: true +:unity: + :plugins: [] diff --git a/unity/test/targets/iar_arm_v5_3.yml b/unity/test/targets/iar_arm_v5_3.yml new file mode 100644 index 0000000..223f1a6 --- /dev/null +++ b/unity/test/targets/iar_arm_v5_3.yml @@ -0,0 +1,80 @@ +tools_root: &tools_root 'C:\Program Files\IAR Systems\Embedded Workbench 5.3\' +compiler: + path: [*tools_root, 'arm\bin\iccarm.exe'] + source_path: '..\src\' + unit_tests_path: &unit_tests_path 'tests\' + build_path: &build_path 'build\' + options: + - --dlib_config + - [*tools_root, 'arm\inc\DLib_Config_Normal.h'] + - --no_cse + - --no_unroll + - --no_inline + - --no_code_motion + - --no_tbaa + - --no_clustering + - --no_scheduling + - --debug + - --cpu_mode thumb + - --endian=little + - --cpu=ARM7TDMI + - --interwork + - --warnings_are_errors + - --fpu=None + - --diag_suppress=Pa050 + - --diag_suppress=Pe111 + - -e + - -On + includes: + prefix: '-I' + items: + - [*tools_root, 'arm\inc\'] + - 'src\' + - '..\src\' + - 'testdata/' + - *unit_tests_path + - 'vendor\unity\src\' + - 'iar\iar_v5\incIAR\' + defines: + prefix: '-D' + items: + - UNITY_SUPPORT_64 + - 'UNITY_SUPPORT_TEST_CASES' + object_files: + prefix: '-o' + extension: '.r79' + destination: *build_path +linker: + path: [*tools_root, 'arm\bin\ilinkarm.exe'] + options: + - --redirect _Printf=_PrintfLarge + - --redirect _Scanf=_ScanfSmall + - --semihosting + - --entry __iar_program_start + - --config + - [*tools_root, 'arm\config\generic.icf'] + object_files: + path: *build_path + extension: '.o' + bin_files: + prefix: '-o' + extension: '.out' + destination: *build_path +simulator: + path: [*tools_root, 'common\bin\CSpyBat.exe'] + pre_support: + - --silent + - [*tools_root, 'arm\bin\armproc.dll'] + - [*tools_root, 'arm\bin\armsim.dll'] + post_support: + - --plugin + - [*tools_root, 'arm\bin\armbat.dll'] + - --backend + - -B + - -p + - [*tools_root, 'arm\config\debugger\atmel\ioat91sam7X256.ddf'] + - -d + - sim +colour: true +:unity: + :plugins: [] diff --git a/unity/test/targets/iar_armcortex_LM3S9B92_v5_4.yml b/unity/test/targets/iar_armcortex_LM3S9B92_v5_4.yml new file mode 100644 index 0000000..c79bacf --- /dev/null +++ b/unity/test/targets/iar_armcortex_LM3S9B92_v5_4.yml @@ -0,0 +1,94 @@ +#Default tool path for IAR 5.4 on Windows XP 64bit +tools_root: &tools_root 'C:\Program Files (x86)\IAR Systems\Embedded Workbench 5.4 Kickstart\' +compiler: + path: [*tools_root, 'arm\bin\iccarm.exe'] + source_path: '..\src\' + unit_tests_path: &unit_tests_path 'tests\' + build_path: &build_path 'build\' + options: + - --diag_suppress=Pa050 + #- --diag_suppress=Pe111 + - --debug + - --endian=little + - --cpu=Cortex-M3 + - --no_path_in_file_macros + - -e + - --fpu=None + - --dlib_config + - [*tools_root, 'arm\inc\DLib_Config_Normal.h'] + #- --preinclude --preinclude C:\Vss\T2 Working\common\system.h + - --interwork + - --warnings_are_errors +# - Ohz + - -Oh +# - --no_cse +# - --no_unroll +# - --no_inline +# - --no_code_motion +# - --no_tbaa +# - --no_clustering +# - --no_scheduling + + includes: + prefix: '-I' + items: + - [*tools_root, 'arm\inc\'] + - 'src\' + - '..\src\' + - 'testdata/' + - *unit_tests_path + - 'vendor\unity\src\' + - 'iar\iar_v5\incIAR\' + defines: + prefix: '-D' + items: + - ewarm + - PART_LM3S9B92 + - TARGET_IS_TEMPEST_RB1 + - USE_ROM_DRIVERS + - UART_BUFFERED + - UNITY_SUPPORT_64 + object_files: + prefix: '-o' + extension: '.r79' + destination: *build_path +linker: + path: [*tools_root, 'arm\bin\ilinkarm.exe'] + options: + - --redirect _Printf=_PrintfLarge + - --redirect _Scanf=_ScanfSmall + - --semihosting + - --entry __iar_program_start + - --config + - [*tools_root, 'arm\config\generic.icf'] +# - ['C:\Temp\lm3s9b92.icf'] + object_files: + path: *build_path + extension: '.o' + bin_files: + prefix: '-o' + extension: '.out' + destination: *build_path +simulator: + path: [*tools_root, 'common\bin\CSpyBat.exe'] + pre_support: + #- --silent + - [*tools_root, 'arm\bin\armproc.dll'] + - [*tools_root, 'arm\bin\armsim2.dll'] + post_support: + - --plugin + - [*tools_root, 'arm\bin\armbat.dll'] + - --backend + - -B + - --endian=little + - --cpu=Cortex-M3 + - --fpu=None + - -p + - [*tools_root, 'arm\config\debugger\TexasInstruments\iolm3sxxxx.ddf'] + - --semihosting + - --device=LM3SxBxx + #- -d + #- sim +colour: true +:unity: + :plugins: [] diff --git a/unity/test/targets/iar_cortexm3_v5.yml b/unity/test/targets/iar_cortexm3_v5.yml new file mode 100644 index 0000000..973de94 --- /dev/null +++ b/unity/test/targets/iar_cortexm3_v5.yml @@ -0,0 +1,84 @@ +# unit testing under iar compiler / simulator for STM32 Cortex-M3 + +tools_root: &tools_root 'C:\Program Files\IAR Systems\Embedded Workbench 5.4\' +compiler: + path: [*tools_root, 'arm\bin\iccarm.exe'] + source_path: '..\src\' + unit_tests_path: &unit_tests_path 'tests\' + build_path: &build_path 'build\' + options: + - --dlib_config + - [*tools_root, 'arm\inc\DLib_Config_Normal.h'] + - --no_cse + - --no_unroll + - --no_inline + - --no_code_motion + - --no_tbaa + - --no_clustering + - --no_scheduling + - --debug + - --cpu_mode thumb + - --endian=little + - --cpu=Cortex-M3 + - --interwork + - --warnings_are_errors + - --fpu=None + - --diag_suppress=Pa050 + - --diag_suppress=Pe111 + - -e + - -On + includes: + prefix: '-I' + items: + - [*tools_root, 'arm\inc\'] + - 'src\' + - '..\src\' + - 'testdata/' + - *unit_tests_path + - 'vendor\unity\src\' + - 'iar\iar_v5\incIAR\' + defines: + prefix: '-D' + items: + - 'IAR' + - 'UNITY_SUPPORT_64' + - 'UNITY_SUPPORT_TEST_CASES' + object_files: + prefix: '-o' + extension: '.r79' + destination: *build_path +linker: + path: [*tools_root, 'arm\bin\ilinkarm.exe'] + options: + - --redirect _Printf=_PrintfLarge + - --redirect _Scanf=_ScanfSmall + - --semihosting + - --entry __iar_program_start + - --config + - [*tools_root, 'arm\config\generic_cortex.icf'] + object_files: + path: *build_path + extension: '.o' + bin_files: + prefix: '-o' + extension: '.out' + destination: *build_path +simulator: + path: [*tools_root, 'common\bin\CSpyBat.exe'] + pre_support: + - --silent + - [*tools_root, 'arm\bin\armproc.dll'] + - [*tools_root, 'arm\bin\armsim.dll'] + post_support: + - --plugin + - [*tools_root, 'arm\bin\armbat.dll'] + - --backend + - -B + - -p + - [*tools_root, 'arm\config\debugger\ST\iostm32f107xx.ddf'] + - --cpu=Cortex-M3 + - -d + - sim +colour: true +:unity: + :plugins: [] diff --git a/unity/test/targets/iar_msp430.yml b/unity/test/targets/iar_msp430.yml new file mode 100644 index 0000000..4563af9 --- /dev/null +++ b/unity/test/targets/iar_msp430.yml @@ -0,0 +1,95 @@ +tools_root: &tools_root 'C:\Program Files\IAR Systems\Embedded Workbench 5.3 MSP430\' +core_root: &core_root [*tools_root, '430\'] +core_bin: &core_bin [*core_root, 'bin\'] +core_config: &core_config [*core_root, 'config\'] +core_lib: &core_lib [*core_root, 'lib\'] +core_inc: &core_inc [*core_root, 'inc\'] +core_config: &core_config [*core_root, 'config\'] + +compiler: + path: [*core_bin, 'icc430.exe'] + source_path: '..\src\' + unit_tests_path: &unit_tests_path 'tests\' + build_path: &build_path 'build\' + options: + - --dlib_config + - [*core_lib, 'dlib\dl430fn.h'] + - --no_cse + - --no_unroll + - --no_inline + - --no_code_motion + - --no_tbaa + - --debug + - -e + - -Ol + - --multiplier=16 + - --double=32 + - --diag_suppress Pa050 + - --diag_suppress Pe111 + includes: + prefix: '-I' + items: + - *core_inc + - [*core_inc, 'dlib'] + - [*core_lib, 'dlib'] + - 'src\' + - '../src/' + - 'testdata/' + - *unit_tests_path + - 'vendor\unity\src' + defines: + prefix: '-D' + items: + - '__MSP430F149__' + - 'INT_WIDTH=16' + - 'UNITY_EXCLUDE_FLOAT' + - 'UNITY_SUPPORT_TEST_CASES' + object_files: + prefix: '-o' + extension: '.r43' + destination: *build_path +linker: + path: [*core_bin, 'xlink.exe'] + options: + - -rt + - [*core_lib, 'dlib\dl430fn.r43'] + - -e_PrintfTiny=_Printf + - -e_ScanfSmall=_Scanf + - -s __program_start + - -D_STACK_SIZE=50 + - -D_DATA16_HEAP_SIZE=50 + - -D_DATA20_HEAP_SIZE=50 + - -f + - [*core_config, 'lnk430f5438.xcl'] + - -f + - [*core_config, 'multiplier.xcl'] + includes: + prefix: '-I' + items: + - *core_config + - *core_lib + - [*core_lib, 'dlib'] + object_files: + path: *build_path + extension: '.r79' + bin_files: + prefix: '-o' + extension: '.d79' + destination: *build_path +simulator: + path: [*tools_root, 'common\bin\CSpyBat.exe'] + pre_support: + - --silent + - [*core_bin, '430proc.dll'] + - [*core_bin, '430sim.dll'] + post_support: + - --plugin + - [*core_bin, '430bat.dll'] + - --backend -B + - --cpu MSP430F5438 + - -p + - [*core_config, 'MSP430F5438.ddf'] + - -d sim +colour: true +:unity: + :plugins: [] diff --git a/unity/test/targets/iar_sh2a_v6.yml b/unity/test/targets/iar_sh2a_v6.yml new file mode 100644 index 0000000..27e6bee --- /dev/null +++ b/unity/test/targets/iar_sh2a_v6.yml @@ -0,0 +1,86 @@ +tools_root: &tools_root 'C:\Program Files\IAR Systems\Embedded Workbench 6.0\' +compiler: + path: [*tools_root, 'sh\bin\iccsh.exe'] + source_path: '..\src\' + unit_tests_path: &unit_tests_path 'tests\' + build_path: &build_path 'build\' + options: + - -e + - --char_is_signed + - -Ol + - --no_cse + - --no_unroll + - --no_inline + - --no_code_motion + - --no_tbaa + - --no_scheduling + - --no_clustering + - --debug + - --dlib_config + - [*tools_root, 'sh\inc\DLib_Product.h'] + - --double=32 + - --code_model=huge + - --data_model=huge + - --core=sh2afpu + - --warnings_affect_exit_code + - --warnings_are_errors + - --mfc + - --use_unix_directory_separators + - --diag_suppress=Pe161 + includes: + prefix: '-I' + items: + - [*tools_root, 'sh\inc\'] + - [*tools_root, 'sh\inc\c'] + - 'src\' + - '..\src\' + - 'testdata/' + - *unit_tests_path + - 'vendor\unity\src\' + defines: + prefix: '-D' + items: + - UNITY_SUPPORT_64 + - 'UNITY_SUPPORT_TEST_CASES' + object_files: + prefix: '-o' + extension: '.o' + destination: *build_path +linker: + path: [*tools_root, 'sh\bin\ilinksh.exe'] + options: + - --redirect __Printf=__PrintfSmall + - --redirect __Scanf=__ScanfSmall + - --config + - [*tools_root, 'sh\config\generic.icf'] + - --config_def _CSTACK_SIZE=0x800 + - --config_def _HEAP_SIZE=0x800 + - --config_def _INT_TABLE=0x10 + - --entry __iar_program_start + - --debug_lib + object_files: + path: *build_path + extension: '.o' + bin_files: + prefix: '-o' + extension: '.out' + destination: *build_path +simulator: + path: [*tools_root, 'common\bin\CSpyBat.exe'] + pre_support: + - --silent + - [*tools_root, 'sh\bin\shproc.dll'] + - [*tools_root, 'sh\bin\shsim.dll'] + post_support: + - --plugin + - [*tools_root, 'sh\bin\shbat.dll'] + - --backend + - -B + - --core sh2afpu + - -p + - [*tools_root, 'sh\config\debugger\io7264.ddf'] + - -d + - sim +colour: true +:unity: + :plugins: [] diff --git a/unity/test/testdata/CException.h b/unity/test/testdata/CException.h new file mode 100644 index 0000000..91ad3e1 --- /dev/null +++ b/unity/test/testdata/CException.h @@ -0,0 +1,11 @@ +#ifndef CEXCEPTION_H +#define CEXCEPTION_H + +#define CEXCEPTION_BEING_USED 1 + +#define CEXCEPTION_NONE 0 +#define CEXCEPTION_T int e = 1; (void) +#define Try if (e) +#define Catch(a) if (!a) + +#endif //CEXCEPTION_H diff --git a/unity/test/testdata/Defs.h b/unity/test/testdata/Defs.h new file mode 100644 index 0000000..d3a90c0 --- /dev/null +++ b/unity/test/testdata/Defs.h @@ -0,0 +1,8 @@ +#ifndef DEF_H +#define DEF_H + +#define EXTERN_DECL + +extern int CounterSuiteSetup; + +#endif //DEF_H diff --git a/unity/test/testdata/cmock.h b/unity/test/testdata/cmock.h new file mode 100644 index 0000000..c6149be --- /dev/null +++ b/unity/test/testdata/cmock.h @@ -0,0 +1,14 @@ +#ifndef CMOCK_H +#define CMOCK_H + +int CMockMemFreeFinalCounter = 0; +int mockMock_Init_Counter = 0; +int mockMock_Verify_Counter = 0; +int mockMock_Destroy_Counter = 0; + +void CMock_Guts_MemFreeFinal(void) { CMockMemFreeFinalCounter++; } +void mockMock_Init(void) { mockMock_Init_Counter++; } +void mockMock_Verify(void) { mockMock_Verify_Counter++; } +void mockMock_Destroy(void) { mockMock_Destroy_Counter++; } + +#endif //CMOCK_H diff --git a/unity/test/testdata/mockMock.h b/unity/test/testdata/mockMock.h new file mode 100644 index 0000000..0a2c616 --- /dev/null +++ b/unity/test/testdata/mockMock.h @@ -0,0 +1,13 @@ +#ifndef MOCK_MOCK_H +#define MOCK_MOCK_H + +extern int mockMock_Init_Counter; +extern int mockMock_Verify_Counter; +extern int mockMock_Destroy_Counter; +extern int CMockMemFreeFinalCounter; + +void mockMock_Init(void); +void mockMock_Verify(void); +void mockMock_Destroy(void); + +#endif //MOCK_MOCK_H diff --git a/unity/test/testdata/testRunnerGenerator.c b/unity/test/testdata/testRunnerGenerator.c new file mode 100644 index 0000000..62989a0 --- /dev/null +++ b/unity/test/testdata/testRunnerGenerator.c @@ -0,0 +1,186 @@ +/* This Test File Is Used To Verify Many Combinations Of Using the Generate Test Runner Script */ + +#include +#include "unity.h" +#include "Defs.h" + +#ifdef USE_CEXCEPTION +#include "CException.h" +#endif + +/* Notes about prefixes: + test - normal default prefix. these are "always run" tests for this procedure + spec - normal default prefix. required to run default setup/teardown calls. + should - normal default prefix. + qwiktest - custom prefix for when tests skip all setup/teardown calls. + custtest - custom prefix for when tests use custom setup/teardown calls. + paratest - custom prefix for when we want to verify parameterized tests. + extest - custom prefix only used during cexception + suitetest- custom prefix for when we want to use custom suite setup/teardown +*/ + +/* Support for Meta Test Rig */ +#define TEST_CASE(a) + +/* Include Passthroughs for Linking Tests */ +void putcharSpy(int c) { (void)putchar(c);} +void flushSpy(void) {} + +/* Global Variables Used During These Tests */ +int CounterSetup = 0; +int CounterTeardown = 0; +int CounterSuiteSetup = 0; + +void setUp(void) +{ + CounterSetup = 1; +} + +void tearDown(void) +{ + CounterTeardown = 1; +} + +void custom_setup(void) +{ + CounterSetup = 2; +} + +void custom_teardown(void) +{ + CounterTeardown = 2; +} + +/* +void test_OldSchoolCommentsShouldBeIgnored(void) +{ + TEST_ASSERT_FAIL("Old-School Comments Should Be Ignored"); +} +*/ + +void test_ThisTestAlwaysPasses(void) +{ + TEST_PASS(); +} + +void test_ThisTestAlwaysFails(void) +{ + TEST_FAIL_MESSAGE("This Test Should Fail"); +} + +void test_ThisTestAlwaysIgnored(void) +{ + TEST_IGNORE_MESSAGE("This Test Should Be Ignored"); +} + +void qwiktest_ThisTestPassesWhenNoSetupRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(0, CounterSetup, "Setup Was Unexpectedly Run"); +} + +void qwiktest_ThisTestPassesWhenNoTeardownRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(0, CounterTeardown, "Teardown Was Unexpectedly Run"); +} + +void spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(0, CounterSuiteSetup, "Suite Setup Was Unexpectedly Run"); +} + +void spec_ThisTestPassesWhenNormalSetupRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(1, CounterSetup, "Normal Setup Wasn't Run"); +} + +void spec_ThisTestPassesWhenNormalTeardownRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(1, CounterTeardown, "Normal Teardown Wasn't Run"); +} + +void custtest_ThisTestPassesWhenCustomSetupRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(2, CounterSetup, "Custom Setup Wasn't Run"); +} + +void custtest_ThisTestPassesWhenCustomTeardownRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(2, CounterTeardown, "Custom Teardown Wasn't Run"); +} + +//void test_NewStyleCommentsShouldBeIgnored(void) +//{ +// TEST_ASSERT_FAIL("New Style Comments Should Be Ignored"); +//} + +void test_NotBeConfusedByLongComplicatedStrings(void) +{ + const char* crazyString = "GET / HTTP/1.1\r\nHost: 127.0.0.1:8081\r\nConnection: keep-alive\r\nCache-Control: no-cache\r\nUser-Agent: Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2490.80 Safari/537.36\r\nPostman-Token: 768c7149-c3fb-f704-71a2-63918d9195b2\r\nAccept: */*\r\nAccept-Encoding: gzip, deflate, sdch\r\nAccept-Language: en-GB,en-US;q=0.8,en;q=0.6\r\n\r\n"; + + TEST_ASSERT_EQUAL_STRING_MESSAGE(crazyString, crazyString, "These Strings Are The Same"); +} + +void test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings(void) +{ + TEST_ASSERT_TRUE_MESSAGE(1, "1 Should be True"); +} + +void test_StillNotBeConfusedByLongComplicatedStrings(void) +{ + const char* crazyString = "GET / HTTP/1.1\r\nHost: 127.0.0.1:8081\r\nConnection: keep-alive\r\nCache-Control: no-cache\r\nUser-Agent: Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2490.80 Safari/537.36\r\nPostman-Token: 768c7149-c3fb-f704-71a2-63918d9195b2\r\nAccept: */*\r\nAccept-Encoding: gzip, deflate, sdch\r\nAccept-Language: en-GB,en-US;q=0.8,en;q=0.6\r\n\r\n"; + + TEST_ASSERT_EQUAL_STRING_MESSAGE(crazyString, crazyString, "These Strings Are Still The Same"); +} + +void should_RunTestsStartingWithShouldByDefault(void) +{ + TEST_ASSERT_TRUE_MESSAGE(1, "1 Should be True"); +} + +TEST_CASE(25) +TEST_CASE(125) +TEST_CASE(5) +void paratest_ShouldHandleParameterizedTests(int Num) +{ + TEST_ASSERT_EQUAL_MESSAGE(0, (Num % 5), "All The Values Are Divisible By 5"); +} + +TEST_CASE(7) +void paratest_ShouldHandleParameterizedTests2(int Num) +{ + TEST_ASSERT_EQUAL_MESSAGE(7, Num, "The Only Call To This Passes"); +} + +void paratest_ShouldHandleNonParameterizedTestsWhenParameterizationValid(void) +{ + TEST_PASS(); +} + +TEST_CASE(17) +void paratest_ShouldHandleParameterizedTestsThatFail(int Num) +{ + TEST_ASSERT_EQUAL_MESSAGE(3, Num, "This call should fail"); +} + +#ifdef USE_CEXCEPTION +void extest_ShouldHandleCExceptionInTest(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(1, CEXCEPTION_BEING_USED, "Should be pulling in CException"); +} +#endif + +#ifdef USE_ANOTHER_MAIN +int custom_main(void); + +int main(void) +{ + return custom_main(); +} +#endif + +void suitetest_ThisTestPassesWhenCustomSuiteSetupAndTeardownRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(1, CounterSuiteSetup, "Suite Setup Should Have Run"); +} + + diff --git a/unity/test/testdata/testRunnerGeneratorSmall.c b/unity/test/testdata/testRunnerGeneratorSmall.c new file mode 100644 index 0000000..c8aaf74 --- /dev/null +++ b/unity/test/testdata/testRunnerGeneratorSmall.c @@ -0,0 +1,70 @@ +/* This Test File Is Used To Verify Many Combinations Of Using the Generate Test Runner Script */ + +#include +#include "unity.h" +#include "Defs.h" + +TEST_FILE("some_file.c") + +/* Notes about prefixes: + test - normal default prefix. these are "always run" tests for this procedure + spec - normal default prefix. required to run default setup/teardown calls. +*/ + +/* Support for Meta Test Rig */ +#define TEST_CASE(a) + +/* Include Passthroughs for Linking Tests */ +void putcharSpy(int c) { (void)putchar(c);} +void flushSpy(void) {} + +/* Global Variables Used During These Tests */ +int CounterSetup = 0; +int CounterTeardown = 0; +int CounterSuiteSetup = 0; + +void setUp(void) +{ + CounterSetup = 1; +} + +void tearDown(void) +{ + CounterTeardown = 1; +} + +void custom_setup(void) +{ + CounterSetup = 2; +} + +void custom_teardown(void) +{ + CounterTeardown = 2; +} + +void test_ThisTestAlwaysPasses(void) +{ + TEST_PASS(); +} + +void test_ThisTestAlwaysFails(void) +{ + TEST_FAIL_MESSAGE("This Test Should Fail"); +} + +void test_ThisTestAlwaysIgnored(void) +{ + TEST_IGNORE_MESSAGE("This Test Should Be Ignored"); +} + +void spec_ThisTestPassesWhenNormalSetupRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(1, CounterSetup, "Normal Setup Wasn't Run"); +} + +void spec_ThisTestPassesWhenNormalTeardownRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(1, CounterTeardown, "Normal Teardown Wasn't Run"); +} + diff --git a/unity/test/testdata/testRunnerGeneratorWithMocks.c b/unity/test/testdata/testRunnerGeneratorWithMocks.c new file mode 100644 index 0000000..4aacbf9 --- /dev/null +++ b/unity/test/testdata/testRunnerGeneratorWithMocks.c @@ -0,0 +1,195 @@ +/* This Test File Is Used To Verify Many Combinations Of Using the Generate Test Runner Script */ + +#include +#include "unity.h" +#include "Defs.h" +#include "mockMock.h" + +#ifdef USE_CEXCEPTION +#include "CException.h" +#endif + +/* Notes about prefixes: + test - normal default prefix. these are "always run" tests for this procedure + spec - normal default prefix. required to run default setup/teardown calls. + should - normal default prefix. + qwiktest - custom prefix for when tests skip all setup/teardown calls. + custtest - custom prefix for when tests use custom setup/teardown calls. + paratest - custom prefix for when we want to verify parameterized tests. + extest - custom prefix only used during cexception + suitetest- custom prefix for when we want to use custom suite setup/teardown +*/ + +/* Support for Meta Test Rig */ +#define TEST_CASE(a) + +/* Include Passthroughs for Linking Tests */ +void putcharSpy(int c) { (void)putchar(c);} +void flushSpy(void) {} + +/* Global Variables Used During These Tests */ +int CounterSetup = 0; +int CounterTeardown = 0; +int CounterSuiteSetup = 0; + +void setUp(void) +{ + CounterSetup = 1; +} + +void tearDown(void) +{ + CounterTeardown = 1; +} + +void custom_setup(void) +{ + CounterSetup = 2; +} + +void custom_teardown(void) +{ + CounterTeardown = 2; +} + +/* +void test_OldSchoolCommentsShouldBeIgnored(void) +{ + TEST_ASSERT_FAIL("Old-School Comments Should Be Ignored"); +} +*/ + +void test_ThisTestAlwaysPasses(void) +{ + TEST_PASS(); +} + +void test_ThisTestAlwaysFails(void) +{ + TEST_FAIL_MESSAGE("This Test Should Fail"); +} + +void test_ThisTestAlwaysIgnored(void) +{ + TEST_IGNORE_MESSAGE("This Test Should Be Ignored"); +} + +void qwiktest_ThisTestPassesWhenNoSetupRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(0, CounterSetup, "Setup Was Unexpectedly Run"); +} + +void qwiktest_ThisTestPassesWhenNoTeardownRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(0, CounterTeardown, "Teardown Was Unexpectedly Run"); +} + +void spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(0, CounterSuiteSetup, "Suite Setup Was Unexpectedly Run"); +} + +void spec_ThisTestPassesWhenNormalSetupRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(1, CounterSetup, "Normal Setup Wasn't Run"); +} + +void spec_ThisTestPassesWhenNormalTeardownRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(1, CounterTeardown, "Normal Teardown Wasn't Run"); +} + +void custtest_ThisTestPassesWhenCustomSetupRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(2, CounterSetup, "Custom Setup Wasn't Run"); +} + +void custtest_ThisTestPassesWhenCustomTeardownRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(2, CounterTeardown, "Custom Teardown Wasn't Run"); +} + +//void test_NewStyleCommentsShouldBeIgnored(void) +//{ +// TEST_ASSERT_FAIL("New Style Comments Should Be Ignored"); +//} + +void test_NotBeConfusedByLongComplicatedStrings(void) +{ + const char* crazyString = "GET / HTTP/1.1\r\nHost: 127.0.0.1:8081\r\nConnection: keep-alive\r\nCache-Control: no-cache\r\nUser-Agent: Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2490.80 Safari/537.36\r\nPostman-Token: 768c7149-c3fb-f704-71a2-63918d9195b2\r\nAccept: */*\r\nAccept-Encoding: gzip, deflate, sdch\r\nAccept-Language: en-GB,en-US;q=0.8,en;q=0.6\r\n\r\n"; + + TEST_ASSERT_EQUAL_STRING_MESSAGE(crazyString, crazyString, "These Strings Are The Same"); +} + +void test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings(void) +{ + TEST_ASSERT_TRUE_MESSAGE(1, "1 Should be True"); +} + +void test_StillNotBeConfusedByLongComplicatedStrings(void) +{ + const char* crazyString = "GET / HTTP/1.1\r\nHost: 127.0.0.1:8081\r\nConnection: keep-alive\r\nCache-Control: no-cache\r\nUser-Agent: Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2490.80 Safari/537.36\r\nPostman-Token: 768c7149-c3fb-f704-71a2-63918d9195b2\r\nAccept: */*\r\nAccept-Encoding: gzip, deflate, sdch\r\nAccept-Language: en-GB,en-US;q=0.8,en;q=0.6\r\n\r\n"; + + TEST_ASSERT_EQUAL_STRING_MESSAGE(crazyString, crazyString, "These Strings Are Still The Same"); +} + +void should_RunTestsStartingWithShouldByDefault(void) +{ + TEST_ASSERT_TRUE_MESSAGE(1, "1 Should be True"); +} + +TEST_CASE(25) +TEST_CASE(125) +TEST_CASE(5) +void paratest_ShouldHandleParameterizedTests(int Num) +{ + TEST_ASSERT_EQUAL_MESSAGE(0, (Num % 5), "All The Values Are Divisible By 5"); +} + +TEST_CASE(7) +void paratest_ShouldHandleParameterizedTests2(int Num) +{ + TEST_ASSERT_EQUAL_MESSAGE(7, Num, "The Only Call To This Passes"); +} + +void paratest_ShouldHandleNonParameterizedTestsWhenParameterizationValid(void) +{ + TEST_PASS(); +} + +TEST_CASE(17) +void paratest_ShouldHandleParameterizedTestsThatFail(int Num) +{ + TEST_ASSERT_EQUAL_MESSAGE(3, Num, "This call should fail"); +} + +#ifdef USE_CEXCEPTION +void extest_ShouldHandleCExceptionInTest(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(1, CEXCEPTION_BEING_USED, "Should be pulling in CException"); +} +#endif + +#ifdef USE_ANOTHER_MAIN +int custom_main(void); + +int main(void) +{ + return custom_main(); +} +#endif + +void suitetest_ThisTestPassesWhenCustomSuiteSetupAndTeardownRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(1, CounterSuiteSetup, "Suite Setup Should Have Run"); +} + +void test_ShouldCallMockInitAndVerifyFunctionsForEachTest(void) +{ + int passesOrIgnores = (int)(Unity.NumberOfTests - Unity.TestFailures); + TEST_ASSERT_EQUAL_MESSAGE(Unity.NumberOfTests, mockMock_Init_Counter, "Mock Init Should Be Called Once Per Test Started"); + TEST_ASSERT_EQUAL_MESSAGE(passesOrIgnores, mockMock_Verify_Counter, "Mock Verify Should Be Called Once Per Test Passed"); + TEST_ASSERT_EQUAL_MESSAGE(Unity.NumberOfTests - 1, mockMock_Destroy_Counter, "Mock Destroy Should Be Called Once Per Test Completed"); + TEST_ASSERT_EQUAL_MESSAGE(0, CMockMemFreeFinalCounter, "Mock MemFreeFinal Should Not Be Called Until End"); +} + diff --git a/unity/test/tests/test_generate_test_runner.rb b/unity/test/tests/test_generate_test_runner.rb new file mode 100644 index 0000000..a3536d3 --- /dev/null +++ b/unity/test/tests/test_generate_test_runner.rb @@ -0,0 +1,1252 @@ +# ========================================== +# CMock Project - Automatic Mock Generation for C +# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams +# [Released under MIT License. Please refer to license.txt for details] +# ========================================== + +require '../auto/generate_test_runner.rb' + +$generate_test_runner_tests = 0 +$generate_test_runner_failures = 0 + +OUT_FILE = 'build/testsample_' + +RUNNER_TESTS = [ + { :name => 'DefaultsThroughOptions', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST'], + :options => nil, #defaults + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'DefaultsThroughCommandLine', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST'], + :cmdline => "", #defaults + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'DefaultsThroughYAMLFile', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST'], + :cmdline => "", #defaults + :yaml => {}, #defaults + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ShorterFilterOfJustTest', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST'], + :options => { + :test_prefix => "test", + }, + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ShorterFilterOfJustShould', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST'], + :options => { + :test_prefix => "should", + }, + :expected => { + :to_pass => [ 'should_RunTestsStartingWithShouldByDefault' ], + :to_fail => [ ], + :to_ignore => [ ], + } + }, + + { :name => 'ShorterFilterOfJustSpec', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST'], + :options => { + :test_prefix => "spec", + }, + :expected => { + :to_pass => [ 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + ], + :to_fail => [ ], + :to_ignore => [ ], + } + }, + + { :name => 'InjectIncludes', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST'], + :options => { + :includes => ['Defs.h'], + }, + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ParameterizedThroughOptions', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST'], + :options => { + :test_prefix => "paratest", + :use_param_tests => true, + }, + :expected => { + :to_pass => [ 'paratest_ShouldHandleParameterizedTests\(25\)', + 'paratest_ShouldHandleParameterizedTests\(125\)', + 'paratest_ShouldHandleParameterizedTests\(5\)', + 'paratest_ShouldHandleParameterizedTests2\(7\)', + 'paratest_ShouldHandleNonParameterizedTestsWhenParameterizationValid\(RUN_TEST_NO_ARGS\)', + ], + :to_fail => [ 'paratest_ShouldHandleParameterizedTestsThatFail\(17\)' ], + :to_ignore => [ ], + } + }, + + { :name => 'ParameterizedThroughCommandLine', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST'], + :cmdline => " --test_prefix=\"paratest\" --use_param_tests=1", + :expected => { + :to_pass => [ 'paratest_ShouldHandleParameterizedTests\(25\)', + 'paratest_ShouldHandleParameterizedTests\(125\)', + 'paratest_ShouldHandleParameterizedTests\(5\)', + 'paratest_ShouldHandleParameterizedTests2\(7\)', + 'paratest_ShouldHandleNonParameterizedTestsWhenParameterizationValid\(RUN_TEST_NO_ARGS\)', + ], + :to_fail => [ 'paratest_ShouldHandleParameterizedTestsThatFail\(17\)' ], + :to_ignore => [ ], + } + }, + + { :name => 'ParameterizedThroughCommandLineAndYaml', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST'], + :cmdline => "--use_param_tests=1", + :yaml => { + :test_prefix => "paratest" + }, + :expected => { + :to_pass => [ 'paratest_ShouldHandleParameterizedTests\(25\)', + 'paratest_ShouldHandleParameterizedTests\(125\)', + 'paratest_ShouldHandleParameterizedTests\(5\)', + 'paratest_ShouldHandleParameterizedTests2\(7\)', + 'paratest_ShouldHandleNonParameterizedTestsWhenParameterizationValid\(RUN_TEST_NO_ARGS\)', + ], + :to_fail => [ 'paratest_ShouldHandleParameterizedTestsThatFail\(17\)' ], + :to_ignore => [ ], + } + }, + + { :name => 'CException', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'USE_CEXCEPTION'], + :options => { + :test_prefix => "extest", + :plugins => [ :cexception ], + }, + :expected => { + :to_pass => [ 'extest_ShouldHandleCExceptionInTest' ], + :to_fail => [ ], + :to_ignore => [ ], + } + }, + + { :name => 'CustomSetupAndTeardownThroughOptions', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST'], + :options => { + :test_prefix => "custtest|test", + :setup_name => "custom_setup", + :teardown_name => "custom_teardown", + }, + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'custtest_ThisTestPassesWhenCustomSetupRan', + 'custtest_ThisTestPassesWhenCustomTeardownRan', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'CustomSetupAndTeardownThroughCommandLine', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST'], + :cmdline => " --test_prefix=\"custtest|test\" --setup_name=\"custom_setup\" --teardown_name=\"custom_teardown\"", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'custtest_ThisTestPassesWhenCustomSetupRan', + 'custtest_ThisTestPassesWhenCustomTeardownRan', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'CustomSetupAndTeardownThroughYaml', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST'], + :cmdline => " --test_prefix=\"custtest|test\"", + :yaml => { + :setup_name => "custom_setup", + :teardown_name => "custom_teardown", + }, + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'custtest_ThisTestPassesWhenCustomSetupRan', + 'custtest_ThisTestPassesWhenCustomTeardownRan', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'CustomMain', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', "USE_ANOTHER_MAIN"], + :options => { + :main_name => "custom_main", + }, + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'CustomSuiteSetupAndTeardown', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST'], + :includes => ['Defs.h'], + :options => { + :test_prefix => "suitetest|test", + :suite_setup => " CounterSuiteSetup = 1;", + :suite_teardown => " return num_failures;", + }, + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'suitetest_ThisTestPassesWhenCustomSuiteSetupAndTeardownRan', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'MainExternDeclaration', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST'], + :includes => ['Defs.h'], + :options => { + :main_export_decl => "EXTERN_DECL", + }, + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + + #### WITH MOCKS ########################################## + + { :name => 'DefaultsThroughOptions', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST'], + :options => nil, #defaults + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + 'test_ShouldCallMockInitAndVerifyFunctionsForEachTest', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'DefaultsThroughCommandLine', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST'], + :cmdline => "", #defaults + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + 'test_ShouldCallMockInitAndVerifyFunctionsForEachTest', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'DefaultsThroughYAMLFile', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST'], + :cmdline => "", #defaults + :yaml => {}, #defaults + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + 'test_ShouldCallMockInitAndVerifyFunctionsForEachTest', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ShorterFilterOfJustTest', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST'], + :options => { + :test_prefix => "test", + }, + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'test_ShouldCallMockInitAndVerifyFunctionsForEachTest', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ShorterFilterOfJustShould', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST'], + :options => { + :test_prefix => "should", + }, + :expected => { + :to_pass => [ 'should_RunTestsStartingWithShouldByDefault' ], + :to_fail => [ ], + :to_ignore => [ ], + } + }, + + { :name => 'ShorterFilterOfJustSpec', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST'], + :options => { + :test_prefix => "spec", + }, + :expected => { + :to_pass => [ 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + ], + :to_fail => [ ], + :to_ignore => [ ], + } + }, + + { :name => 'InjectIncludes', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST'], + :options => { + :includes => ['Defs.h'], + }, + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + 'test_ShouldCallMockInitAndVerifyFunctionsForEachTest', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ParameterizedThroughOptions', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST'], + :options => { + :test_prefix => "paratest", + :use_param_tests => true, + }, + :expected => { + :to_pass => [ 'paratest_ShouldHandleParameterizedTests\(25\)', + 'paratest_ShouldHandleParameterizedTests\(125\)', + 'paratest_ShouldHandleParameterizedTests\(5\)', + 'paratest_ShouldHandleParameterizedTests2\(7\)', + 'paratest_ShouldHandleNonParameterizedTestsWhenParameterizationValid\(RUN_TEST_NO_ARGS\)', + ], + :to_fail => [ 'paratest_ShouldHandleParameterizedTestsThatFail\(17\)' ], + :to_ignore => [ ], + } + }, + + { :name => 'ParameterizedThroughCommandLine', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST'], + :cmdline => " --test_prefix=\"paratest\" --use_param_tests=1", + :expected => { + :to_pass => [ 'paratest_ShouldHandleParameterizedTests\(25\)', + 'paratest_ShouldHandleParameterizedTests\(125\)', + 'paratest_ShouldHandleParameterizedTests\(5\)', + 'paratest_ShouldHandleParameterizedTests2\(7\)', + 'paratest_ShouldHandleNonParameterizedTestsWhenParameterizationValid\(RUN_TEST_NO_ARGS\)', + ], + :to_fail => [ 'paratest_ShouldHandleParameterizedTestsThatFail\(17\)' ], + :to_ignore => [ ], + } + }, + + { :name => 'ParameterizedThroughCommandLineAndYaml', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST'], + :cmdline => "--use_param_tests=1", + :yaml => { + :test_prefix => "paratest" + }, + :expected => { + :to_pass => [ 'paratest_ShouldHandleParameterizedTests\(25\)', + 'paratest_ShouldHandleParameterizedTests\(125\)', + 'paratest_ShouldHandleParameterizedTests\(5\)', + 'paratest_ShouldHandleParameterizedTests2\(7\)', + 'paratest_ShouldHandleNonParameterizedTestsWhenParameterizationValid\(RUN_TEST_NO_ARGS\)', + ], + :to_fail => [ 'paratest_ShouldHandleParameterizedTestsThatFail\(17\)' ], + :to_ignore => [ ], + } + }, + + { :name => 'CException', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST', 'USE_CEXCEPTION'], + :options => { + :test_prefix => "extest", + :plugins => [ :cexception ], + }, + :expected => { + :to_pass => [ 'extest_ShouldHandleCExceptionInTest' ], + :to_fail => [ ], + :to_ignore => [ ], + } + }, + + { :name => 'CustomSetupAndTeardownThroughOptions', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST'], + :options => { + :test_prefix => "custtest|test", + :setup_name => "custom_setup", + :teardown_name => "custom_teardown", + }, + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'custtest_ThisTestPassesWhenCustomSetupRan', + 'custtest_ThisTestPassesWhenCustomTeardownRan', + 'test_ShouldCallMockInitAndVerifyFunctionsForEachTest', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'CustomSetupAndTeardownThroughCommandLine', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST'], + :cmdline => " --test_prefix=\"custtest|test\" --setup_name=\"custom_setup\" --teardown_name=\"custom_teardown\"", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'custtest_ThisTestPassesWhenCustomSetupRan', + 'custtest_ThisTestPassesWhenCustomTeardownRan', + 'test_ShouldCallMockInitAndVerifyFunctionsForEachTest', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'CustomSetupAndTeardownThroughYaml', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST'], + :cmdline => " --test_prefix=\"custtest|test\"", + :yaml => { + :setup_name => "custom_setup", + :teardown_name => "custom_teardown", + }, + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'custtest_ThisTestPassesWhenCustomSetupRan', + 'custtest_ThisTestPassesWhenCustomTeardownRan', + 'test_ShouldCallMockInitAndVerifyFunctionsForEachTest', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'CustomMain', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST', "USE_ANOTHER_MAIN"], + :options => { + :main_name => "custom_main", + }, + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + 'test_ShouldCallMockInitAndVerifyFunctionsForEachTest', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'CustomSuiteSetupAndTeardown', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST'], + :includes => ['Defs.h'], + :options => { + :test_prefix => "suitetest|test", + :suite_setup => " CounterSuiteSetup = 1;", + :suite_teardown => " return num_failures;", + }, + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'suitetest_ThisTestPassesWhenCustomSuiteSetupAndTeardownRan', + 'test_ShouldCallMockInitAndVerifyFunctionsForEachTest', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'MainExternDeclaration', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST'], + :includes => ['Defs.h'], + :options => { + :main_export_decl => "EXTERN_DECL", + }, + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + 'test_ShouldCallMockInitAndVerifyFunctionsForEachTest', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + + + #### WITH ARGS ########################################## + + { :name => 'ArgsThroughOptions', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ArgsThroughCommandLine', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :cmdline => "--cmdline_args=1", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ArgsThroughYAMLFile', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :cmdline => "", + :yaml => { + :cmdline_args => true, + }, + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ArgsNameFilterJustTest', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n test_", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ArgsNameFilterJustShould', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n should_", + :expected => { + :to_pass => [ 'should_RunTestsStartingWithShouldByDefault' ], + :to_fail => [ ], + :to_ignore => [ ], + } + }, + + { :name => 'ArgsNameFilterTestAndShould', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n should_,test_", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault' ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ArgsNameFilterWithWildcardOnFile', + :testfile => 'testdata/testRunnerGeneratorSmall.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n testRunnerGeneratorSma*", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan' ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ArgsNameFilterWithWildcardAsName', + :testfile => 'testdata/testRunnerGeneratorSmall.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n testRunnerGeneratorSmall:*", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan' ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ArgsNameFilterWithWildcardOnName', + :testfile => 'testdata/testRunnerGeneratorSmall.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n testRunnerGeneratorSmall:test_*", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses' ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ArgsNameFilterWithWildcardAndShortName', + :testfile => 'testdata/testRunnerGeneratorSmall.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n testRunnerGeneratorSmall:te*", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses' ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ArgsNameFilterWithWildcardOnBoth', + :testfile => 'testdata/testRunnerGeneratorSmall.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n testRunnerGeneratorSm*:*", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan' ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ArgsExcludeFilterJustTest', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-x test_", + :expected => { + :to_pass => [ 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + 'should_RunTestsStartingWithShouldByDefault', + ], + :to_fail => [ ], + :to_ignore => [ ], + } + }, + + { :name => 'ArgsIncludeAndExcludeFilter', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + :includes => ['Defs.h'], + }, + :cmdline_args => "-n test_ -x Ignored", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ ], + } + }, + + { :name => 'ArgsIncludeSingleTest', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n ThisTestAlwaysPasses", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses' ], + :to_fail => [ ], + :to_ignore => [ ], + } + }, + + { :name => 'ArgsIncludeSingleTestInSpecificFile', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n testRunnerGenerator:ThisTestAlwaysPasses", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses' ], + :to_fail => [ ], + :to_ignore => [ ], + } + }, + + { :name => 'ArgsIncludeTestFileWithExtension', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n testRunnerGenerator.c:ThisTestAlwaysPasses", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses' ], + :to_fail => [ ], + :to_ignore => [ ], + } + }, + + { :name => 'ArgsIncludeDoubleQuotes', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n \"testRunnerGenerator:ThisTestAlwaysPasses,test_ThisTestAlwaysFails\"", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses' ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ ], + } + }, + + { :name => 'ArgsIncludeSingleQuotes', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n 'testRunnerGenerator:ThisTestAlwaysPasses,test_ThisTestAlwaysFails'", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses' ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ ], + } + }, + + { :name => 'ArgsIncludeAValidTestForADifferentFile', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n AnotherFile:ThisTestDoesNotExist", + :expected => { + :to_pass => [ ], + :to_fail => [ ], + :to_ignore => [ ], + } + }, + + { :name => 'ArgsIncludeNoTests', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n ThisTestDoesNotExist", + :expected => { + :to_pass => [ ], + :to_fail => [ ], + :to_ignore => [ ], + } + }, + + { :name => 'ArgsExcludeAllTests', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-x _", + :expected => { + :to_pass => [ ], + :to_fail => [ ], + :to_ignore => [ ], + } + }, + + { :name => 'ArgsIncludeFullFile', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n testRunnerGenerator", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ArgsIncludeWithAlternateFlag', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-f=\"testRunnerGenerator:ThisTestAlwaysPasses,test_ThisTestAlwaysFails\"", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses' ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ ], + } + }, + + { :name => 'ArgsIncludeWithParameterized', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :cmdline => "--use_param_tests=1", + :yaml => { + :cmdline_args => true, + :test_prefix => "paratest" + }, + :cmdline_args => "-n ShouldHandleParameterizedTests", + :expected => { + :to_pass => [ 'paratest_ShouldHandleParameterizedTests\(25\)', + 'paratest_ShouldHandleParameterizedTests\(125\)', + 'paratest_ShouldHandleParameterizedTests\(5\)', + 'paratest_ShouldHandleParameterizedTests2\(7\)', + ], + :to_fail => [ 'paratest_ShouldHandleParameterizedTestsThatFail\(17\)' ], + :to_ignore => [ ], + } + }, + + { :name => 'ArgsList', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-l", + :expected => { + :to_pass => [ ], + :to_fail => [ ], + :to_ignore => [ ], + :text => [ "testRunnerGenerator", + "test_ThisTestAlwaysPasses", + "test_ThisTestAlwaysFails", + "test_ThisTestAlwaysIgnored", + "spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan", + "spec_ThisTestPassesWhenNormalSetupRan", + "spec_ThisTestPassesWhenNormalTeardownRan", + "test_NotBeConfusedByLongComplicatedStrings", + "test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings", + "test_StillNotBeConfusedByLongComplicatedStrings", + "should_RunTestsStartingWithShouldByDefault" + ] + } + }, + + { :name => 'ArgsListParameterized', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :test_prefix => "paratest", + :use_param_tests => true, + :cmdline_args => true, + }, + :cmdline_args => "-l", + :expected => { + :to_pass => [ ], + :to_fail => [ ], + :to_ignore => [ ], + :text => [ "testRunnerGenerator", + 'paratest_ShouldHandleParameterizedTests\(25\)', + 'paratest_ShouldHandleParameterizedTests\(125\)', + 'paratest_ShouldHandleParameterizedTests\(5\)', + 'paratest_ShouldHandleParameterizedTests2\(7\)', + 'paratest_ShouldHandleNonParameterizedTestsWhenParameterizationValid\(RUN_TEST_NO_ARGS\)', + 'paratest_ShouldHandleParameterizedTestsThatFail\(17\)' + ], + } + }, + + { :name => 'ArgsIncompleteIncludeFlags', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n", + :expected => { + :to_pass => [ ], + :to_fail => [ ], + :to_ignore => [ ], + :text => [ "ERROR: No Test String to Include Matches For" ], + } + }, + + { :name => 'ArgsIncompleteExcludeFlags', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-x", + :expected => { + :to_pass => [ ], + :to_fail => [ ], + :to_ignore => [ ], + :text => [ "ERROR: No Test String to Exclude Matches For" ], + } + }, + + { :name => 'ArgsIllegalFlags', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-z", + :expected => { + :to_pass => [ ], + :to_fail => [ ], + :to_ignore => [ ], + :text => [ "ERROR: Unknown Option z" ], + } + }, +] + +def runner_test(test, runner, expected, test_defines, cmdline_args) + # Tack on TEST define for compiling unit tests + load_configuration($cfg_file) + + #compile objects + obj_list = [ + compile(runner, test_defines), + compile(test, test_defines), + compile('../src/unity.c', test_defines), + ] + + # Link the test executable + test_base = File.basename(test, C_EXTENSION) + link_it(test_base, obj_list) + + # Execute unit test and generate results file + simulator = build_simulator_fields + cmdline_args ||= "" + executable = $cfg['linker']['bin_files']['destination'] + test_base + $cfg['linker']['bin_files']['extension'] + " #{cmdline_args}" + cmd_str = if simulator.nil? + executable + else + "#{simulator[:command]} #{simulator[:pre_support]} #{executable} #{simulator[:post_support]}" + end + output = execute(cmd_str, true) + + #compare to the expected pass/fail + allgood = expected[:to_pass].inject(true) {|s,v| s && verify_match(/#{v}:PASS/, output) } + allgood = expected[:to_fail].inject(allgood) {|s,v| s && verify_match(/#{v}:FAIL/, output) } + allgood = expected[:to_ignore].inject(allgood) {|s,v| s && verify_match(/#{v}:IGNORE/, output) } + + #verify there weren't more pass/fail/etc than expected + allgood &&= verify_number( expected[:to_pass], /(:PASS)/, output) + allgood &&= verify_number( expected[:to_fail], /(:FAIL)/, output) + allgood &&= verify_number( expected[:to_ignore], /(:IGNORE)/, output) + + #if we care about any other text, check that too + if (expected[:text]) + allgood = expected[:text].inject(allgood) {|s,v| s && verify_match(/#{v}/, output) } + allgood &&= verify_number( expected[:text], /.+/, output ) + end + + report output if (!allgood && !$verbose) #report failures if not already reporting everything + return allgood +end + +def verify_match(expression, output) + if (expression =~ output) + return true + else + report " FAIL: No Match For /#{expression.to_s}/" + return false + end +end + +def verify_number(expected, expression, output) + exp = expected.length + act = output.scan(expression).length + if (exp == act) + return true + else + report " FAIL: Expected #{exp} Matches For /#{expression.to_s}/. Was #{act}" + return false + end +end + +RUNNER_TESTS.each do |testset| + basename = File.basename(testset[:testfile], C_EXTENSION) + testset_name = "Runner_#{basename}_#{testset[:name]}" + should testset_name do + runner_name = OUT_FILE + testset[:name] + '_runner.c' + + #create a yaml file first if required + yaml_option = "" + if (testset[:yaml]) + File.open("build/runner_options.yml",'w') {|f| f << { :unity => testset[:yaml] }.to_yaml } + yaml_option = "build/runner_options.yml" + end + + #run script via command line or through hash function call, as requested + if (testset[:cmdline]) + cmdstr = "ruby ../auto/generate_test_runner.rb #{yaml_option} #{testset[:cmdline]} \"#{testset[:testfile]}\" \"#{runner_name}\"" + `#{cmdstr}` + else + UnityTestRunnerGenerator.new(testset[:options]).run(testset[:testfile], runner_name) + end + + #test the script against the specified test file and check results + if (runner_test(testset[:testfile], runner_name, testset[:expected], testset[:testdefines], testset[:cmdline_args])) + report "#{testset_name}:PASS" + else + report "#{testset_name}:FAIL" + $generate_test_runner_failures += 1 + end + $generate_test_runner_tests += 1 + end +end + +raise "There were #{$generate_test_runner_failures.to_s} failures while testing generate_test_runner.rb" if ($generate_test_runner_failures > 0) diff --git a/unity/test/tests/testparameterized.c b/unity/test/tests/testparameterized.c new file mode 100644 index 0000000..6100834 --- /dev/null +++ b/unity/test/tests/testparameterized.c @@ -0,0 +1,174 @@ +/* ========================================== + Unity Project - A Test Framework for C + Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams + [Released under MIT License. Please refer to license.txt for details] +========================================== */ + +#include +#include +#include "unity.h" + +/* Support for Meta Test Rig */ +#define TEST_CASE(...) + +/* Include Passthroughs for Linking Tests */ +void putcharSpy(int c) { (void)putchar(c);} +void flushSpy(void) {} + +#define EXPECT_ABORT_BEGIN \ + if (TEST_PROTECT()) \ + { + +#define VERIFY_FAILS_END \ + } \ + Unity.CurrentTestFailed = (Unity.CurrentTestFailed != 0) ? 0 : 1; \ + if (Unity.CurrentTestFailed == 1) { \ + SetToOneMeanWeAlreadyCheckedThisGuy = 1; \ + UnityPrintNumberUnsigned(Unity.CurrentTestLineNumber); \ + UNITY_OUTPUT_CHAR(':'); \ + UnityPrint(Unity.CurrentTestName); \ + UnityPrint(":FAIL: [[[[ Test Should Have Failed But Did Not ]]]]"); \ + UNITY_OUTPUT_CHAR('\n'); \ + } + +#define VERIFY_IGNORES_END \ + } \ + Unity.CurrentTestFailed = (Unity.CurrentTestIgnored != 0) ? 0 : 1; \ + Unity.CurrentTestIgnored = 0; \ + if (Unity.CurrentTestFailed == 1) { \ + SetToOneMeanWeAlreadyCheckedThisGuy = 1; \ + UnityPrintNumberUnsigned(Unity.CurrentTestLineNumber); \ + UNITY_OUTPUT_CHAR(':'); \ + UnityPrint(Unity.CurrentTestName); \ + UnityPrint(":FAIL: [[[[ Test Should Have Ignored But Did Not ]]]]"); \ + UNITY_OUTPUT_CHAR('\n'); \ + } + +int SetToOneToFailInTearDown; +int SetToOneMeanWeAlreadyCheckedThisGuy; +static unsigned NextExpectedStringIndex; +static unsigned NextExpectedCharIndex; + +void suiteSetUp(void) +{ + NextExpectedStringIndex = 0; + NextExpectedCharIndex = 0; +} + +void setUp(void) +{ + SetToOneToFailInTearDown = 0; + SetToOneMeanWeAlreadyCheckedThisGuy = 0; +} + +void tearDown(void) +{ + if (SetToOneToFailInTearDown == 1) + TEST_FAIL_MESSAGE("<= Failed in tearDown"); + if ((SetToOneMeanWeAlreadyCheckedThisGuy == 0) && (Unity.CurrentTestFailed > 0)) + { + UnityPrint(": [[[[ Test Should Have Passed But Did Not ]]]]"); + UNITY_OUTPUT_CHAR('\n'); + } +} + +TEST_CASE(0) +TEST_CASE(44) +TEST_CASE((90)+9) +void test_TheseShouldAllPass(int Num) +{ + TEST_ASSERT_TRUE(Num < 100); +} + +TEST_CASE(3) +TEST_CASE(77) +TEST_CASE( (99) + 1 - (1)) +void test_TheseShouldAllFail(int Num) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_TRUE(Num > 100); + VERIFY_FAILS_END +} + +TEST_CASE(1) +TEST_CASE(44) +TEST_CASE(99) +TEST_CASE(98) +void test_TheseAreEveryOther(int Num) +{ + if (Num & 1) + { + EXPECT_ABORT_BEGIN + TEST_ASSERT_TRUE(Num > 100); + VERIFY_FAILS_END + } + else + { + TEST_ASSERT_TRUE(Num < 100); + } +} + +void test_NormalPassesStillWork(void) +{ + TEST_ASSERT_TRUE(1); +} + +void test_NormalFailsStillWork(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_TRUE(0); + VERIFY_FAILS_END +} + +TEST_CASE(0, "abc") +TEST_CASE(1, "{") +TEST_CASE(2, "}") +TEST_CASE(3, ";") +TEST_CASE(4, "\"quoted\"") +void test_StringsArePreserved(unsigned index, const char * str) +{ + static const char * const expected[] = + { + "abc", + "{", + "}", + ";", + "\"quoted\"" + }; + + /* Ensure that no test cases are skipped by tracking the next expected index */ + TEST_ASSERT_EQUAL_UINT32(NextExpectedStringIndex, index); + TEST_ASSERT_LESS_THAN(sizeof(expected) / sizeof(expected[0]), index); + TEST_ASSERT_EQUAL_STRING(expected[index], str); + + NextExpectedStringIndex++; +} + +TEST_CASE(0, 'x') +TEST_CASE(1, '{') +TEST_CASE(2, '}') +TEST_CASE(3, ';') +TEST_CASE(4, '\'') +TEST_CASE(5, '"') +void test_CharsArePreserved(unsigned index, char c) +{ + static const char expected[] = + { + 'x', + '{', + '}', + ';', + '\'', + '"' + }; + + /* Ensure that no test cases are skipped by tracking the next expected index */ + TEST_ASSERT_EQUAL_UINT32(NextExpectedCharIndex, index); + TEST_ASSERT_LESS_THAN(sizeof(expected) / sizeof(expected[0]), index); + TEST_ASSERT_EQUAL(expected[index], c); + + NextExpectedCharIndex++; +} + + + diff --git a/unity/test/tests/testunity.c b/unity/test/tests/testunity.c new file mode 100644 index 0000000..56f0328 --- /dev/null +++ b/unity/test/tests/testunity.c @@ -0,0 +1,7804 @@ +/* ========================================== + Unity Project - A Test Framework for C + Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams + [Released under MIT License. Please refer to license.txt for details] +========================================== */ + +#include "unity.h" +#include +#include + +// Dividing by these constants produces +/- infinity. +// The rationale is given in UnityAssertFloatIsInf's body. +#ifndef UNITY_EXCLUDE_FLOAT +static const UNITY_FLOAT f_zero = 0.0f; +#endif + +#ifndef UNITY_EXCLUDE_DOUBLE +static const UNITY_DOUBLE d_zero = 0.0; +#endif + +#define EXPECT_ABORT_BEGIN \ + startPutcharSpy(); \ + if (TEST_PROTECT()) \ + { + +#define VERIFY_FAILS_END \ + } \ + endPutcharSpy(); /* start/end Spy to suppress output of failure message */ \ + Unity.CurrentTestFailed = (Unity.CurrentTestFailed == 1) ? 0 : 1; \ + if (Unity.CurrentTestFailed == 1) { \ + SetToOneMeanWeAlreadyCheckedThisGuy = 1; \ + UnityPrintNumberUnsigned(Unity.CurrentTestLineNumber); \ + UNITY_OUTPUT_CHAR(':'); \ + UnityPrint(Unity.CurrentTestName); \ + UnityPrint(":FAIL: [[[[ Test Should Have Failed But Did Not ]]]]"); \ + UNITY_OUTPUT_CHAR('\n'); \ + } + +#define VERIFY_IGNORES_END \ + } \ + endPutcharSpy(); /* start/end Spy to suppress output of ignore message */ \ + Unity.CurrentTestFailed = (Unity.CurrentTestIgnored == 1) ? 0 : 1; \ + Unity.CurrentTestIgnored = 0; \ + if (Unity.CurrentTestFailed == 1) { \ + SetToOneMeanWeAlreadyCheckedThisGuy = 1; \ + UnityPrintNumberUnsigned(Unity.CurrentTestLineNumber); \ + UNITY_OUTPUT_CHAR(':'); \ + UnityPrint(Unity.CurrentTestName); \ + UnityPrint(":FAIL: [[[[ Test Should Have Ignored But Did Not ]]]]"); \ + UNITY_OUTPUT_CHAR('\n'); \ + } + +void startPutcharSpy(void); +void endPutcharSpy(void); +char* getBufferPutcharSpy(void); + +void startFlushSpy(void); +void endFlushSpy(void); +int getFlushSpyCalls(void); + +static int SetToOneToFailInTearDown; +static int SetToOneMeanWeAlreadyCheckedThisGuy; + +void setUp(void) +{ + SetToOneToFailInTearDown = 0; + SetToOneMeanWeAlreadyCheckedThisGuy = 0; +} + +void tearDown(void) +{ + endPutcharSpy(); /* Stop suppressing test output */ + if (SetToOneToFailInTearDown == 1) + { + /* These will be skipped internally if already failed/ignored */ + TEST_FAIL_MESSAGE("<= Failed in tearDown"); + TEST_IGNORE_MESSAGE("<= Ignored in tearDown"); + } + if ((SetToOneMeanWeAlreadyCheckedThisGuy == 0) && (Unity.CurrentTestFailed > 0)) + { + UnityPrint(": [[[[ Test Should Have Passed But Did Not ]]]]"); + UNITY_OUTPUT_CHAR('\n'); + } +} + +void testUnitySizeInitializationReminder(void) +{ + /* This test ensures that sizeof(struct UNITY_STORAGE_T) doesn't change. If this + * test breaks, go look at the initialization of the Unity global variable + * in unity.c and make sure we're filling in the proper fields. */ + const char* message = "Unexpected size for UNITY_STORAGE_T struct. Please check that " + "the initialization of the Unity symbol in unity.c is " + "still correct."; + + /* Define a structure with all the same fields as `struct UNITY_STORAGE_T`. */ +#ifdef UNITY_EXCLUDE_DETAILS + struct { + const char* TestFile; + const char* CurrentTestName; + 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 + } _Expected_Unity; +#else + struct { + const char* TestFile; + const char* CurrentTestName; + const char* CurrentDetails1; + const char* CurrentDetails2; + 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_COUNTER_TYPE CurrentTestStartTime; + UNITY_COUNTER_TYPE CurrentTestStopTime; +#endif +#ifndef UNITY_EXCLUDE_SETJMP_H + jmp_buf AbortFrame; +#endif + } _Expected_Unity; +#endif + + /* Compare our fake structure's size to the actual structure's size. They + * should be the same. + * + * This accounts for alignment, padding, and packing issues that might come + * up between different architectures. */ + TEST_ASSERT_EQUAL_MESSAGE(sizeof(_Expected_Unity), sizeof(Unity), message); +} + +void testPassShouldEndImmediatelyWithPass(void) +{ + TEST_PASS(); + TEST_FAIL_MESSAGE("We should have passed already and finished this test"); +} + +void testTrue(void) +{ + TEST_ASSERT(1); + + TEST_ASSERT_TRUE(1); +} + +void testFalse(void) +{ + TEST_ASSERT_FALSE(0); + + TEST_ASSERT_UNLESS(0); +} + +void testPreviousPass(void) +{ + TEST_ASSERT_EQUAL_INT(0U, Unity.TestFailures); +} + +void testNotVanilla(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT(0); + VERIFY_FAILS_END +} + +void testNotTrue(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_TRUE(0); + VERIFY_FAILS_END +} + +void testNotFalse(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_FALSE(1); + VERIFY_FAILS_END +} + +void testNotUnless(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_UNLESS(1); + VERIFY_FAILS_END +} + +void testNotNotEqual(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_NOT_EQUAL(10, 10); + VERIFY_FAILS_END +} + +void testFail(void) +{ + EXPECT_ABORT_BEGIN + TEST_FAIL_MESSAGE("Expected for testing"); + VERIFY_FAILS_END +} + +void testIsNull(void) +{ + char* ptr1 = NULL; + const char* ptr2 = "hello"; + + TEST_ASSERT_NULL(ptr1); + TEST_ASSERT_NOT_NULL(ptr2); +} + +void testIsNullShouldFailIfNot(void) +{ + const char* ptr1 = "hello"; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_NULL(ptr1); + VERIFY_FAILS_END +} + +void testNotNullShouldFailIfNULL(void) +{ + char* ptr1 = NULL; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_NOT_NULL(ptr1); + VERIFY_FAILS_END +} + +void testIgnore(void) +{ + EXPECT_ABORT_BEGIN + TEST_IGNORE(); + TEST_FAIL_MESSAGE("This should not be reached"); + VERIFY_IGNORES_END +} + +void testIgnoreMessage(void) +{ + EXPECT_ABORT_BEGIN + TEST_IGNORE_MESSAGE("This is an expected TEST_IGNORE_MESSAGE string!"); + TEST_FAIL_MESSAGE("This should not be reached"); + VERIFY_IGNORES_END +} + +void testNotEqualInts(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT(3982, 3983); + VERIFY_FAILS_END +} + +void testNotEqualInt8s(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT8(-127, -126); + VERIFY_FAILS_END +} + +void testNotEqualInt16s(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT16(-16383, -16382); + VERIFY_FAILS_END +} + +void testNotEqualInt32s(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT32(-2147483647, -2147483648); //use largest 32 bit negative to test printability + VERIFY_FAILS_END +} + +void testNotEqualBits(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_BITS(0xFF00, 0x5555, 0x5A55); + VERIFY_FAILS_END +} + +void testNotEqualUInts(void) +{ + UNITY_UINT16 v0, v1; + + v0 = 9000; + v1 = 9001; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT(v0, v1); + VERIFY_FAILS_END +} + +void testNotEqualUInt8s(void) +{ + UNITY_UINT8 v0, v1; + + v0 = 254; + v1 = 255; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT8(v0, v1); + VERIFY_FAILS_END +} + +void testNotEqualUInt16s(void) +{ + UNITY_UINT16 v0, v1; + + v0 = 65535; + v1 = 65534; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT16(v0, v1); + VERIFY_FAILS_END +} + +void testNotEqualUInt32s(void) +{ + UNITY_UINT32 v0, v1; + + v0 = 4294967295; + v1 = 4294967294; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT32(v0, v1); + VERIFY_FAILS_END +} + +void testNotEqualHex8s(void) +{ + UNITY_UINT8 v0, v1; + + v0 = 0x23; + v1 = 0x22; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX8(v0, v1); + VERIFY_FAILS_END +} + +void testNotEqualHex8sIfSigned(void) +{ + UNITY_INT8 v0, v1; + + v0 = -2; + v1 = 2; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX8(v0, v1); + VERIFY_FAILS_END +} + +void testNotEqualHex16s(void) +{ + UNITY_UINT16 v0, v1; + + v0 = 0x1234; + v1 = 0x1235; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX16(v0, v1); + VERIFY_FAILS_END +} + +void testNotEqualHex16sIfSigned(void) +{ + UNITY_INT16 v0, v1; + + v0 = -1024; + v1 = -1028; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX16(v0, v1); + VERIFY_FAILS_END +} + +void testNotEqualHex32s(void) +{ + UNITY_UINT32 v0, v1; + + v0 = 900000; + v1 = 900001; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX32(v0, v1); + VERIFY_FAILS_END +} + +void testNotEqualHex32sIfSigned(void) +{ + UNITY_INT32 v0, v1; + + v0 = -900000; + v1 = 900001; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX32(v0, v1); + VERIFY_FAILS_END +} + +void testEqualInts(void) +{ + int v0, v1; + int *p0, *p1; + + v0 = 19467; + v1 = 19467; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_INT(1837, 1837); + TEST_ASSERT_EQUAL_INT(-27365, -27365); + TEST_ASSERT_EQUAL_INT(v0, v1); + TEST_ASSERT_EQUAL_INT(19467, v1); + TEST_ASSERT_EQUAL_INT(v0, 19467); + TEST_ASSERT_EQUAL_INT(*p0, v1); + TEST_ASSERT_EQUAL_INT(*p0, *p1); + TEST_ASSERT_EQUAL_INT(*p0, 19467); +} + +void testEqualInt8s(void) +{ + UNITY_INT8 v0, v1; + UNITY_INT8 *p0, *p1; + + v0 = 0x22; + v1 = 0x22; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_INT8(0x22, 0x22); + TEST_ASSERT_EQUAL_INT8(v0, v1); + TEST_ASSERT_EQUAL_INT8(0x22, v1); + TEST_ASSERT_EQUAL_INT8(v0, 0x22); + TEST_ASSERT_EQUAL_INT8(*p0, v1); + TEST_ASSERT_EQUAL_INT8(*p0, *p1); + TEST_ASSERT_EQUAL_INT8(*p0, 0x22); +} + +void testEqualInt8sWhenThereAreDifferencesOutside8Bits(void) +{ + TEST_ASSERT_EQUAL_INT8(0x321,0x421); + TEST_ASSERT_EQUAL_INT8(0xFF21,0x0021); +} + +void testEqualInt16s(void) +{ + UNITY_INT16 v0, v1; + UNITY_INT16 *p0, *p1; + + v0 = 0x7876; + v1 = 0x7876; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_INT16(0x7876, 0x7876); + TEST_ASSERT_EQUAL_INT16(v0, v1); + TEST_ASSERT_EQUAL_INT16(0x7876, v1); + TEST_ASSERT_EQUAL_INT16(v0, 0x7876); + TEST_ASSERT_EQUAL_INT16(*p0, v1); + TEST_ASSERT_EQUAL_INT16(*p0, *p1); + TEST_ASSERT_EQUAL_INT16(*p0, 0x7876); +} + +void testEqualInt16sNegatives(void) +{ + UNITY_INT16 v0, v1; + UNITY_INT16 *p0, *p1; + + v0 = -7876; + v1 = -7876; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_INT16(-7876, -7876); + TEST_ASSERT_EQUAL_INT16(v0, v1); + TEST_ASSERT_EQUAL_INT16(-7876, v1); + TEST_ASSERT_EQUAL_INT16(v0, -7876); + TEST_ASSERT_EQUAL_INT16(*p0, v1); + TEST_ASSERT_EQUAL_INT16(*p0, *p1); + TEST_ASSERT_EQUAL_INT16(*p0, -7876); +} + +void testEqualInt16sWhenThereAreDifferencesOutside16Bits(void) +{ + TEST_ASSERT_EQUAL_INT16(0x54321,0x64321); + TEST_ASSERT_EQUAL_INT16(0xFFFF4321,0x00004321); +} + +void testEqualInt32s(void) +{ + UNITY_INT32 v0, v1; + UNITY_INT32 *p0, *p1; + + v0 = 0x78760000; + v1 = 0x78760000; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_INT32(0x78760000, 0x78760000); + TEST_ASSERT_EQUAL_INT32(v0, v1); + TEST_ASSERT_EQUAL_INT32(0x78760000, v1); + TEST_ASSERT_EQUAL_INT32(v0, 0x78760000); + TEST_ASSERT_EQUAL_INT32(*p0, v1); + TEST_ASSERT_EQUAL_INT32(*p0, *p1); + TEST_ASSERT_EQUAL_INT32(*p0, 0x78760000); +} + +void testEqualInt32sNegatives(void) +{ + UNITY_INT32 v0, v1; + UNITY_INT32 *p0, *p1; + + v0 = -123456789; + v1 = -123456789; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_INT32(-123456789, -123456789); + TEST_ASSERT_EQUAL_INT32(v0, v1); + TEST_ASSERT_EQUAL_INT32(-123456789, v1); + TEST_ASSERT_EQUAL_INT32(v0, -123456789); + TEST_ASSERT_EQUAL_INT32(*p0, v1); + TEST_ASSERT_EQUAL_INT32(*p0, *p1); + TEST_ASSERT_EQUAL_INT32(*p0, -123456789); +} + + +void testEqualUints(void) +{ + unsigned int v0, v1; + unsigned int *p0, *p1; + + v0 = 19467; + v1 = 19467; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_UINT(1837, 1837); + TEST_ASSERT_EQUAL_UINT(v0, v1); + TEST_ASSERT_EQUAL_UINT(19467, v1); + TEST_ASSERT_EQUAL_UINT(v0, 19467); + TEST_ASSERT_EQUAL_UINT(*p0, v1); + TEST_ASSERT_EQUAL_UINT(*p0, *p1); + TEST_ASSERT_EQUAL_UINT(*p0, 19467); + TEST_ASSERT_EQUAL_UINT(60872u, 60872u); +} + + +void testEqualUint8s(void) +{ + UNITY_UINT8 v0, v1; + UNITY_UINT8 *p0, *p1; + + v0 = 0x22; + v1 = 0x22; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_UINT8(0x22, 0x22); + TEST_ASSERT_EQUAL_UINT8(v0, v1); + TEST_ASSERT_EQUAL_UINT8(0x22, v1); + TEST_ASSERT_EQUAL_UINT8(v0, 0x22); + TEST_ASSERT_EQUAL_UINT8(*p0, v1); + TEST_ASSERT_EQUAL_UINT8(*p0, *p1); + TEST_ASSERT_EQUAL_UINT8(*p0, 0x22); +} + +void testEqualUint8sWhenThereAreDifferencesOutside8Bits(void) +{ + TEST_ASSERT_EQUAL_UINT8(0x321,0x421); + TEST_ASSERT_EQUAL_UINT8(0xFF21,0x0021); +} + +void testEqualUint16s(void) +{ + UNITY_UINT16 v0, v1; + UNITY_UINT16 *p0, *p1; + + v0 = 0x9876; + v1 = 0x9876; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_UINT16(0x9876, 0x9876); + TEST_ASSERT_EQUAL_UINT16(v0, v1); + TEST_ASSERT_EQUAL_UINT16(0x9876, v1); + TEST_ASSERT_EQUAL_UINT16(v0, 0x9876); + TEST_ASSERT_EQUAL_UINT16(*p0, v1); + TEST_ASSERT_EQUAL_UINT16(*p0, *p1); + TEST_ASSERT_EQUAL_UINT16(*p0, 0x9876); +} + +void testEqualUint16sWhenThereAreDifferencesOutside16Bits(void) +{ + TEST_ASSERT_EQUAL_UINT16(0x54321,0x64321); + TEST_ASSERT_EQUAL_UINT16(0xFFFF4321,0x00004321); +} + +void testEqualUint32s(void) +{ + UNITY_UINT32 v0, v1; + UNITY_UINT32 *p0, *p1; + + v0 = 0x98760000; + v1 = 0x98760000; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_UINT32(0x98760000, 0x98760000); + TEST_ASSERT_EQUAL_UINT32(v0, v1); + TEST_ASSERT_EQUAL_UINT32(0x98760000, v1); + TEST_ASSERT_EQUAL_UINT32(v0, 0x98760000); + TEST_ASSERT_EQUAL_UINT32(*p0, v1); + TEST_ASSERT_EQUAL_UINT32(*p0, *p1); + TEST_ASSERT_EQUAL_UINT32(*p0, 0x98760000); +} + +void testNotEqual(void) +{ + TEST_ASSERT_NOT_EQUAL(0, 1); + TEST_ASSERT_NOT_EQUAL(1, 0); + TEST_ASSERT_NOT_EQUAL(100, 101); + TEST_ASSERT_NOT_EQUAL(0, -1); + TEST_ASSERT_NOT_EQUAL(65535, -65535); + TEST_ASSERT_NOT_EQUAL(75, 900); + TEST_ASSERT_NOT_EQUAL(-100, -101); +} + +void testEqualHex8s(void) +{ + UNITY_UINT8 v0, v1; + UNITY_UINT8 *p0, *p1; + + v0 = 0x22; + v1 = 0x22; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_HEX8(0x22, 0x22); + TEST_ASSERT_EQUAL_HEX8(v0, v1); + TEST_ASSERT_EQUAL_HEX8(0x22, v1); + TEST_ASSERT_EQUAL_HEX8(v0, 0x22); + TEST_ASSERT_EQUAL_HEX8(*p0, v1); + TEST_ASSERT_EQUAL_HEX8(*p0, *p1); + TEST_ASSERT_EQUAL_HEX8(*p0, 0x22); +} + +void testEqualHex8sWhenThereAreDifferencesOutside8Bits(void) +{ + TEST_ASSERT_EQUAL_HEX8(0x321,0x421); + TEST_ASSERT_EQUAL_HEX8(0xFF21,0x0021); +} + +void testEqualHex8sNegatives(void) +{ + UNITY_UINT8 v0, v1; + UNITY_UINT8 *p0, *p1; + + v0 = 0xDD; + v1 = 0xDD; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_HEX8(0xDD, 0xDD); + TEST_ASSERT_EQUAL_HEX8(v0, v1); + TEST_ASSERT_EQUAL_HEX8(0xDD, v1); + TEST_ASSERT_EQUAL_HEX8(v0, 0xDD); + TEST_ASSERT_EQUAL_HEX8(*p0, v1); + TEST_ASSERT_EQUAL_HEX8(*p0, *p1); + TEST_ASSERT_EQUAL_HEX8(*p0, 0xDD); +} + +void testEqualHex16s(void) +{ + UNITY_UINT16 v0, v1; + UNITY_UINT16 *p0, *p1; + + v0 = 0x9876; + v1 = 0x9876; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_HEX16(0x9876, 0x9876); + TEST_ASSERT_EQUAL_HEX16(v0, v1); + TEST_ASSERT_EQUAL_HEX16(0x9876, v1); + TEST_ASSERT_EQUAL_HEX16(v0, 0x9876); + TEST_ASSERT_EQUAL_HEX16(*p0, v1); + TEST_ASSERT_EQUAL_HEX16(*p0, *p1); + TEST_ASSERT_EQUAL_HEX16(*p0, 0x9876); +} + +void testEqualHex16sWhenThereAreDifferencesOutside16Bits(void) +{ + TEST_ASSERT_EQUAL_HEX16(0x54321,0x64321); + TEST_ASSERT_EQUAL_HEX16(0xFFFF4321,0x00004321); +} + +void testEqualHex32s(void) +{ + UNITY_UINT32 v0, v1; + UNITY_UINT32 *p0, *p1; + + v0 = 0x98765432ul; + v1 = 0x98765432ul; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_HEX32(0x98765432ul, 0x98765432ul); + TEST_ASSERT_EQUAL_HEX32(v0, v1); + TEST_ASSERT_EQUAL_HEX32(0x98765432ul, v1); + TEST_ASSERT_EQUAL_HEX32(v0, 0x98765432ul); + TEST_ASSERT_EQUAL_HEX32(*p0, v1); + TEST_ASSERT_EQUAL_HEX32(*p0, *p1); + TEST_ASSERT_EQUAL_HEX32(*p0, 0x98765432ul); +} + +void testEqualBits(void) +{ + UNITY_UINT32 v0 = 0xFF55AA00; + UNITY_UINT32 v1 = 0x55550000; + + TEST_ASSERT_BITS(v1, v0, 0x55550000); + TEST_ASSERT_BITS(v1, v0, 0xFF55CC00); + TEST_ASSERT_BITS(0xFFFFFFFF, v0, 0xFF55AA00); + TEST_ASSERT_BITS(0xFFFFFFFF, v0, v0); + TEST_ASSERT_BITS(0xF0F0F0F0, v0, 0xFC5DAE0F); + TEST_ASSERT_BITS_HIGH(v1, v0); + TEST_ASSERT_BITS_LOW(0x000055FF, v0); + TEST_ASSERT_BIT_HIGH(30, v0); + TEST_ASSERT_BIT_LOW(5, v0); +} + +void testNotEqualBitHigh(void) +{ + UNITY_UINT32 v0 = 0x7F55AA00; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_BIT_HIGH(31, v0); + VERIFY_FAILS_END +} + +void testNotEqualBitLow(void) +{ + UNITY_UINT32 v0 = 0xFF55AA00; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_BIT_LOW(30, v0); + VERIFY_FAILS_END +} + +void testNotEqualBitsHigh(void) +{ + UNITY_UINT32 v0 = 0xFF55AA00; + UNITY_UINT32 v1 = 0x55550000; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_BITS_HIGH(v0, v1); + VERIFY_FAILS_END + +} + +void testNotEqualBitsLow(void) +{ + UNITY_UINT32 v0 = 0xFF55AA00; + UNITY_UINT32 v1 = 0x55550000; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_BITS_LOW(v0, v1); + VERIFY_FAILS_END +} + + +void testEqualShorts(void) +{ + short v0, v1; + short *p0, *p1; + + v0 = 19467; + v1 = 19467; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_INT(1837, 1837); + TEST_ASSERT_EQUAL_INT(-2987, -2987); + TEST_ASSERT_EQUAL_INT(v0, v1); + TEST_ASSERT_EQUAL_INT(19467, v1); + TEST_ASSERT_EQUAL_INT(v0, 19467); + TEST_ASSERT_EQUAL_INT(*p0, v1); + TEST_ASSERT_EQUAL_INT(*p0, *p1); + TEST_ASSERT_EQUAL_INT(*p0, 19467); +} + +void testEqualUShorts(void) +{ + unsigned short v0, v1; + unsigned short *p0, *p1; + + v0 = 19467; + v1 = 19467; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_UINT(1837, 1837); + TEST_ASSERT_EQUAL_UINT(2987, 2987); + TEST_ASSERT_EQUAL_UINT(v0, v1); + TEST_ASSERT_EQUAL_UINT(19467, v1); + TEST_ASSERT_EQUAL_UINT(v0, 19467); + TEST_ASSERT_EQUAL_UINT(*p0, v1); + TEST_ASSERT_EQUAL_UINT(*p0, *p1); + TEST_ASSERT_EQUAL_UINT(*p0, 19467); +} + +void testEqualChars(void) +{ + signed char v0, v1; + signed char *p0, *p1; + + v0 = 109; + v1 = 109; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_INT(42, 42); + TEST_ASSERT_EQUAL_INT(-116, -116); + TEST_ASSERT_EQUAL_INT(v0, v1); + TEST_ASSERT_EQUAL_INT(109, v1); + TEST_ASSERT_EQUAL_INT(v0, 109); + TEST_ASSERT_EQUAL_INT(*p0, v1); + TEST_ASSERT_EQUAL_INT(*p0, *p1); + TEST_ASSERT_EQUAL_INT(*p0, 109); +} + +void testEqualUChars(void) +{ + unsigned char v0, v1; + unsigned char *p0, *p1; + + v0 = 251; + v1 = 251; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_INT(42, 42); + TEST_ASSERT_EQUAL_INT(v0, v1); + TEST_ASSERT_EQUAL_INT(251, v1); + TEST_ASSERT_EQUAL_INT(v0, 251); + TEST_ASSERT_EQUAL_INT(*p0, v1); + TEST_ASSERT_EQUAL_INT(*p0, *p1); + TEST_ASSERT_EQUAL_INT(*p0, 251); +} + +void testEqualPointers(void) +{ + int v0, v1; + int *p0, *p1, *p2; + + v0 = 19467; + v1 = 18271; + p0 = &v0; + p1 = &v1; + p2 = &v1; + + TEST_ASSERT_EQUAL_PTR(p0, &v0); + TEST_ASSERT_EQUAL_PTR(&v1, p1); + TEST_ASSERT_EQUAL_PTR(p2, p1); + TEST_ASSERT_EQUAL_PTR(&v0, &v0); +} + +void testNotEqualPointers(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_PTR(0x12345678, 0x12345677); + VERIFY_FAILS_END +} + +void testIntsWithinDelta(void) +{ + TEST_ASSERT_INT_WITHIN(1, 5000, 5001); + TEST_ASSERT_INT_WITHIN(5, 5000, 4996); + TEST_ASSERT_INT_WITHIN(5, 5000, 5005); + TEST_ASSERT_INT_WITHIN(500, 50, -440); + + TEST_ASSERT_INT_WITHIN(2, -1, -1); + TEST_ASSERT_INT_WITHIN(5, 1, -1); + TEST_ASSERT_INT_WITHIN(5, -1, 1); +} + +void testIntsWithinDeltaAndCustomMessage(void) +{ + TEST_ASSERT_INT_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message."); + TEST_ASSERT_INT_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message."); + TEST_ASSERT_INT_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message."); + TEST_ASSERT_INT_WITHIN_MESSAGE(500, 50, -440, "Custom Message."); + + TEST_ASSERT_INT_WITHIN_MESSAGE(2, -1, -1, "Custom Message."); + TEST_ASSERT_INT_WITHIN_MESSAGE(5, 1, -1, "Custom Message."); + TEST_ASSERT_INT_WITHIN_MESSAGE(5, -1, 1, "Custom Message."); +} + +void testIntsNotWithinDelta(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT_WITHIN(5, 5000, 5006); + VERIFY_FAILS_END +} + +void testIntsNotWithinDeltaAndCustomMessage(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT_WITHIN_MESSAGE(5, 5000, 5006, "Custom Message."); + VERIFY_FAILS_END +} + +void testUIntsWithinDelta(void) +{ + TEST_ASSERT_UINT_WITHIN(1, 5000, 5001); + TEST_ASSERT_UINT_WITHIN(5, 5000, 4996); + TEST_ASSERT_UINT_WITHIN(5, 5000, 5005); +} + +void testUIntsWithinDeltaAndCustomMessage(void) +{ + TEST_ASSERT_UINT_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message."); + TEST_ASSERT_UINT_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message."); + TEST_ASSERT_UINT_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message."); +} + +void testUIntsNotWithinDelta(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT_WITHIN(1, 2147483647u, 2147483649u); + VERIFY_FAILS_END +} + +void testUIntsNotWithinDeltaAndCustomMessage(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT_WITHIN_MESSAGE(1, 2147483647u, 2147483649u, "Custom Message."); + VERIFY_FAILS_END +} + +void testUIntsNotWithinDeltaEvenThoughASignedIntWouldPassSmallFirst(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT_WITHIN(5, 1, -1); + VERIFY_FAILS_END +} + +void testUIntsNotWithinDeltaEvenThoughASignedIntWouldPassSmallFirstAndCustomMessage(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT_WITHIN_MESSAGE(5, 1, -1, "Custom Message."); + VERIFY_FAILS_END +} + +void testUIntsNotWithinDeltaEvenThoughASignedIntWouldPassBigFirst(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT_WITHIN(5, -1, 1); + VERIFY_FAILS_END +} + +void testUIntsNotWithinDeltaEvenThoughASignedIntWouldPassBigFirstAndCustomMessage(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT_WITHIN_MESSAGE(5, -1, 1, "Custom Message."); + VERIFY_FAILS_END +} + +void testHEX32sWithinDelta(void) +{ + TEST_ASSERT_HEX32_WITHIN(1, 5000, 5001); + TEST_ASSERT_HEX32_WITHIN(5, 5000, 4996); + TEST_ASSERT_HEX32_WITHIN(5, 5000, 5005); +} + +void testHEX32sWithinDeltaAndCustomMessage(void) +{ + TEST_ASSERT_HEX32_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message."); + TEST_ASSERT_HEX32_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message."); + TEST_ASSERT_HEX32_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message."); +} + +void testHEX32sNotWithinDelta(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX32_WITHIN(1, 2147483647u, 2147483649u); + VERIFY_FAILS_END +} + +void testHEX32sNotWithinDeltaAndCustomMessage(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX32_WITHIN_MESSAGE(1, 2147483647u, 2147483649u, "Custom Message."); + VERIFY_FAILS_END +} + +void testHEX32sNotWithinDeltaEvenThoughASignedIntWouldPass(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX32_WITHIN(5, 1, -1); + VERIFY_FAILS_END +} + +void testHEX32sNotWithinDeltaEvenThoughASignedIntWouldPassAndCustomMessage(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX32_WITHIN_MESSAGE(5, 1, -1, "Custom Message."); + VERIFY_FAILS_END +} + +void testHEX16sWithinDelta(void) +{ + TEST_ASSERT_HEX16_WITHIN(1, 5000, 5001); + TEST_ASSERT_HEX16_WITHIN(5, 5000, 4996); + TEST_ASSERT_HEX16_WITHIN(5, 5000, 5005); +} + +void testHEX16sWithinDeltaAndCustomMessage(void) +{ + TEST_ASSERT_HEX16_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message."); + TEST_ASSERT_HEX16_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message."); + TEST_ASSERT_HEX16_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message."); +} + +void testHEX16sWithinDeltaWhenThereAreDifferenceOutsideOf16Bits(void) +{ + TEST_ASSERT_HEX16_WITHIN(5, 0x54321, 0x44321); +} + +void testHEX16sWithinDeltaWhenThereAreDifferenceOutsideOf16BitsAndCustomMessage(void) +{ + TEST_ASSERT_HEX16_WITHIN_MESSAGE(5, 0x54321, 0x44321, "Custom Message."); +} + +void testHEX16sNotWithinDelta(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX16_WITHIN(2, 65535, 0); + VERIFY_FAILS_END +} + +void testHEX16sNotWithinDeltaAndCustomMessage(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX16_WITHIN_MESSAGE(2, 65535, 0, "Custom Message."); + VERIFY_FAILS_END +} + +void testHEX8sWithinDelta(void) +{ + TEST_ASSERT_HEX8_WITHIN(1, 254, 255); + TEST_ASSERT_HEX8_WITHIN(5, 251, 255); + TEST_ASSERT_HEX8_WITHIN(5, 1, 4); +} + +void testHEX8sWithinDeltaAndCustomMessage(void) +{ + TEST_ASSERT_HEX8_WITHIN_MESSAGE(1, 254, 255, "Custom Message."); + TEST_ASSERT_HEX8_WITHIN_MESSAGE(5, 251, 255, "Custom Message."); + TEST_ASSERT_HEX8_WITHIN_MESSAGE(5, 1, 4, "Custom Message."); +} + +void testHEX8sWithinDeltaWhenThereAreDifferenceOutsideOf8Bits(void) +{ + TEST_ASSERT_HEX8_WITHIN(5, 0x123, 0xF23); +} + +void testHEX8sWithinDeltaWhenThereAreDifferenceOutsideOf8BitsAndCustomMessage(void) +{ + TEST_ASSERT_HEX8_WITHIN_MESSAGE(5, 0x123, 0xF23, "Custom Message."); +} + +void testHEX8sNotWithinDelta(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX8_WITHIN(2, 255, 0); + VERIFY_FAILS_END +} + +void testHEX8sNotWithinDeltaAndCustomMessage(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX8_WITHIN_MESSAGE(2, 255, 0, "Custom Message."); + VERIFY_FAILS_END +} + +//----------------- + +void testUINT32sWithinDelta(void) +{ + TEST_ASSERT_UINT32_WITHIN(1, 5000, 5001); + TEST_ASSERT_UINT32_WITHIN(5, 5000, 4996); + TEST_ASSERT_UINT32_WITHIN(5, 5000, 5005); +} + +void testUINT32sWithinDeltaAndCustomMessage(void) +{ + TEST_ASSERT_UINT32_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message."); + TEST_ASSERT_UINT32_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message."); + TEST_ASSERT_UINT32_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message."); +} + +void testUINT32sNotWithinDelta(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT32_WITHIN(1, 2147483647u, 2147483649u); + VERIFY_FAILS_END +} + +void testUINT32sNotWithinDeltaAndCustomMessage(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT32_WITHIN_MESSAGE(1, 2147483647u, 2147483649u, "Custom Message."); + VERIFY_FAILS_END +} + +void testUINT32sNotWithinDeltaEvenThoughASignedIntWouldPass(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT32_WITHIN(5, 1, -1); + VERIFY_FAILS_END +} + +void testUINT32sNotWithinDeltaEvenThoughASignedIntWouldPassAndCustomMessage(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT32_WITHIN_MESSAGE(5, 1, -1, "Custom Message."); + VERIFY_FAILS_END +} + +void testUINT16sWithinDelta(void) +{ + TEST_ASSERT_UINT16_WITHIN(1, 5000, 5001); + TEST_ASSERT_UINT16_WITHIN(5, 5000, 4996); + TEST_ASSERT_UINT16_WITHIN(5, 5000, 5005); +} + +void testUINT16sWithinDeltaAndCustomMessage(void) +{ + TEST_ASSERT_UINT16_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message."); + TEST_ASSERT_UINT16_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message."); + TEST_ASSERT_UINT16_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message."); +} + +void testUINT16sWithinDeltaWhenThereAreDifferenceOutsideOf16Bits(void) +{ + TEST_ASSERT_UINT16_WITHIN(5, 0x54321, 0x44321); +} + +void testUINT16sWithinDeltaWhenThereAreDifferenceOutsideOf16BitsAndCustomMessage(void) +{ + TEST_ASSERT_UINT16_WITHIN_MESSAGE(5, 0x54321, 0x44321, "Custom Message."); +} + +void testUINT16sNotWithinDelta(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT16_WITHIN(2, 65535, 0); + VERIFY_FAILS_END +} + +void testUINT16sNotWithinDeltaAndCustomMessage(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT16_WITHIN_MESSAGE(2, 65535, 0, "Custom Message."); + VERIFY_FAILS_END +} + +void testUINT8sWithinDelta(void) +{ + TEST_ASSERT_UINT8_WITHIN(1, 254, 255); + TEST_ASSERT_UINT8_WITHIN(5, 251, 255); + TEST_ASSERT_UINT8_WITHIN(5, 1, 4); +} + +void testUINT8sWithinDeltaAndCustomMessage(void) +{ + TEST_ASSERT_UINT8_WITHIN_MESSAGE(1, 254, 255, "Custom Message."); + TEST_ASSERT_UINT8_WITHIN_MESSAGE(5, 251, 255, "Custom Message."); + TEST_ASSERT_UINT8_WITHIN_MESSAGE(5, 1, 4, "Custom Message."); +} + +void testUINT8sWithinDeltaWhenThereAreDifferenceOutsideOf8Bits(void) +{ + TEST_ASSERT_UINT8_WITHIN(5, 0x123, 0xF23); +} + +void testUINT8sWithinDeltaWhenThereAreDifferenceOutsideOf8BitsAndCustomMessage(void) +{ + TEST_ASSERT_UINT8_WITHIN_MESSAGE(5, 0x123, 0xF23, "Custom Message."); +} + +void testUINT8sNotWithinDelta(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT8_WITHIN(2, 255, 0); + VERIFY_FAILS_END +} + +void testUINT8sNotWithinDeltaAndCustomMessage(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT8_WITHIN_MESSAGE(2, 255, 0, "Custom Message."); + VERIFY_FAILS_END +} + +void testINT32sWithinDelta(void) +{ + TEST_ASSERT_INT32_WITHIN(1, 5000, 5001); + TEST_ASSERT_INT32_WITHIN(5, 1, -2); + TEST_ASSERT_INT32_WITHIN(5, -2, 1); +} + +void testINT32sWithinDeltaAndCustomMessage(void) +{ + TEST_ASSERT_INT32_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message."); +} + +void testINT32sNotWithinDelta(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT32_WITHIN(1, -3, 1); + VERIFY_FAILS_END +} + +void testINT32sNotWithinDeltaAndDifferenceOverflows(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT32_WITHIN(1, -1, 0x7FFFFFFF); + VERIFY_FAILS_END +} +void testINT32sNotWithinDeltaAndCustomMessage(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT32_WITHIN_MESSAGE(1, -2, 1, "Custom Message."); + VERIFY_FAILS_END +} + +void testINT16sWithinDelta(void) +{ + TEST_ASSERT_INT16_WITHIN(1, 5000, 5001); + TEST_ASSERT_INT16_WITHIN(5, 2, -2); + TEST_ASSERT_INT16_WITHIN(5, -2, 2); +} + +void testINT16sWithinDeltaAndCustomMessage(void) +{ + TEST_ASSERT_INT16_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message."); +} + +void testINT16sWithinDeltaWhenThereAreDifferenceOutsideOf16Bits(void) +{ + TEST_ASSERT_INT16_WITHIN(5, 0x54321, 0x44321); +} + +void testINT16sWithinDeltaWhenThereAreDifferenceOutsideOf16BitsAndCustomMessage(void) +{ + TEST_ASSERT_INT16_WITHIN_MESSAGE(5, 0x54321, 0x44321, "Custom Message."); +} + +void testINT16sNotWithinDelta(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT16_WITHIN(2, 4, -2); + VERIFY_FAILS_END +} + +void testINT16sNotWithinDeltaAndCustomMessage(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT16_WITHIN_MESSAGE(2, 3, 0, "Custom Message."); + VERIFY_FAILS_END +} + +void testINT8sWithinDelta(void) +{ + TEST_ASSERT_INT8_WITHIN(1, 127, 126); + TEST_ASSERT_INT8_WITHIN(5, -2, 2); + TEST_ASSERT_INT8_WITHIN(5, 2, -2); +} + +void testINT8sWithinDeltaAndCustomMessage(void) +{ + TEST_ASSERT_INT8_WITHIN_MESSAGE(5, 1, 4, "Custom Message."); +} + +void testINT8sWithinDeltaWhenThereAreDifferenceOutsideOf8Bits(void) +{ + TEST_ASSERT_INT8_WITHIN(5, 0x123, 0xF23); +} + +void testINT8sWithinDeltaWhenThereAreDifferenceOutsideOf8BitsAndCustomMessage(void) +{ + TEST_ASSERT_INT8_WITHIN_MESSAGE(5, 0x123, 0xF23, "Custom Message."); +} + +void testINT8sNotWithinDelta(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT8_WITHIN(2, -3, 0); + VERIFY_FAILS_END +} + +void testINT8sNotWithinDeltaAndCustomMessage(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT8_WITHIN_MESSAGE(2, -4, 0, "Custom Message."); + VERIFY_FAILS_END +} + +//------------------------ + +void testInt64ArrayWithinDelta(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; + UNITY_INT64 acutalSmallDelta[] = {12345001, -12344996, 12345005}; + UNITY_INT64 acutalBigDelta[] = {12345101, -12344896, 12345055}; + + TEST_ASSERT_INT64_ARRAY_WITHIN(1, expected, acutalSmallDelta, 3); + TEST_ASSERT_INT64_ARRAY_WITHIN(110, expected, acutalBigDelta, 3); +#endif +} + +void testInt64ArrayWithinDeltaAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; + UNITY_INT64 acutalSmallDelta[] = {12345001, -12344996, 12345005}; + UNITY_INT64 acutalBigDelta[] = {12345101, -12344896, 12345055}; + + TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(1, expected, acutalSmallDelta, 3, "Custom Message."); + TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(110, expected, acutalBigDelta, 3, "Custom Message."); +#endif +} + +void tesUInt64ArrayNotWithinDelta(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; + UNITY_INT64 acutalBigDelta[] = {12345101, -12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT64_ARRAY_WITHIN(1, expected, acutalBigDelta, 3); + VERIFY_FAILS_END +#endif +} + +void testInt64ArrayNotWithinDeltaAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; + UNITY_INT64 acutalBigDelta[] = {12345101, -12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(1, expected, acutalBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testInt64ArrayWithinDeltaPointless(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; + UNITY_INT64 acutalBigDelta[] = {12345101, -12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT64_ARRAY_WITHIN(110, expected, acutalBigDelta, 0); + VERIFY_FAILS_END +#endif +} + +void testInt64ArrayWithinDeltaPointlessAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; + UNITY_INT64 acutalBigDelta[] = {12345101, -12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(110, expected, acutalBigDelta, 0, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testInt64ArrayWithinDeltaExpectedNull(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 acutalBigDelta[] = {12345101, -12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT64_ARRAY_WITHIN(110, NULL, acutalBigDelta, 3); + VERIFY_FAILS_END +#endif +} + +void testInt64ArrayWithinDeltaExpectedNullAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 acutalBigDelta[] = {12345101, -12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(110, NULL, acutalBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testInt64ArrayWithinDeltaActualNull(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT64_ARRAY_WITHIN(110, expected, NULL, 3); + VERIFY_FAILS_END +#endif +} + +void testInt64ArrayWithinDeltaActualNullAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(110, expected, NULL, 3, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testInt64ArrayWithinDeltaSamePointer(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; + + TEST_ASSERT_UINT64_ARRAY_WITHIN(110, expected, expected, 3); +#endif +} + +void testInt64ArrayWithinDeltaSamePointerAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; + + TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(110, expected, expected, 3, "Custom Message."); +#endif +} + +void testIntArrayWithinDelta(void) +{ + UNITY_INT expected[] = {5000, -4995, 5005}; + UNITY_INT acutalSmallDelta[] = {5001, -4996, 5005}; + UNITY_INT acutalBigDelta[] = {5101, -4896, 5055}; + + TEST_ASSERT_INT_ARRAY_WITHIN(1, expected, acutalSmallDelta, 3); + TEST_ASSERT_INT_ARRAY_WITHIN(110, expected, acutalBigDelta, 3); +} + +void testIntArrayWithinDeltaAndMessage(void) +{ + UNITY_INT expected[] = {5000, -4995, 5005}; + UNITY_INT acutalSmallDelta[] = {5001, -4996, 5005}; + UNITY_INT acutalBigDelta[] = {5101, -4896, 5055}; + + TEST_ASSERT_INT_ARRAY_WITHIN_MESSAGE(1, expected, acutalSmallDelta, 3, "Custom Message."); + TEST_ASSERT_INT_ARRAY_WITHIN_MESSAGE(110, expected, acutalBigDelta, 3, "Custom Message."); +} + +void testIntArrayNotWithinDelta(void) +{ + UNITY_INT expected[] = {5000, -4995, 5005}; + UNITY_INT acutalBigDelta[] = {5101, -4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT_ARRAY_WITHIN(1, expected, acutalBigDelta, 3); + VERIFY_FAILS_END +} + +void testIntArrayNotWithinDeltaAndMessage(void) +{ + UNITY_INT expected[] = {5000, -4995, 5005}; + UNITY_INT acutalBigDelta[] = {5101, -4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT_ARRAY_WITHIN_MESSAGE(1, expected, acutalBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testIntArrayWithinDeltaPointless(void) +{ + UNITY_INT expected[] = {5000, -4995, 5005}; + UNITY_INT acutalBigDelta[] = {5101, -4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT_ARRAY_WITHIN(110, expected, acutalBigDelta, 0); + VERIFY_FAILS_END +} + +void testIntArrayWithinDeltaPointlessAndMessage(void) +{ + UNITY_INT expected[] = {5000, -4995, 5005}; + UNITY_INT acutalBigDelta[] = {5101, -4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT_ARRAY_WITHIN_MESSAGE(110, expected, acutalBigDelta, 0, "Custom Message."); + VERIFY_FAILS_END +} + +void testIntArrayWithinDeltaExpectedNull(void) +{ + UNITY_INT acutalBigDelta[] = {5101, -4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT_ARRAY_WITHIN(110, NULL, acutalBigDelta, 3); + VERIFY_FAILS_END +} + +void testIntArrayWithinDeltaExpectedNullAndMessage(void) +{ + UNITY_INT acutalBigDelta[] = {5101, -4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT_ARRAY_WITHIN_MESSAGE(110, NULL, acutalBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testIntArrayWithinDeltaActualNull(void) +{ + UNITY_INT expected[] = {5000, -4995, 5005}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT_ARRAY_WITHIN(110, expected, NULL, 3); + VERIFY_FAILS_END +} + +void testIntArrayWithinDeltaActualNullAndMessage(void) +{ + UNITY_INT expected[] = {5000, -4995, 5005}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT_ARRAY_WITHIN_MESSAGE(110, expected, NULL, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testIntArrayWithinDeltaSamePointer(void) +{ + UNITY_INT expected[] = {5000, -4995, 5005}; + + TEST_ASSERT_INT_ARRAY_WITHIN(110, expected, expected, 3); +} + +void testIntArrayWithinDeltaSamePointerAndMessage(void) +{ + UNITY_INT expected[] = {5000, -4995, 5005}; + + TEST_ASSERT_INT_ARRAY_WITHIN_MESSAGE(110, expected, expected, 3, "Custom Message."); +} + +void testInt16ArrayWithinDelta(void) +{ + UNITY_INT16 expected[] = {5000, -4995, 5005}; + UNITY_INT16 acutalSmallDelta[] = {5001, -4996, 5005}; + UNITY_INT16 acutalBigDelta[] = {5101, -4896, 5055}; + + TEST_ASSERT_INT16_ARRAY_WITHIN(1, expected, acutalSmallDelta, 3); + TEST_ASSERT_INT16_ARRAY_WITHIN(110, expected, acutalBigDelta, 3); +} + +void testInt16ArrayWithinDeltaAndMessage(void) +{ + UNITY_INT16 expected[] = {5000, -4995, 5005}; + UNITY_INT16 acutalSmallDelta[] = {5001, -4996, 5005}; + UNITY_INT16 acutalBigDelta[] = {5101, -4896, 5055}; + + TEST_ASSERT_INT16_ARRAY_WITHIN_MESSAGE(1, expected, acutalSmallDelta, 3, "Custom Message."); + TEST_ASSERT_INT16_ARRAY_WITHIN_MESSAGE(110, expected, acutalBigDelta, 3, "Custom Message."); +} + +void testInt16ArrayNotWithinDelta(void) +{ + UNITY_INT16 expected[] = {5000, -4995, 5005}; + UNITY_INT16 acutalBigDelta[] = {5101, -4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT16_ARRAY_WITHIN(1, expected, acutalBigDelta, 3); + VERIFY_FAILS_END +} + +void testInt16ArrayNotWithinDeltaAndMessage(void) +{ + UNITY_INT16 expected[] = {5000, -4995, 5005}; + UNITY_INT16 acutalBigDelta[] = {5101, -4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT16_ARRAY_WITHIN_MESSAGE(1, expected, acutalBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testInt16ArrayWithinDeltaPointless(void) +{ + UNITY_INT16 expected[] = {5000, -4995, 5005}; + UNITY_INT16 acutalBigDelta[] = {5101, -4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT16_ARRAY_WITHIN(110, expected, acutalBigDelta, 0); + VERIFY_FAILS_END +} + +void testInt16ArrayWithinDeltaPointlessAndMessage(void) +{ + UNITY_INT16 expected[] = {5000, -4995, 5005}; + UNITY_INT16 acutalBigDelta[] = {5101, -4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT16_ARRAY_WITHIN_MESSAGE(110, expected, acutalBigDelta, 0, "Custom Message."); + VERIFY_FAILS_END +} + +void testInt16ArrayWithinDeltaExpectedNull(void) +{ + UNITY_INT16 acutalBigDelta[] = {5101, -4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT16_ARRAY_WITHIN(110, NULL, acutalBigDelta, 3); + VERIFY_FAILS_END +} + +void testInt16ArrayWithinDeltaExpectedNullAndMessage(void) +{ + UNITY_INT16 acutalBigDelta[] = {5101, -4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT16_ARRAY_WITHIN_MESSAGE(110, NULL, acutalBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testInt16ArrayWithinDeltaActualNull(void) +{ + UNITY_INT16 expected[] = {5000, -4995, 5005}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT16_ARRAY_WITHIN(110, expected, NULL, 3); + VERIFY_FAILS_END +} + +void testInt16ArrayWithinDeltaActualNullAndMessage(void) +{ + UNITY_INT16 expected[] = {5000, -4995, 5005}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT16_ARRAY_WITHIN_MESSAGE(110, expected, NULL, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testInt16ArrayWithinDeltaSamePointer(void) +{ + UNITY_INT16 expected[] = {5000, -4995, 5005}; + + TEST_ASSERT_INT16_ARRAY_WITHIN(110, expected, expected, 3); +} + +void testInt16ArrayWithinDeltaSamePointerAndMessage(void) +{ + UNITY_INT16 expected[] = {5000, -4995, 5005}; + + TEST_ASSERT_INT16_ARRAY_WITHIN_MESSAGE(110, expected, expected, 3, "Custom Message."); +} + +void testInt8ArrayWithinDelta(void) +{ + UNITY_INT8 expected[] = {20, -95, 55}; + UNITY_INT8 acutalSmallDelta[] = {21, -94, 55}; + UNITY_INT8 acutalBigDelta[] = {11, -86, 45}; + + TEST_ASSERT_INT8_ARRAY_WITHIN(1, expected, acutalSmallDelta, 3); + TEST_ASSERT_INT8_ARRAY_WITHIN(11, expected, acutalBigDelta, 3); +} + +void testInt8ArrayWithinDeltaAndMessage(void) +{ + UNITY_INT8 expected[] = {20, -95, 55}; + UNITY_INT8 acutalSmallDelta[] = {21, -94, 55}; + UNITY_INT8 acutalBigDelta[] = {11, -86, 45}; + + TEST_ASSERT_INT8_ARRAY_WITHIN_MESSAGE(1, expected, acutalSmallDelta, 3, "Custom Message."); + TEST_ASSERT_INT8_ARRAY_WITHIN_MESSAGE(11, expected, acutalBigDelta, 3, "Custom Message."); +} + +void testInt8ArrayNotWithinDelta(void) +{ + UNITY_INT8 expected[] = {20, -95, 55}; + UNITY_INT8 acutalBigDelta[] = {11, -86, 45}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT8_ARRAY_WITHIN(1, expected, acutalBigDelta, 3); + VERIFY_FAILS_END +} + +void testInt8ArrayNotWithinDeltaAndMessage(void) +{ + UNITY_INT8 expected[] = {20, -95, 55}; + UNITY_INT8 acutalBigDelta[] = {11, -86, 45}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT8_ARRAY_WITHIN_MESSAGE(1, expected, acutalBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testInt8ArrayWithinDeltaPointless(void) +{ + UNITY_INT8 expected[] = {20, -95, 55}; + UNITY_INT8 acutalBigDelta[] = {11, -86, 45}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT8_ARRAY_WITHIN(11, expected, acutalBigDelta, 0); + VERIFY_FAILS_END +} + +void testInt8ArrayWithinDeltaPointlessAndMessage(void) +{ + UNITY_INT8 expected[] = {20, -95, 55}; + UNITY_INT8 acutalBigDelta[] = {11, -86, 45}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT8_ARRAY_WITHIN_MESSAGE(11, expected, acutalBigDelta, 0, "Custom Message."); + VERIFY_FAILS_END +} + +void testInt8ArrayWithinDeltaExpectedNull(void) +{ + UNITY_INT8 acutalBigDelta[] = {11, -86, 45}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT8_ARRAY_WITHIN(11, NULL, acutalBigDelta, 3); + VERIFY_FAILS_END +} + +void testInt8ArrayWithinDeltaExpectedNullAndMessage(void) +{ + UNITY_INT8 acutalBigDelta[] = {11, -86, 45}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT8_ARRAY_WITHIN_MESSAGE(11, NULL, acutalBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testInt8ArrayWithinDeltaActualNull(void) +{ + UNITY_INT8 expected[] = {20, -95, 55}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT8_ARRAY_WITHIN(11, expected, NULL, 3); + VERIFY_FAILS_END +} + +void testInt8ArrayWithinDeltaActualNullAndMessage(void) +{ + UNITY_INT8 expected[] = {20, -95, 55}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT8_ARRAY_WITHIN_MESSAGE(11, expected, NULL, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testInt8ArrayWithinDeltaSamePointer(void) +{ + UNITY_INT8 expected[] = {20, -95, 55}; + + TEST_ASSERT_INT8_ARRAY_WITHIN(11, expected, expected, 3); +} + +void testInt8ArrayWithinDeltaSamePointerAndMessage(void) +{ + UNITY_INT8 expected[] = {20, -95, 55}; + + TEST_ASSERT_INT8_ARRAY_WITHIN_MESSAGE(11, expected, expected, 3, "Custom Message."); +} + +void testUInt64ArrayWithinDelta(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; + UNITY_UINT64 acutalSmallDelta[] = {12345001, 12344996, 12345005}; + UNITY_UINT64 acutalBigDelta[] = {12345101, 12344896, 12345055}; + + TEST_ASSERT_UINT64_ARRAY_WITHIN(1, expected, acutalSmallDelta, 3); + TEST_ASSERT_UINT64_ARRAY_WITHIN(110, expected, acutalBigDelta, 3); +#endif +} + +void testUInt64ArrayWithinDeltaAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; + UNITY_UINT64 acutalSmallDelta[] = {12345001, 12344996, 12345005}; + UNITY_UINT64 acutalBigDelta[] = {12345101, 12344896, 12345055}; + + TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(1, expected, acutalSmallDelta, 3, "Custom Message."); + TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(110, expected, acutalBigDelta, 3, "Custom Message."); +#endif +} + +void testUInt64ArrayNotWithinDelta(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; + UNITY_UINT64 acutalBigDelta[] = {12345101, 12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT64_ARRAY_WITHIN(1, expected, acutalBigDelta, 3); + VERIFY_FAILS_END +#endif +} + +void testUInt64ArrayNotWithinDeltaAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; + UNITY_UINT64 acutalBigDelta[] = {12345101, 12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(1, expected, acutalBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testUInt64ArrayWithinDeltaPointless(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; + UNITY_UINT64 acutalBigDelta[] = {12345101, 12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT64_ARRAY_WITHIN(110, expected, acutalBigDelta, 0); + VERIFY_FAILS_END +#endif +} + +void testUInt64ArrayWithinDeltaPointlessAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; + UNITY_UINT64 acutalBigDelta[] = {12345101, 12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(110, expected, acutalBigDelta, 0, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testUInt64ArrayWithinDeltaExpectedNull(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 acutalBigDelta[] = {12345101, 12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT64_ARRAY_WITHIN(110, NULL, acutalBigDelta, 3); + VERIFY_FAILS_END +#endif +} + +void testUInt64ArrayWithinDeltaExpectedNullAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 acutalBigDelta[] = {12345101, 12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(110, NULL, acutalBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testUInt64ArrayWithinDeltaActualNull(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT64_ARRAY_WITHIN(110, expected, NULL, 3); + VERIFY_FAILS_END +#endif +} + +void testUInt64ArrayWithinDeltaActualNullAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(110, expected, NULL, 3, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testUInt64ArrayWithinDeltaSamePointer(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; + + TEST_ASSERT_UINT64_ARRAY_WITHIN(110, expected, expected, 3); +#endif +} + +void testUInt64ArrayWithinDeltaSamePointerAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; + + TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(110, expected, expected, 3, "Custom Message."); +#endif +} + +void testUIntArrayWithinDelta(void) +{ + UNITY_UINT expected[] = {125000, 124995, 125005}; + UNITY_UINT acutalSmallDelta[] = {125001, 124996, 125005}; + UNITY_UINT acutalBigDelta[] = {125101, 124896, 125055}; + + TEST_ASSERT_UINT_ARRAY_WITHIN(1, expected, acutalSmallDelta, 3); + TEST_ASSERT_UINT_ARRAY_WITHIN(110, expected, acutalBigDelta, 3); +} + +void testUIntArrayWithinDeltaAndMessage(void) +{ + UNITY_UINT expected[] = {125000, 124995, 125005}; + UNITY_UINT acutalSmallDelta[] = {125001, 124996, 125005}; + UNITY_UINT acutalBigDelta[] = {125101, 124896, 125055}; + + TEST_ASSERT_UINT_ARRAY_WITHIN_MESSAGE(1, expected, acutalSmallDelta, 3, "Custom Message."); + TEST_ASSERT_UINT_ARRAY_WITHIN_MESSAGE(110, expected, acutalBigDelta, 3, "Custom Message."); +} + +void testUIntArrayNotWithinDelta(void) +{ + UNITY_UINT expected[] = {125000, 124995, 125005}; + UNITY_UINT acutalBigDelta[] = {125101, 124896, 125055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT_ARRAY_WITHIN(1, expected, acutalBigDelta, 3); + VERIFY_FAILS_END +} + +void testUIntArrayNotWithinDeltaAndMessage(void) +{ + UNITY_UINT expected[] = {125000, 124995, 125005}; + UNITY_UINT acutalBigDelta[] = {125101, 124896, 125055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT_ARRAY_WITHIN_MESSAGE(1, expected, acutalBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testUIntArrayWithinDeltaPointless(void) +{ + UNITY_UINT expected[] = {125000, 124995, 125005}; + UNITY_UINT acutalBigDelta[] = {125101, 124896, 125055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT_ARRAY_WITHIN(110, expected, acutalBigDelta, 0); + VERIFY_FAILS_END +} + +void testUIntArrayWithinDeltaPointlessAndMessage(void) +{ + UNITY_UINT expected[] = {125000, 124995, 125005}; + UNITY_UINT acutalBigDelta[] = {125101, 124896, 125055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT_ARRAY_WITHIN_MESSAGE(110, expected, acutalBigDelta, 0, "Custom Message."); + VERIFY_FAILS_END +} + +void testUIntArrayWithinDeltaExpectedNull(void) +{ + UNITY_UINT acutalBigDelta[] = {125101, 124896, 125055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT_ARRAY_WITHIN(110, NULL, acutalBigDelta, 3); + VERIFY_FAILS_END +} + +void testUIntArrayWithinDeltaExpectedNullAndMessage(void) +{ + UNITY_UINT acutalBigDelta[] = {125101, 124896, 125055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT_ARRAY_WITHIN_MESSAGE(110, NULL, acutalBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testUIntArrayWithinDeltaActualNull(void) +{ + UNITY_UINT expected[] = {125000, 124995, 125005}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT_ARRAY_WITHIN(110, expected, NULL, 3); + VERIFY_FAILS_END +} + +void testUIntArrayWithinDeltaActualNullAndMessage(void) +{ + UNITY_UINT expected[] = {125000, 124995, 125005}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT_ARRAY_WITHIN_MESSAGE(110, expected, NULL, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testUIntArrayWithinDeltaSamePointer(void) +{ + UNITY_UINT expected[] = {125000, 124995, 125005}; + + TEST_ASSERT_UINT_ARRAY_WITHIN(110, expected, expected, 3); +} + +void testUIntArrayWithinDeltaSamePointerAndMessage(void) +{ + UNITY_UINT expected[] = {125000, 124995, 125005}; + + TEST_ASSERT_UINT_ARRAY_WITHIN_MESSAGE(110, expected, expected, 3, "Custom Message."); +} + +void testUInt16ArrayWithinDelta(void) +{ + UNITY_UINT16 expected[] = {5000, 4995, 5005}; + UNITY_UINT16 acutalSmallDelta[] = {5001, 4996, 5005}; + UNITY_UINT16 acutalBigDelta[] = {5101, 4896, 5055}; + + TEST_ASSERT_UINT16_ARRAY_WITHIN(1, expected, acutalSmallDelta, 3); + TEST_ASSERT_UINT16_ARRAY_WITHIN(110, expected, acutalBigDelta, 3); +} + +void testUInt16ArrayWithinDeltaAndMessage(void) +{ + UNITY_UINT16 expected[] = {5000, 4995, 5005}; + UNITY_UINT16 acutalSmallDelta[] = {5001, 4996, 5005}; + UNITY_UINT16 acutalBigDelta[] = {5101, 4896, 5055}; + + TEST_ASSERT_UINT16_ARRAY_WITHIN_MESSAGE(1, expected, acutalSmallDelta, 3, "Custom Message."); + TEST_ASSERT_UINT16_ARRAY_WITHIN_MESSAGE(110, expected, acutalBigDelta, 3, "Custom Message."); +} + +void testUInt16ArrayNotWithinDelta(void) +{ + UNITY_UINT16 expected[] = {5000, 4995, 5005}; + UNITY_UINT16 acutalBigDelta[] = {5101, 4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT16_ARRAY_WITHIN(1, expected, acutalBigDelta, 3); + VERIFY_FAILS_END +} + +void testUInt16ArrayNotWithinDeltaAndMessage(void) +{ + UNITY_UINT16 expected[] = {5000, 4995, 5005}; + UNITY_UINT16 acutalBigDelta[] = {5101, 4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT16_ARRAY_WITHIN_MESSAGE(1, expected, acutalBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testUInt16ArrayWithinDeltaPointless(void) +{ + UNITY_UINT16 expected[] = {5000, 4995, 5005}; + UNITY_UINT16 acutalBigDelta[] = {5101, 4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT16_ARRAY_WITHIN(110, expected, acutalBigDelta, 0); + VERIFY_FAILS_END +} + +void testUInt16ArrayWithinDeltaPointlessAndMessage(void) +{ + UNITY_UINT16 expected[] = {5000, 4995, 5005}; + UNITY_UINT16 acutalBigDelta[] = {5101, 4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT16_ARRAY_WITHIN_MESSAGE(110, expected, acutalBigDelta, 0, "Custom Message."); + VERIFY_FAILS_END +} + +void testUInt16ArrayWithinDeltaExpectedNull(void) +{ + UNITY_UINT16 acutalBigDelta[] = {5101, 4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT16_ARRAY_WITHIN(110, NULL, acutalBigDelta, 3); + VERIFY_FAILS_END +} + +void testUInt16ArrayWithinDeltaExpectedNullAndMessage(void) +{ + UNITY_UINT16 acutalBigDelta[] = {5101, 4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT16_ARRAY_WITHIN_MESSAGE(110, NULL, acutalBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testUInt16ArrayWithinDeltaActualNull(void) +{ + UNITY_UINT16 expected[] = {5000, 4995, 5005}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT16_ARRAY_WITHIN(110, expected, NULL, 3); + VERIFY_FAILS_END +} + +void testUInt16ArrayWithinDeltaActualNullAndMessage(void) +{ + UNITY_UINT16 expected[] = {5000, 4995, 5005}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT16_ARRAY_WITHIN_MESSAGE(110, expected, NULL, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testUInt16ArrayWithinDeltaSamePointer(void) +{ + UNITY_UINT16 expected[] = {5000, 4995, 5005}; + + TEST_ASSERT_UINT16_ARRAY_WITHIN(110, expected, expected, 3); +} + +void testUInt16ArrayWithinDeltaSamePointerAndMessage(void) +{ + UNITY_UINT16 expected[] = {5000, 4995, 5005}; + + TEST_ASSERT_UINT16_ARRAY_WITHIN_MESSAGE(110, expected, expected, 3, "Custom Message."); +} + +void testUInt8ArrayWithinDelta(void) +{ + UNITY_UINT8 expected[] = {20, 95, 55}; + UNITY_UINT8 acutalSmallDelta[] = {21, 94, 55}; + UNITY_UINT8 acutalBigDelta[] = {11, 86, 45}; + + TEST_ASSERT_UINT8_ARRAY_WITHIN(1, expected, acutalSmallDelta, 3); + TEST_ASSERT_UINT8_ARRAY_WITHIN(11, expected, acutalBigDelta, 3); +} + +void testUInt8ArrayWithinDeltaAndMessage(void) +{ + UNITY_UINT8 expected[] = {20, 95, 55}; + UNITY_UINT8 acutalSmallDelta[] = {21, 94, 55}; + UNITY_UINT8 acutalBigDelta[] = {11, 86, 45}; + + TEST_ASSERT_UINT8_ARRAY_WITHIN_MESSAGE(1, expected, acutalSmallDelta, 3, "Custom Message."); + TEST_ASSERT_UINT8_ARRAY_WITHIN_MESSAGE(11, expected, acutalBigDelta, 3, "Custom Message."); +} + +void testUInt8ArrayNotWithinDelta(void) +{ + UNITY_UINT8 expected[] = {20, 95, 55}; + UNITY_UINT8 acutalBigDelta[] = {11, 86, 45}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT8_ARRAY_WITHIN(1, expected, acutalBigDelta, 3); + VERIFY_FAILS_END +} + +void testUInt8ArrayNotWithinDeltaAndMessage(void) +{ + UNITY_UINT8 expected[] = {20, 95, 55}; + UNITY_UINT8 acutalBigDelta[] = {11, 86, 45}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT8_ARRAY_WITHIN_MESSAGE(1, expected, acutalBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testUInt8ArrayWithinDeltaPointless(void) +{ + UNITY_UINT8 expected[] = {20, 95, 55}; + UNITY_UINT8 acutalBigDelta[] = {11, 86, 45}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT8_ARRAY_WITHIN(11, expected, acutalBigDelta, 0); + VERIFY_FAILS_END +} + +void testUInt8ArrayWithinDeltaPointlessAndMessage(void) +{ + UNITY_UINT8 expected[] = {20, 95, 55}; + UNITY_UINT8 acutalBigDelta[] = {11, 86, 45}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT8_ARRAY_WITHIN_MESSAGE(11, expected, acutalBigDelta, 0, "Custom Message."); + VERIFY_FAILS_END +} + +void testUInt8ArrayWithinDeltaExpectedNull(void) +{ + UNITY_UINT8 acutalBigDelta[] = {11, 86, 45}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT8_ARRAY_WITHIN(11, NULL, acutalBigDelta, 3); + VERIFY_FAILS_END +} + +void testUInt8ArrayWithinDeltaExpectedNullAndMessage(void) +{ + UNITY_UINT8 acutalBigDelta[] = {11, 86, 45}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT8_ARRAY_WITHIN_MESSAGE(11, NULL, acutalBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testUInt8ArrayWithinDeltaActualNull(void) +{ + UNITY_UINT8 expected[] = {20, 95, 55}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT8_ARRAY_WITHIN(11, expected, NULL, 3); + VERIFY_FAILS_END +} + +void testUInt8ArrayWithinDeltaActualNullAndMessage(void) +{ + UNITY_UINT8 expected[] = {20, 95, 55}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT8_ARRAY_WITHIN_MESSAGE(11, expected, NULL, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testUInt8ArrayWithinDeltaSamePointer(void) +{ + UNITY_UINT8 expected[] = {20, 95, 55}; + + TEST_ASSERT_UINT8_ARRAY_WITHIN(11, expected, expected, 3); +} + +void testUInt8ArrayWithinDeltaSamePointerAndMessage(void) +{ + UNITY_UINT8 expected[] = {20, 95, 55}; + + TEST_ASSERT_UINT8_ARRAY_WITHIN_MESSAGE(11, expected, expected, 3, "Custom Message."); +} + +void testHEX64ArrayWithinDelta(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; + UNITY_UINT64 acutalSmallDelta[] = {0xABCD1235, 0xABCD1121, 0xABCD1277}; + UNITY_UINT64 acutalBigDelta[] = {0xABCD1267, 0xABCD1188, 0xABCD12AC}; + + TEST_ASSERT_HEX64_ARRAY_WITHIN(1, expected, acutalSmallDelta, 3); + TEST_ASSERT_HEX64_ARRAY_WITHIN(110, expected, acutalBigDelta, 3); +#endif +} + +void testHEX64ArrayWithinDeltaAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; + UNITY_UINT64 acutalSmallDelta[] = {0xABCD1235, 0xABCD1121, 0xABCD1277}; + UNITY_UINT64 acutalBigDelta[] = {0xABCD1267, 0xABCD1188, 0xABCD12AC}; + + TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(1, expected, acutalSmallDelta, 3, "Custom Message."); + TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(110, expected, acutalBigDelta, 3, "Custom Message."); +#endif +} + +void testHEX64ArrayNotWithinDelta(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; + UNITY_UINT64 acutalBigDelta[] = {0xABCD1267, 0xABCD1188, 0xABCD12AC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX64_ARRAY_WITHIN(1, expected, acutalBigDelta, 3); + VERIFY_FAILS_END +#endif +} + +void testHEX64ArrayNotWithinDeltaAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; + UNITY_UINT64 acutalBigDelta[] = {0xABCD1267, 0xABCD1188, 0xABCD12AC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(1, expected, acutalBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testHEX64ArrayWithinDeltaPointless(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; + UNITY_UINT64 acutalBigDelta[] = {0xABCD1267, 0xABCD1188, 0xABCD12AC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX64_ARRAY_WITHIN(110, expected, acutalBigDelta, 0); + VERIFY_FAILS_END +#endif +} + +void testHEX64ArrayWithinDeltaPointlessAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; + UNITY_UINT64 acutalBigDelta[] = {0xABCD1267, 0xABCD1188, 0xABCD12AC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(110, expected, acutalBigDelta, 0, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testHEX64ArrayWithinDeltaExpectedNull(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 acutalBigDelta[] = {0xABCD1267, 0xABCD1188, 0xABCD12AC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX64_ARRAY_WITHIN(110, NULL, acutalBigDelta, 3); + VERIFY_FAILS_END +#endif +} + +void testHEX64ArrayWithinDeltaExpectedNullAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 acutalBigDelta[] = {0xABCD1267, 0xABCD1188, 0xABCD12AC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(110, NULL, acutalBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testHEX64ArrayWithinDeltaActualNull(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX64_ARRAY_WITHIN(110, expected, NULL, 3); + VERIFY_FAILS_END +#endif +} + +void testHEX64ArrayWithinDeltaActualNullAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(110, expected, NULL, 3, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testHEX64ArrayWithinDeltaSamePointer(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; + + TEST_ASSERT_HEX64_ARRAY_WITHIN(110, expected, expected, 3); +#endif +} + +void testHEX64ArrayWithinDeltaSamePointerAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {0xABCD11234, 0xABCD1122, 0xABCD1277}; + + TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(110, expected, expected, 3, "Custom Message."); +#endif +} + +void testHEX32ArrayWithinDelta(void) +{ + UNITY_UINT expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; + UNITY_UINT acutalSmallDelta[] = {0xABCD1235, 0xABCD1121, 0xABCD1277}; + UNITY_UINT acutalBigDelta[] = {0xABCD1267, 0xABCD1188, 0xABCD12AC}; + + TEST_ASSERT_HEX32_ARRAY_WITHIN(1, expected, acutalSmallDelta, 3); + TEST_ASSERT_HEX32_ARRAY_WITHIN(110, expected, acutalBigDelta, 3); +} + +void testHEX32ArrayWithinDeltaAndMessage(void) +{ + UNITY_UINT expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; + UNITY_UINT acutalSmallDelta[] = {0xABCD1235, 0xABCD1121, 0xABCD1277}; + UNITY_UINT acutalBigDelta[] = {0xABCD1267, 0xABCD1188, 0xABCD12AC}; + + TEST_ASSERT_HEX32_ARRAY_WITHIN_MESSAGE(1, expected, acutalSmallDelta, 3, "Custom Message."); + TEST_ASSERT_HEX32_ARRAY_WITHIN_MESSAGE(110, expected, acutalBigDelta, 3, "Custom Message."); +} + +void testHEX32ArrayNotWithinDelta(void) +{ + UNITY_UINT expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; + UNITY_UINT acutalBigDelta[] = {0xABCD1267, 0xABCD1188, 0xABCD12AC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX32_ARRAY_WITHIN(1, expected, acutalBigDelta, 3); + VERIFY_FAILS_END +} + +void testHEX32ArrayNotWithinDeltaAndMessage(void) +{ + UNITY_UINT expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; + UNITY_UINT acutalBigDelta[] = {0xABCD1267, 0xABCD1188, 0xABCD12AC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX32_ARRAY_WITHIN_MESSAGE(1, expected, acutalBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testHEX32ArrayWithinDeltaPointless(void) +{ + UNITY_UINT expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; + UNITY_UINT acutalBigDelta[] = {0xABCD1267, 0xABCD1188, 0xABCD12AC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX32_ARRAY_WITHIN(110, expected, acutalBigDelta, 0); + VERIFY_FAILS_END +} + +void testHEX32ArrayWithinDeltaPointlessAndMessage(void) +{ + UNITY_UINT expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; + UNITY_UINT acutalBigDelta[] = {0xABCD1267, 0xABCD1188, 0xABCD12AC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX32_ARRAY_WITHIN_MESSAGE(110, expected, acutalBigDelta, 0, "Custom Message."); + VERIFY_FAILS_END +} + +void testHEX32ArrayWithinDeltaExpectedNull(void) +{ + UNITY_UINT acutalBigDelta[] = {0xABCD1267, 0xABCD1188, 0xABCD12AC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX32_ARRAY_WITHIN(110, NULL, acutalBigDelta, 3); + VERIFY_FAILS_END +} + +void testHEX32ArrayWithinDeltaExpectedNullAndMessage(void) +{ + UNITY_UINT acutalBigDelta[] = {0xABCD1267, 0xABCD1188, 0xABCD12AC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX32_ARRAY_WITHIN_MESSAGE(110, NULL, acutalBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testHEX32ArrayWithinDeltaActualNull(void) +{ + UNITY_UINT expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX32_ARRAY_WITHIN(110, expected, NULL, 3); + VERIFY_FAILS_END +} + +void testHEX32ArrayWithinDeltaActualNullAndMessage(void) +{ + UNITY_UINT expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX32_ARRAY_WITHIN_MESSAGE(110, expected, NULL, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testHEX32ArrayWithinDeltaSamePointer(void) +{ + UNITY_UINT expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; + + TEST_ASSERT_HEX32_ARRAY_WITHIN(110, expected, expected, 3); +} + +void testHEX32ArrayWithinDeltaSamePointerAndMessage(void) +{ + UNITY_UINT expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; + + TEST_ASSERT_HEX32_ARRAY_WITHIN_MESSAGE(110, expected, expected, 3, "Custom Message."); +} + + +void testHEX16ArrayWithinDelta(void) +{ + UNITY_UINT16 expected[] = {0x1234, 0x1122, 0x1277}; + UNITY_UINT16 acutalSmallDelta[] = {0x1235, 0x1121, 0x1277}; + UNITY_UINT16 acutalBigDelta[] = {0x1267, 0x1188, 0x12AC}; + + TEST_ASSERT_HEX16_ARRAY_WITHIN(1, expected, acutalSmallDelta, 3); + TEST_ASSERT_HEX16_ARRAY_WITHIN(110, expected, acutalBigDelta, 3); +} + +void testHEX16ArrayWithinDeltaAndMessage(void) +{ + UNITY_UINT16 expected[] = {0x1234, 0x1122, 0x1277}; + UNITY_UINT16 acutalSmallDelta[] = {0x1235, 0x1121, 0x1277}; + UNITY_UINT16 acutalBigDelta[] = {0x1267, 0x1188, 0x12AC}; + + TEST_ASSERT_HEX16_ARRAY_WITHIN_MESSAGE(1, expected, acutalSmallDelta, 3, "Custom Message."); + TEST_ASSERT_HEX16_ARRAY_WITHIN_MESSAGE(110, expected, acutalBigDelta, 3, "Custom Message."); +} + +void testHEX16ArrayNotWithinDelta(void) +{ + UNITY_UINT16 expected[] = {0x1234, 0x1122, 0x1277}; + UNITY_UINT16 acutalBigDelta[] = {0x1267, 0x1188, 0x12AC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX16_ARRAY_WITHIN(1, expected, acutalBigDelta, 3); + VERIFY_FAILS_END +} + +void testHEX16ArrayNotWithinDeltaAndMessage(void) +{ + UNITY_UINT16 expected[] = {0x1234, 0x1122, 0x1277}; + UNITY_UINT16 acutalBigDelta[] = {0x1267, 0x1188, 0x12AC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX16_ARRAY_WITHIN_MESSAGE(1, expected, acutalBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testHEX16ArrayWithinDeltaPointless(void) +{ + UNITY_UINT16 expected[] = {0x1234, 0x1122, 0x1277}; + UNITY_UINT16 acutalBigDelta[] = {0x1267, 0x1188, 0x12AC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX16_ARRAY_WITHIN(110, expected, acutalBigDelta, 0); + VERIFY_FAILS_END +} + +void testHEX16ArrayWithinDeltaPointlessAndMessage(void) +{ + UNITY_UINT16 expected[] = {0x1234, 0x1122, 0x1277}; + UNITY_UINT16 acutalBigDelta[] = {0x1267, 0x1188, 0x12AC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX16_ARRAY_WITHIN_MESSAGE(110, expected, acutalBigDelta, 0, "Custom Message."); + VERIFY_FAILS_END +} + +void testHEX16ArrayWithinDeltaExpectedNull(void) +{ + UNITY_UINT16 acutalBigDelta[] = {0x1267, 0x1188, 0x12AC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX16_ARRAY_WITHIN(110, NULL, acutalBigDelta, 3); + VERIFY_FAILS_END +} + +void testHEX16ArrayWithinDeltaExpectedNullAndMessage(void) +{ + UNITY_UINT16 acutalBigDelta[] = {0x1267, 0x1188, 0x12AC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX16_ARRAY_WITHIN_MESSAGE(110, NULL, acutalBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testHEX16ArrayWithinDeltaActualNull(void) +{ + UNITY_UINT16 expected[] = {0x1234, 0x1122, 0x1277}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX16_ARRAY_WITHIN(110, expected, NULL, 3); + VERIFY_FAILS_END +} + +void testHEX16ArrayWithinDeltaActualNullAndMessage(void) +{ + UNITY_UINT16 expected[] = {0x1234, 0x1122, 0x1277}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX16_ARRAY_WITHIN_MESSAGE(110, expected, NULL, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testHEX16ArrayWithinDeltaSamePointer(void) +{ + UNITY_UINT16 expected[] = {0x1234, 0x1122, 0x1277}; + + TEST_ASSERT_HEX16_ARRAY_WITHIN(110, expected, expected, 3); +} + +void testHEX16ArrayWithinDeltaSamePointerAndMessage(void) +{ + UNITY_UINT16 expected[] = {0x1234, 0x1122, 0x1277}; + + TEST_ASSERT_HEX16_ARRAY_WITHIN_MESSAGE(110, expected, expected, 3, "Custom Message."); +} + +void testHEX8ArrayWithinDelta(void) +{ + UNITY_UINT8 expected[] = {0x34, 0x22, 0x77}; + UNITY_UINT8 acutalSmallDelta[] = {0x35, 0x21, 0x77}; + UNITY_UINT8 acutalBigDelta[] = {0x47, 0x48, 0x4C}; + + TEST_ASSERT_HEX8_ARRAY_WITHIN(1, expected, acutalSmallDelta, 3); + TEST_ASSERT_HEX8_ARRAY_WITHIN(60, expected, acutalBigDelta, 3); +} + +void testHEX8ArrayWithinDeltaAndMessage(void) +{ + UNITY_UINT8 expected[] = {0x34, 0x22, 0x77}; + UNITY_UINT8 acutalSmallDelta[] = {0x35, 0x21, 0x77}; + UNITY_UINT8 acutalBigDelta[] = {0x47, 0x48, 0x4C}; + + TEST_ASSERT_HEX8_ARRAY_WITHIN_MESSAGE(1, expected, acutalSmallDelta, 3, "Custom Message."); + TEST_ASSERT_HEX8_ARRAY_WITHIN_MESSAGE(60, expected, acutalBigDelta, 3, "Custom Message."); +} + +void testHEX8ArrayNotWithinDelta(void) +{ + UNITY_UINT8 expected[] = {0x34, 0x22, 0x77}; + UNITY_UINT8 acutalBigDelta[] = {0x67, 0x88, 0xAC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX8_ARRAY_WITHIN(1, expected, acutalBigDelta, 3); + VERIFY_FAILS_END +} + +void testHEX8ArrayNotWithinDeltaAndMessage(void) +{ + UNITY_UINT8 expected[] = {0x34, 0x22, 0x77}; + UNITY_UINT8 acutalBigDelta[] = {0x67, 0x88, 0xAC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX8_ARRAY_WITHIN_MESSAGE(1, expected, acutalBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testHEX8ArrayWithinDeltaPointless(void) +{ + UNITY_UINT8 expected[] = {0x34, 0x22, 0x77}; + UNITY_UINT8 acutalBigDelta[] = {0x67, 0x88, 0xAC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX8_ARRAY_WITHIN(60, expected, acutalBigDelta, 0); + VERIFY_FAILS_END +} + +void testHEX8ArrayWithinDeltaPointlessAndMessage(void) +{ + UNITY_UINT8 expected[] = {0x34, 0x22, 0x77}; + UNITY_UINT8 acutalBigDelta[] = {0x67, 0x88, 0xAC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX8_ARRAY_WITHIN_MESSAGE(60, expected, acutalBigDelta, 0, "Custom Message."); + VERIFY_FAILS_END +} + +void testHEX8ArrayWithinDeltaExpectedNull(void) +{ + UNITY_UINT8 acutalBigDelta[] = {0x67, 0x88, 0xAC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX8_ARRAY_WITHIN(60, NULL, acutalBigDelta, 3); + VERIFY_FAILS_END +} + +void testHEX8ArrayWithinDeltaExpectedNullAndMessage(void) +{ + UNITY_UINT8 acutalBigDelta[] = {0x67, 0x88, 0xAC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX8_ARRAY_WITHIN_MESSAGE(60, NULL, acutalBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testHEX8ArrayWithinDeltaActualNull(void) +{ + UNITY_UINT8 expected[] = {0x34, 0x22, 0x77}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX8_ARRAY_WITHIN(60, expected, NULL, 3); + VERIFY_FAILS_END +} + +void testHEX8ArrayWithinDeltaActualNullAndMessage(void) +{ + UNITY_UINT8 expected[] = {0x34, 0x22, 0x77}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX8_ARRAY_WITHIN_MESSAGE(60, expected, NULL, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testHEX8ArrayWithinDeltaSamePointer(void) +{ + UNITY_UINT8 expected[] = {0x34, 0x22, 0x77}; + + TEST_ASSERT_HEX8_ARRAY_WITHIN(60, expected, expected, 3); +} + +void testHEX8ArrayWithinDeltaSamePointerAndMessage(void) +{ + UNITY_UINT8 expected[] = {0x34, 0x22, 0x77}; + + TEST_ASSERT_HEX8_ARRAY_WITHIN_MESSAGE(60, expected, expected, 3, "Custom Message."); +} + +//----------------- + +void testGreaterThan(void) +{ + UNITY_INT v0, v1; + UNITY_INT *p0, *p1; + + v0 = 0; + v1 = 1; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_GREATER_THAN(v0, v1); + TEST_ASSERT_GREATER_THAN(*p0, v1); + TEST_ASSERT_GREATER_THAN(v0, *p1); + TEST_ASSERT_GREATER_THAN(*p0, *p1); +} + +void testNotGreaterThan(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_THAN(0, -1); + VERIFY_FAILS_END +} + +void testGreaterThanINT(void) +{ + UNITY_INT v0, v1; + UNITY_INT *p0, *p1; + + v0 = 302; + v1 = 3334; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_GREATER_THAN_INT(v0, v1); + TEST_ASSERT_GREATER_THAN_INT(*p0, v1); + TEST_ASSERT_GREATER_THAN_INT(v0, *p1); + TEST_ASSERT_GREATER_THAN_INT(*p0, *p1); +} + +void testNotGreaterThanINT(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_THAN_INT(3334, 302); + VERIFY_FAILS_END +} + +void testGreaterThanINT8(void) +{ + UNITY_INT8 v0, v1; + UNITY_INT8 *p0, *p1; + + v0 = -128; + v1 = 127; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_GREATER_THAN_INT8(v0, v1); + TEST_ASSERT_GREATER_THAN_INT8(*p0, v1); + TEST_ASSERT_GREATER_THAN_INT8(v0, *p1); + TEST_ASSERT_GREATER_THAN_INT8(*p0, *p1); +} + +void testNotGreaterThanINT8(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_THAN_INT8(127, -128); + VERIFY_FAILS_END +} + +void testGreaterThanINT16(void) +{ + UNITY_INT16 v0, v1; + UNITY_INT16 *p0, *p1; + + v0 = -32768; + v1 = 32767; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_GREATER_THAN_INT16(v0, v1); + TEST_ASSERT_GREATER_THAN_INT16(*p0, v1); + TEST_ASSERT_GREATER_THAN_INT16(v0, *p1); + TEST_ASSERT_GREATER_THAN_INT16(*p0, *p1); +} + +void testNotGreaterThanINT16(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_THAN_INT16(32768, -32768); + VERIFY_FAILS_END +} + +void testGreaterThanINT32(void) +{ + UNITY_INT32 v0, v1; + UNITY_INT32 *p0, *p1; + + v0 = -214783648; + v1 = 214783647; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_GREATER_THAN_INT32(v0, v1); + TEST_ASSERT_GREATER_THAN_INT32(*p0, v1); + TEST_ASSERT_GREATER_THAN_INT32(v0, *p1); + TEST_ASSERT_GREATER_THAN_INT32(*p0, *p1); +} + +void testNotGreaterThanINT32(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_THAN_INT32(214783647, -214783648); + VERIFY_FAILS_END +} + +void testGreaterThanUINT(void) +{ + UNITY_UINT v0, v1; + UNITY_UINT *p0, *p1; + + v0 = 0; + v1 = 1; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_GREATER_THAN_UINT(v0, v1); + TEST_ASSERT_GREATER_THAN_UINT(*p0, v1); + TEST_ASSERT_GREATER_THAN_UINT(v0, *p1); + TEST_ASSERT_GREATER_THAN_UINT(*p0, *p1); +} + +void testNotGreaterThanUINT(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_THAN_UINT(1, 0); + VERIFY_FAILS_END +} + +void testGreaterThanUINT8(void) +{ + UNITY_UINT8 v0, v1; + UNITY_UINT8 *p0, *p1; + + v0 = 0; + v1 = 255; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_GREATER_THAN_UINT8(v0, v1); + TEST_ASSERT_GREATER_THAN_UINT8(*p0, v1); + TEST_ASSERT_GREATER_THAN_UINT8(v0, *p1); + TEST_ASSERT_GREATER_THAN_UINT8(*p0, *p1); +} + +void testNotGreaterThanUINT8(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_THAN_UINT8(255, 0); + VERIFY_FAILS_END +} + +void testGreaterThanUINT16(void) +{ + UNITY_UINT16 v0, v1; + UNITY_UINT16 *p0, *p1; + + v0 = 0; + v1 = 65535; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_GREATER_THAN_UINT16(v0, v1); + TEST_ASSERT_GREATER_THAN_UINT16(*p0, v1); + TEST_ASSERT_GREATER_THAN_UINT16(v0, *p1); + TEST_ASSERT_GREATER_THAN_UINT16(*p0, *p1); +} + +void testNotGreaterThanUINT16(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_THAN_UINT16(65535, 0); + VERIFY_FAILS_END +} + +void testGreaterThanUINT32(void) +{ + UNITY_UINT32 v0, v1; + UNITY_UINT32 *p0, *p1; + + v0 = 0; + v1 = 4294967295; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_GREATER_THAN_UINT32(v0, v1); + TEST_ASSERT_GREATER_THAN_UINT32(*p0, v1); + TEST_ASSERT_GREATER_THAN_UINT32(v0, *p1); + TEST_ASSERT_GREATER_THAN_UINT32(*p0, *p1); +} + +void testNotGreaterThanUINT32(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_THAN_UINT32(4294967295, 0); + VERIFY_FAILS_END +} + +void testGreaterThanHEX8(void) +{ + UNITY_UINT8 v0, v1; + UNITY_UINT8 *p0, *p1; + + v0 = 0x00; + v1 = 0xFF; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_GREATER_THAN_HEX8(v0, v1); + TEST_ASSERT_GREATER_THAN_HEX8(*p0, v1); + TEST_ASSERT_GREATER_THAN_HEX8(v0, *p1); + TEST_ASSERT_GREATER_THAN_HEX8(*p0, *p1); +} + +void testNotGreaterThanHEX8(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_THAN_HEX8(0xFF, 0x00); + VERIFY_FAILS_END +} + +void testGreaterThanHEX16(void) +{ + UNITY_UINT16 v0, v1; + UNITY_UINT16 *p0, *p1; + + v0 = 0x0000; + v1 = 0xFFFF; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_GREATER_THAN_HEX16(v0, v1); + TEST_ASSERT_GREATER_THAN_HEX16(*p0, v1); + TEST_ASSERT_GREATER_THAN_HEX16(v0, *p1); + TEST_ASSERT_GREATER_THAN_HEX16(*p0, *p1); +} + +void testNotGreaterThanHEX16(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_THAN_HEX16(0xFFFF, 0x00); + VERIFY_FAILS_END +} + +void testGreaterThanHEX32(void) +{ + UNITY_UINT32 v0, v1; + UNITY_UINT32 *p0, *p1; + + v0 = 0x00000000; + v1 = 0xFFFFFFFF; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_GREATER_THAN_HEX32(v0, v1); + TEST_ASSERT_GREATER_THAN_HEX32(*p0, v1); + TEST_ASSERT_GREATER_THAN_HEX32(v0, *p1); + TEST_ASSERT_GREATER_THAN_HEX32(*p0, *p1); +} + +void testNotGreaterThanHEX32(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_THAN_HEX32(0xFFFFFFFF, 0x00); + VERIFY_FAILS_END +} + +void testGreaterOrEqual(void) +{ + UNITY_INT v0, v1, v2; + UNITY_INT *p0, *p1, *p2; + + v0 = 0; + v1 = 1; + v2 = 0; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_GREATER_OR_EQUAL(v0, v1); + TEST_ASSERT_GREATER_OR_EQUAL(*p0, v1); + TEST_ASSERT_GREATER_OR_EQUAL(v0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL(*p0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL(v0, v2); + TEST_ASSERT_GREATER_OR_EQUAL(*p0, v2); + TEST_ASSERT_GREATER_OR_EQUAL(v0, *p2); + TEST_ASSERT_GREATER_OR_EQUAL(*p0, *p2); +} + +void testNotGreaterOrEqual(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_OR_EQUAL(0, -1); + VERIFY_FAILS_END +} + +void testGreaterOrEqualINT(void) +{ + UNITY_INT v0, v1, v2; + UNITY_INT *p0, *p1, *p2; + + v0 = 302; + v1 = 3334; + v2 = 302; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_GREATER_OR_EQUAL_INT(v0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_INT(*p0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_INT(v0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_INT(*p0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_INT(v0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_INT(*p0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_INT(v0, *p2); + TEST_ASSERT_GREATER_OR_EQUAL_INT(*p0, *p2); +} + +void testNotGreaterOrEqualINT(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_OR_EQUAL_INT(3334, 302); + VERIFY_FAILS_END +} + +void testGreaterOrEqualINT8(void) +{ + UNITY_INT8 v0, v1, v2; + UNITY_INT8 *p0, *p1, *p2; + + v0 = -128; + v1 = 127; + v2 = -128; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_GREATER_OR_EQUAL_INT8(v0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_INT8(*p0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_INT8(v0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_INT8(*p0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_INT8(v0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_INT8(*p0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_INT8(v0, *p2); + TEST_ASSERT_GREATER_OR_EQUAL_INT8(*p0, *p2); +} + +void testNotGreaterOrEqualINT8(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_OR_EQUAL_INT8(127, -128); + VERIFY_FAILS_END +} + +void testGreaterOrEqualINT16(void) +{ + UNITY_INT16 v0, v1, v2; + UNITY_INT16 *p0, *p1, *p2; + + v0 = -32768; + v1 = 32767; + v2 = -32768; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_GREATER_OR_EQUAL_INT16(v0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_INT16(*p0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_INT16(v0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_INT16(*p0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_INT16(v0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_INT16(*p0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_INT16(v0, *p2); + TEST_ASSERT_GREATER_OR_EQUAL_INT16(*p0, *p2); +} + +void testNotGreaterOrEqualINT16(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_OR_EQUAL_INT16(32767, -32768); + VERIFY_FAILS_END +} + +void testGreaterOrEqualINT32(void) +{ + UNITY_INT32 v0, v1, v2; + UNITY_INT32 *p0, *p1, *p2; + + v0 = -214783648; + v1 = 214783647; + v2 = -214783648; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_GREATER_OR_EQUAL_INT32(v0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_INT32(*p0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_INT32(v0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_INT32(*p0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_INT32(v0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_INT32(*p0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_INT32(v0, *p2); + TEST_ASSERT_GREATER_OR_EQUAL_INT32(*p0, *p2); +} + +void testNotGreaterOrEqualINT32(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_OR_EQUAL_INT32(214783647, -214783648); + VERIFY_FAILS_END +} + +void testGreaterOrEqualUINT(void) +{ + UNITY_UINT v0, v1, v2; + UNITY_UINT *p0, *p1, *p2; + + v0 = 0; + v1 = 1; + v2 = 0; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_GREATER_OR_EQUAL_UINT(v0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_UINT(*p0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_UINT(v0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_UINT(*p0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_UINT(v0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_UINT(*p0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_UINT(v0, *p2); + TEST_ASSERT_GREATER_OR_EQUAL_UINT(*p0, *p2); +} + +void testNotGreaterOrEqualUINT(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_OR_EQUAL_UINT(1, 0); + VERIFY_FAILS_END +} + +void testGreaterOrEqualUINT8(void) +{ + UNITY_UINT8 v0, v1, v2; + UNITY_UINT8 *p0, *p1, *p2; + + v0 = 0; + v1 = 255; + v2 = 0; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_GREATER_OR_EQUAL_UINT8(v0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_UINT8(*p0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_UINT8(v0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_UINT8(*p0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_UINT8(v0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_UINT8(*p0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_UINT8(v0, *p2); + TEST_ASSERT_GREATER_OR_EQUAL_UINT8(*p0, *p2); +} + +void testNotGreaterOrEqualUINT8(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_OR_EQUAL_UINT8(255, 0); + VERIFY_FAILS_END +} + +void testGreaterOrEqualUINT16(void) +{ + UNITY_UINT16 v0, v1, v2; + UNITY_UINT16 *p0, *p1, *p2; + + v0 = 0; + v1 = 65535; + v2 = 0; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_GREATER_OR_EQUAL_UINT16(v0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_UINT16(*p0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_UINT16(v0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_UINT16(*p0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_UINT16(v0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_UINT16(*p0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_UINT16(v0, *p2); + TEST_ASSERT_GREATER_OR_EQUAL_UINT16(*p0, *p2); +} + +void testNotGreaterOrEqualUINT16(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_OR_EQUAL_UINT16(65535, 0); + VERIFY_FAILS_END +} + +void testGreaterOrEqualUINT32(void) +{ + UNITY_UINT32 v0, v1, v2; + UNITY_UINT32 *p0, *p1, *p2; + + v0 = 0; + v1 = 4294967295; + v2 = 0; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_GREATER_OR_EQUAL_UINT32(v0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_UINT32(*p0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_UINT32(v0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_UINT32(*p0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_UINT32(v0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_UINT32(*p0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_UINT32(v0, *p2); + TEST_ASSERT_GREATER_OR_EQUAL_UINT32(*p0, *p2); +} + +void testNotGreaterOrEqualUINT32(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_OR_EQUAL_UINT32(4294967295, 0); + VERIFY_FAILS_END +} + +void testGreaterOrEqualHEX8(void) +{ + UNITY_UINT8 v0, v1, v2; + UNITY_UINT8 *p0, *p1, *p2; + + v0 = 0x00; + v1 = 0xFF; + v2 = 0x00; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_GREATER_OR_EQUAL_HEX8(v0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_HEX8(*p0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_HEX8(v0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_HEX8(*p0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_HEX8(v0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_HEX8(*p0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_HEX8(v0, *p2); + TEST_ASSERT_GREATER_OR_EQUAL_HEX8(*p0, *p2); +} + +void testNotGreaterOrEqualHEX8(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_OR_EQUAL_HEX8(0xFF, 0x00); + VERIFY_FAILS_END +} + +void testGreaterOrEqualHEX16(void) +{ + UNITY_UINT16 v0, v1, v2; + UNITY_UINT16 *p0, *p1, *p2; + + v0 = 0x0000; + v1 = 0xFFFF; + v2 = 0x0000; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_GREATER_OR_EQUAL_HEX16(v0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_HEX16(*p0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_HEX16(v0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_HEX16(*p0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_HEX16(v0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_HEX16(*p0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_HEX16(v0, *p2); + TEST_ASSERT_GREATER_OR_EQUAL_HEX16(*p0, *p2); +} + +void testNotGreaterOrEqualHEX16(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_OR_EQUAL_HEX16(0xFFFF, 0x00); + VERIFY_FAILS_END +} + +void testGreaterOrEqualHEX32(void) +{ + UNITY_UINT32 v0, v1, v2; + UNITY_UINT32 *p0, *p1, *p2; + + v0 = 0x00000000; + v1 = 0xFFFFFFFF; + v2 = 0x00000000; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_GREATER_OR_EQUAL_HEX32(v0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_HEX32(*p0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_HEX32(v0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_HEX32(*p0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_HEX32(v0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_HEX32(*p0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_HEX32(v0, *p2); + TEST_ASSERT_GREATER_OR_EQUAL_HEX32(*p0, *p2); +} + +void testNotGreaterOrEqualHEX32(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_OR_EQUAL_HEX32(0xFFFFFFFF, 0x00); + VERIFY_FAILS_END +} + +//----------------- + + +void testLessThan(void) +{ + UNITY_INT v0, v1; + UNITY_INT *p0, *p1; + + v0 = 0; + v1 = -1; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_LESS_THAN(v0, v1); + TEST_ASSERT_LESS_THAN(*p0, v1); + TEST_ASSERT_LESS_THAN(v0, *p1); + TEST_ASSERT_LESS_THAN(*p0, *p1); +} + +void testNotLessThan(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_THAN(0, 1); + VERIFY_FAILS_END +} + +void testLessThanINT(void) +{ + UNITY_INT v0, v1; + UNITY_INT *p0, *p1; + + v0 = 3334; + v1 = 302; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_LESS_THAN_INT(v0, v1); + TEST_ASSERT_LESS_THAN_INT(*p0, v1); + TEST_ASSERT_LESS_THAN_INT(v0, *p1); + TEST_ASSERT_LESS_THAN_INT(*p0, *p1); +} + +void testNotLessThanINT(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_THAN_INT(302, 3334); + VERIFY_FAILS_END +} + +void testLessThanINT8(void) +{ + UNITY_INT8 v0, v1; + UNITY_INT8 *p0, *p1; + + v0 = 127; + v1 = -128; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_LESS_THAN_INT8(v0, v1); + TEST_ASSERT_LESS_THAN_INT8(*p0, v1); + TEST_ASSERT_LESS_THAN_INT8(v0, *p1); + TEST_ASSERT_LESS_THAN_INT8(*p0, *p1); +} + +void testNotLessThanINT8(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_THAN_INT8(-128, 127); + VERIFY_FAILS_END +} + +void testLessThanINT16(void) +{ + UNITY_INT16 v0, v1; + UNITY_INT16 *p0, *p1; + + v0 = 32767; + v1 = -32768; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_LESS_THAN_INT16(v0, v1); + TEST_ASSERT_LESS_THAN_INT16(*p0, v1); + TEST_ASSERT_LESS_THAN_INT16(v0, *p1); + TEST_ASSERT_LESS_THAN_INT16(*p0, *p1); +} + +void testNotLessThanINT16(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_THAN_INT16(-32768, 32767); + VERIFY_FAILS_END +} + +void testLessThanINT32(void) +{ + UNITY_INT32 v0, v1; + UNITY_INT32 *p0, *p1; + + v0 = 214783647; + v1 = -214783648; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_LESS_THAN_INT32(v0, v1); + TEST_ASSERT_LESS_THAN_INT32(*p0, v1); + TEST_ASSERT_LESS_THAN_INT32(v0, *p1); + TEST_ASSERT_LESS_THAN_INT32(*p0, *p1); +} + +void testNotLessThanINT32(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_THAN_INT32(-214783648, 214783647); + VERIFY_FAILS_END +} + +void testLessThanUINT(void) +{ + UNITY_UINT v0, v1; + UNITY_UINT *p0, *p1; + + v0 = 1; + v1 = 0; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_LESS_THAN_UINT(v0, v1); + TEST_ASSERT_LESS_THAN_UINT(*p0, v1); + TEST_ASSERT_LESS_THAN_UINT(v0, *p1); + TEST_ASSERT_LESS_THAN_UINT(*p0, *p1); +} + +void testNotLessThanUINT(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_THAN_UINT(0, 1); + VERIFY_FAILS_END +} + +void testLessThanUINT8(void) +{ + UNITY_UINT8 v0, v1; + UNITY_UINT8 *p0, *p1; + + v0 = 255; + v1 = 0; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_LESS_THAN_UINT8(v0, v1); + TEST_ASSERT_LESS_THAN_UINT8(*p0, v1); + TEST_ASSERT_LESS_THAN_UINT8(v0, *p1); + TEST_ASSERT_LESS_THAN_UINT8(*p0, *p1); +} + +void testNotLessThanUINT8(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_THAN_UINT8(0, 255); + VERIFY_FAILS_END +} + +void testLessThanUINT16(void) +{ + UNITY_UINT16 v0, v1; + UNITY_UINT16 *p0, *p1; + + v0 = 65535; + v1 = 0; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_LESS_THAN_UINT16(v0, v1); + TEST_ASSERT_LESS_THAN_UINT16(*p0, v1); + TEST_ASSERT_LESS_THAN_UINT16(v0, *p1); + TEST_ASSERT_LESS_THAN_UINT16(*p0, *p1); +} + +void testNotLessThanUINT16(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_THAN_UINT16(0, 65535); + VERIFY_FAILS_END +} + +void testLessThanUINT32(void) +{ + UNITY_UINT32 v0, v1; + UNITY_UINT32 *p0, *p1; + + v0 = 4294967295; + v1 = 0; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_LESS_THAN_UINT32(v0, v1); + TEST_ASSERT_LESS_THAN_UINT32(*p0, v1); + TEST_ASSERT_LESS_THAN_UINT32(v0, *p1); + TEST_ASSERT_LESS_THAN_UINT32(*p0, *p1); +} + +void testNotLessThanUINT32(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_THAN_UINT32(0, 4294967295); + VERIFY_FAILS_END +} + +void testLessThanHEX8(void) +{ + UNITY_UINT8 v0, v1; + UNITY_UINT8 *p0, *p1; + + v0 = 0xFF; + v1 = 0x00; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_LESS_THAN_HEX8(v0, v1); + TEST_ASSERT_LESS_THAN_HEX8(*p0, v1); + TEST_ASSERT_LESS_THAN_HEX8(v0, *p1); + TEST_ASSERT_LESS_THAN_HEX8(*p0, *p1); +} + +void testNotLessThanHEX8(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_THAN_HEX8(0x00, 0xFF); + VERIFY_FAILS_END +} + +void testLessThanHEX16(void) +{ + UNITY_UINT16 v0, v1; + UNITY_UINT16 *p0, *p1; + + v0 = 0xFFFF; + v1 = 0x0000; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_LESS_THAN_HEX16(v0, v1); + TEST_ASSERT_LESS_THAN_HEX16(*p0, v1); + TEST_ASSERT_LESS_THAN_HEX16(v0, *p1); + TEST_ASSERT_LESS_THAN_HEX16(*p0, *p1); +} + +void testNotLessThanHEX16(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_THAN_HEX16(0x0000, 0xFFFF); + VERIFY_FAILS_END +} + +void testLessThanHEX32(void) +{ + UNITY_UINT32 v0, v1; + UNITY_UINT32 *p0, *p1; + + v0 = 0xFFFFFFFF; + v1 = 0x00000000; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_LESS_THAN_HEX32(v0, v1); + TEST_ASSERT_LESS_THAN_HEX32(*p0, v1); + TEST_ASSERT_LESS_THAN_HEX32(v0, *p1); + TEST_ASSERT_LESS_THAN_HEX32(*p0, *p1); +} + +void testNotLessThanHEX32(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_THAN_HEX32(0x00000000, 0xFFFFFFFF); + VERIFY_FAILS_END +} + +void testLessOrEqual(void) +{ + UNITY_INT v0, v1, v2; + UNITY_INT *p0, *p1, *p2; + + v0 = 0; + v1 = -1; + v2 = 0; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_LESS_OR_EQUAL(v0, v1); + TEST_ASSERT_LESS_OR_EQUAL(*p0, v1); + TEST_ASSERT_LESS_OR_EQUAL(v0, *p1); + TEST_ASSERT_LESS_OR_EQUAL(*p0, *p1); + TEST_ASSERT_LESS_OR_EQUAL(v0, v2); + TEST_ASSERT_LESS_OR_EQUAL(*p0, v2); + TEST_ASSERT_LESS_OR_EQUAL(v0, *p2); + TEST_ASSERT_LESS_OR_EQUAL(*p0, *p2); +} + +void testNotLessOrEqual(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_OR_EQUAL(0, 1); + VERIFY_FAILS_END +} + +void testLessOrEqualINT(void) +{ + UNITY_INT v0, v1, v2; + UNITY_INT *p0, *p1, *p2; + + v0 = 3334; + v1 = 302; + v2 = 3334; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_LESS_OR_EQUAL_INT(v0, v1); + TEST_ASSERT_LESS_OR_EQUAL_INT(*p0, v1); + TEST_ASSERT_LESS_OR_EQUAL_INT(v0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_INT(*p0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_INT(v0, v2); + TEST_ASSERT_LESS_OR_EQUAL_INT(*p0, v2); + TEST_ASSERT_LESS_OR_EQUAL_INT(v0, *p2); + TEST_ASSERT_LESS_OR_EQUAL_INT(*p0, *p2); +} + +void testNotLessOrEqualINT(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_OR_EQUAL_INT(302, 3334); + VERIFY_FAILS_END +} + +void testLessOrEqualINT8(void) +{ + UNITY_INT8 v0, v1, v2; + UNITY_INT8 *p0, *p1, *p2; + + v0 = 127; + v1 = -128; + v2 = 127; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_LESS_OR_EQUAL_INT8(v0, v1); + TEST_ASSERT_LESS_OR_EQUAL_INT8(*p0, v1); + TEST_ASSERT_LESS_OR_EQUAL_INT8(v0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_INT8(*p0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_INT8(v0, v2); + TEST_ASSERT_LESS_OR_EQUAL_INT8(*p0, v2); + TEST_ASSERT_LESS_OR_EQUAL_INT8(v0, *p2); + TEST_ASSERT_LESS_OR_EQUAL_INT8(*p0, *p2); +} + +void testNotLessOrEqualINT8(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_OR_EQUAL_INT8(-128, 127); + VERIFY_FAILS_END +} + +void testLessOrEqualINT16(void) +{ + UNITY_INT16 v0, v1, v2; + UNITY_INT16 *p0, *p1, *p2; + + v0 = 32767; + v1 = -32768; + v2 = 32767; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_LESS_OR_EQUAL_INT16(v0, v1); + TEST_ASSERT_LESS_OR_EQUAL_INT16(*p0, v1); + TEST_ASSERT_LESS_OR_EQUAL_INT16(v0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_INT16(*p0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_INT16(v0, v2); + TEST_ASSERT_LESS_OR_EQUAL_INT16(*p0, v2); + TEST_ASSERT_LESS_OR_EQUAL_INT16(v0, *p2); + TEST_ASSERT_LESS_OR_EQUAL_INT16(*p0, *p2); +} + +void testNotLessOrEqualINT16(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_OR_EQUAL_INT16(-32768, 32767); + VERIFY_FAILS_END +} + +void testLessOrEqualINT32(void) +{ + UNITY_INT32 v0, v1, v2; + UNITY_INT32 *p0, *p1, *p2; + + v0 = 214783647; + v1 = -214783648; + v2 = 214783647; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_LESS_OR_EQUAL_INT32(v0, v1); + TEST_ASSERT_LESS_OR_EQUAL_INT32(*p0, v1); + TEST_ASSERT_LESS_OR_EQUAL_INT32(v0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_INT32(*p0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_INT32(v0, v2); + TEST_ASSERT_LESS_OR_EQUAL_INT32(*p0, v2); + TEST_ASSERT_LESS_OR_EQUAL_INT32(v0, *p2); + TEST_ASSERT_LESS_OR_EQUAL_INT32(*p0, *p2); +} + +void testNotLessOrEqualINT32(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_OR_EQUAL_INT32(-214783648, 214783647); + VERIFY_FAILS_END +} + +void testLessOrEqualUINT(void) +{ + UNITY_UINT v0, v1, v2; + UNITY_UINT *p0, *p1, *p2; + + v0 = 1; + v1 = 0; + v2 = 1; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_LESS_OR_EQUAL_UINT(v0, v1); + TEST_ASSERT_LESS_OR_EQUAL_UINT(*p0, v1); + TEST_ASSERT_LESS_OR_EQUAL_UINT(v0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_UINT(*p0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_UINT(v0, v2); + TEST_ASSERT_LESS_OR_EQUAL_UINT(*p0, v2); + TEST_ASSERT_LESS_OR_EQUAL_UINT(v0, *p2); + TEST_ASSERT_LESS_OR_EQUAL_UINT(*p0, *p2); +} + +void testNotLessOrEqualUINT(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_OR_EQUAL_UINT(0, 1); + VERIFY_FAILS_END +} + +void testLessOrEqualUINT8(void) +{ + UNITY_UINT8 v0, v1, v2; + UNITY_UINT8 *p0, *p1, *p2; + + v0 = 255; + v1 = 0; + v2 = 255; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_LESS_OR_EQUAL_UINT8(v0, v1); + TEST_ASSERT_LESS_OR_EQUAL_UINT8(*p0, v1); + TEST_ASSERT_LESS_OR_EQUAL_UINT8(v0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_UINT8(*p0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_UINT8(v0, v2); + TEST_ASSERT_LESS_OR_EQUAL_UINT8(*p0, v2); + TEST_ASSERT_LESS_OR_EQUAL_UINT8(v0, *p2); + TEST_ASSERT_LESS_OR_EQUAL_UINT8(*p0, *p2); +} + +void testNotLessOrEqualUINT8(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_OR_EQUAL_UINT8(0, 255); + VERIFY_FAILS_END +} + +void testLessOrEqualUINT16(void) +{ + UNITY_UINT16 v0, v1, v2; + UNITY_UINT16 *p0, *p1, *p2; + + v0 = 65535; + v1 = 0; + v2 = 65535; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_LESS_OR_EQUAL_UINT16(v0, v1); + TEST_ASSERT_LESS_OR_EQUAL_UINT16(*p0, v1); + TEST_ASSERT_LESS_OR_EQUAL_UINT16(v0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_UINT16(*p0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_UINT16(v0, v2); + TEST_ASSERT_LESS_OR_EQUAL_UINT16(*p0, v2); + TEST_ASSERT_LESS_OR_EQUAL_UINT16(v0, *p2); + TEST_ASSERT_LESS_OR_EQUAL_UINT16(*p0, *p2); +} + +void testNotLessOrEqualUINT16(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_OR_EQUAL_UINT16(0, 65535); + VERIFY_FAILS_END +} + +void testLessOrEqualUINT32(void) +{ + UNITY_UINT32 v0, v1, v2; + UNITY_UINT32 *p0, *p1, *p2; + + v0 = 4294967295; + v1 = 0; + v2 = 4294967295; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_LESS_OR_EQUAL_UINT32(v0, v1); + TEST_ASSERT_LESS_OR_EQUAL_UINT32(*p0, v1); + TEST_ASSERT_LESS_OR_EQUAL_UINT32(v0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_UINT32(*p0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_UINT32(v0, v2); + TEST_ASSERT_LESS_OR_EQUAL_UINT32(*p0, v2); + TEST_ASSERT_LESS_OR_EQUAL_UINT32(v0, *p2); + TEST_ASSERT_LESS_OR_EQUAL_UINT32(*p0, *p2); +} + +void testNotLessOrEqualUINT32(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_OR_EQUAL_UINT32(0, 4294967295); + VERIFY_FAILS_END +} + +void testLessOrEqualHEX8(void) +{ + UNITY_UINT8 v0, v1, v2; + UNITY_UINT8 *p0, *p1, *p2; + + v0 = 0xFF; + v1 = 0x00; + v2 = 0xFF; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_LESS_OR_EQUAL_HEX8(v0, v1); + TEST_ASSERT_LESS_OR_EQUAL_HEX8(*p0, v1); + TEST_ASSERT_LESS_OR_EQUAL_HEX8(v0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_HEX8(*p0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_HEX8(v0, v2); + TEST_ASSERT_LESS_OR_EQUAL_HEX8(*p0, v2); + TEST_ASSERT_LESS_OR_EQUAL_HEX8(v0, *p2); + TEST_ASSERT_LESS_OR_EQUAL_HEX8(*p0, *p2); +} + +void testNotLessOrEqualHEX8(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_OR_EQUAL_HEX8(0x00, 0xFF); + VERIFY_FAILS_END +} + +void testLessOrEqualHEX16(void) +{ + UNITY_UINT16 v0, v1, v2; + UNITY_UINT16 *p0, *p1, *p2; + + v0 = 0xFFFF; + v1 = 0x0000; + v2 = 0xFFFF; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_LESS_OR_EQUAL_HEX16(v0, v1); + TEST_ASSERT_LESS_OR_EQUAL_HEX16(*p0, v1); + TEST_ASSERT_LESS_OR_EQUAL_HEX16(v0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_HEX16(*p0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_HEX16(v0, v2); + TEST_ASSERT_LESS_OR_EQUAL_HEX16(*p0, v2); + TEST_ASSERT_LESS_OR_EQUAL_HEX16(v0, *p2); + TEST_ASSERT_LESS_OR_EQUAL_HEX16(*p0, *p2); +} + +void testNotLessOrEqualHEX16(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_OR_EQUAL_HEX16(0x0000, 0xFFFF); + VERIFY_FAILS_END +} + +void testLessOrEqualHEX32(void) +{ + UNITY_UINT32 v0, v1, v2; + UNITY_UINT32 *p0, *p1, *p2; + + v0 = 0xFFFFFFFF; + v1 = 0x00000000; + v2 = 0xFFFFFFFF; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_LESS_OR_EQUAL_HEX32(v0, v1); + TEST_ASSERT_LESS_OR_EQUAL_HEX32(*p0, v1); + TEST_ASSERT_LESS_OR_EQUAL_HEX32(v0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_HEX32(*p0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_HEX32(v0, v2); + TEST_ASSERT_LESS_OR_EQUAL_HEX32(*p0, v2); + TEST_ASSERT_LESS_OR_EQUAL_HEX32(v0, *p2); + TEST_ASSERT_LESS_OR_EQUAL_HEX32(*p0, *p2); +} + +void testNotLessOrEqualHEX32(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_OR_EQUAL_HEX32(0x00000000, 0xFFFFFFFF); + VERIFY_FAILS_END +} + +//----------------- +void testEqualStrings(void) +{ + const char *testString = "foo"; + + TEST_ASSERT_EQUAL_STRING(testString, testString); + TEST_ASSERT_EQUAL_STRING_MESSAGE("foo", "foo", "foo isn't foo"); + TEST_ASSERT_EQUAL_STRING("foo", testString); + TEST_ASSERT_EQUAL_STRING(testString, "foo"); + TEST_ASSERT_EQUAL_STRING("", ""); +} + +void testEqualStringsLen(void) +{ + const char *testString = "foobar"; + TEST_ASSERT_EQUAL_STRING_LEN(testString, testString, strlen(testString)); + TEST_ASSERT_EQUAL_STRING_LEN_MESSAGE("foobar", "foobaz", 5, "fooba isn't fooba"); + TEST_ASSERT_EQUAL_STRING_LEN("foo", testString, 3); + TEST_ASSERT_EQUAL_STRING_LEN(testString, "foo", 3); + TEST_ASSERT_EQUAL_STRING_LEN("", "", 3); +} + +void testEqualStringsWithCarriageReturnsAndLineFeeds(void) +{ + const char *testString = "foo\r\nbar"; + + TEST_ASSERT_EQUAL_STRING(testString, testString); + TEST_ASSERT_EQUAL_STRING("foo\r\nbar", "foo\r\nbar"); + TEST_ASSERT_EQUAL_STRING("foo\r\nbar", testString); + TEST_ASSERT_EQUAL_STRING(testString, "foo\r\nbar"); + TEST_ASSERT_EQUAL_STRING("", ""); +} + +void testNotEqualString1(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING("foo", "bar"); + VERIFY_FAILS_END +} + +void testNotEqualStringLen1(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING_LEN("foobar", "foobaz", 6); + VERIFY_FAILS_END +} + +void testNotEqualString2(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING("foo", ""); + VERIFY_FAILS_END +} + +void testNotEqualStringLen2(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING_LEN("foo", "", 3); + VERIFY_FAILS_END +} + +void testNotEqualString3(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING("", "bar"); + VERIFY_FAILS_END +} + +void testNotEqualStringLen3(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING_LEN("", "bar", 3); + VERIFY_FAILS_END +} + +void testNotEqualString4(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING("bar\r", "bar\n"); + VERIFY_FAILS_END +} + +void testNotEqualStringLen4(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING_LEN("ba\r\x16", "ba\r\n", 4); + VERIFY_FAILS_END +} + +void testNotEqualString5(void) +{ + const char str1[] = { 0x41, 0x42, 0x03, 0x00 }; + const char str2[] = { 0x41, 0x42, 0x04, 0x00 }; + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING(str1, str2); + VERIFY_FAILS_END +} + +void testNotEqualString_ExpectedStringIsNull(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING(NULL, "bar"); + VERIFY_FAILS_END +} + +void testNotEqualStringLen_ExpectedStringIsNull(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING_LEN(NULL, "bar", 1); + VERIFY_FAILS_END +} + +void testNotEqualString_ActualStringIsNull(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING("foo", NULL); + VERIFY_FAILS_END +} + +void testNotEqualStringLen_ActualStringIsNull(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING_LEN("foo", NULL, 1); + VERIFY_FAILS_END +} + +void testNotEqualString_ExpectedStringIsLonger(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING("foo2", "foo"); + VERIFY_FAILS_END +} + +void testNotEqualString_ActualStringIsLonger(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING("foo", "foo2"); + VERIFY_FAILS_END +} + +void testEqualStringArrays(void) +{ + const char *testStrings[] = { "foo", "boo", "woo", "moo" }; + const char *expStrings[] = { "foo", "boo", "woo", "zoo" }; + + TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, expStrings, 3); + TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 3); + TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 2); + TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 1); +} + +void testNotEqualStringArray1(void) +{ + const char *testStrings[] = { "foo", "boo", "woo", "moo" }; + const char *expStrings[] = { "foo", "boo", "woo", "zoo" }; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4); + VERIFY_FAILS_END +} + +void testNotEqualStringArray2(void) +{ + const char *testStrings[] = { "zoo", "boo", "woo", "moo" }; + const char *expStrings[] = { "foo", "boo", "woo", "moo" }; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4); + VERIFY_FAILS_END +} + +void testNotEqualStringArray3(void) +{ + const char *testStrings[] = { "foo", "boo", "woo", NULL }; + const char *expStrings[] = { "foo", "boo", "woo", "zoo" }; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4); + VERIFY_FAILS_END +} + +void testNotEqualStringArray4(void) +{ + const char *testStrings[] = { "foo", "boo", "woo", "moo" }; + const char *expStrings[] = { "foo", NULL, "woo", "moo" }; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4); + VERIFY_FAILS_END +} + +void testNotEqualStringArray5(void) +{ + const char **testStrings = NULL; + const char *expStrings[] = { "foo", "boo", "woo", "zoo" }; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4); + VERIFY_FAILS_END +} + +void testNotEqualStringArray6(void) +{ + const char *testStrings[] = { "foo", "boo", "woo", "zoo" }; + const char **expStrings = NULL; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4); + VERIFY_FAILS_END +} + +void testEqualStringArrayIfBothNulls(void) +{ + const char **testStrings = NULL; + const char **expStrings = NULL; + + TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4); +} + +void testNotEqualStringArrayLengthZero(void) +{ + const char *testStrings[] = {NULL}; + const char **expStrings = NULL; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 0); + VERIFY_FAILS_END +} + +void testEqualStringEachEqual(void) +{ + const char *testStrings1[] = { "foo", "foo", "foo", "foo" }; + const char *testStrings2[] = { "boo", "boo", "boo", "zoo" }; + const char *testStrings3[] = { "", "", "", "" }; + + TEST_ASSERT_EACH_EQUAL_STRING("foo", testStrings1, 4); + TEST_ASSERT_EACH_EQUAL_STRING("foo", testStrings1, 1); + TEST_ASSERT_EACH_EQUAL_STRING("boo", testStrings2, 3); + TEST_ASSERT_EACH_EQUAL_STRING("", testStrings3, 4); +} + +void testNotEqualStringEachEqual1(void) +{ + const char *testStrings[] = { "foo", "foo", "foo", "moo" }; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_STRING("foo", testStrings, 4); + VERIFY_FAILS_END +} + +void testNotEqualStringEachEqual2(void) +{ + const char *testStrings[] = { "boo", "foo", "foo", "foo" }; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_STRING("foo", testStrings, 4); + VERIFY_FAILS_END +} + +void testNotEqualStringEachEqual3(void) +{ + const char *testStrings[] = { "foo", "foo", "foo", NULL }; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_STRING("foo", testStrings, 4); + VERIFY_FAILS_END +} + +void testNotEqualStringEachEqual4(void) +{ + const char *testStrings[] = { "foo", "foo", "woo", "foo" }; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_STRING("foo", testStrings, 4); + VERIFY_FAILS_END +} + +void testNotEqualStringEachEqual5(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_STRING("foo", NULL, 1); + VERIFY_FAILS_END +} + +void testEqualMemory(void) +{ + const char *testString = "whatever"; + + TEST_ASSERT_EQUAL_MEMORY(testString, testString, 8); + TEST_ASSERT_EQUAL_MEMORY("whatever", "whatever", 8); + TEST_ASSERT_EQUAL_MEMORY("whatever", testString, 8); + TEST_ASSERT_EQUAL_MEMORY(testString, "whatever", 8); + TEST_ASSERT_EQUAL_MEMORY(testString, "whatever", 2); + TEST_ASSERT_EQUAL_MEMORY(NULL, NULL, 1); +} + +void testNotEqualMemory1(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_MEMORY("foo", "bar", 3); + VERIFY_FAILS_END +} + +void testNotEqualMemory2(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_MEMORY("fool", "food", 4); + VERIFY_FAILS_END +} + +void testNotEqualMemory3(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_MEMORY(NULL, "food", 4); + VERIFY_FAILS_END +} + +void testNotEqualMemory4(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_MEMORY("fool", NULL, 4); + VERIFY_FAILS_END +} + +void testNotEqualMemoryLengthZero(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_MEMORY(NULL, NULL, 0); + VERIFY_FAILS_END +} + +void testEqualIntArrays(void) +{ + int p0[] = {1, 8, 987, -2}; + int p1[] = {1, 8, 987, -2}; + int p2[] = {1, 8, 987, 2}; + int p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EQUAL_INT_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_INT_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_INT_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_INT_ARRAY(p0, p3, 1); + TEST_ASSERT_EQUAL_INT_ARRAY(NULL, NULL, 1); +} + +void testNotEqualIntArraysNullExpected(void) +{ + int* p0 = NULL; + int p1[] = {1, 8, 987, 2}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualIntArraysNullActual(void) +{ + int* p1 = NULL; + int p0[] = {1, 8, 987, 2}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualIntArrays1(void) +{ + int p0[] = {1, 8, 987, -2}; + int p1[] = {1, 8, 987, 2}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualIntArrays2(void) +{ + int p0[] = {1, 8, 987, -2}; + int p1[] = {2, 8, 987, -2}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualIntArrays3(void) +{ + int p0[] = {1, 8, 987, -2}; + int p1[] = {1, 8, 986, -2}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualIntArraysLengthZero(void) +{ + UNITY_UINT32 p0[1] = {1}; + UNITY_UINT32 p1[1] = {1}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 0); + VERIFY_FAILS_END +} + +void testEqualIntEachEqual(void) +{ + int p0[] = {1, 1, 1, 1}; + int p1[] = {987, 987, 987, 987}; + int p2[] = {-2, -2, -2, -3}; + int p3[] = {1, 5, 600, 700}; + + TEST_ASSERT_EACH_EQUAL_INT(1, p0, 1); + TEST_ASSERT_EACH_EQUAL_INT(1, p0, 4); + TEST_ASSERT_EACH_EQUAL_INT(987, p1, 4); + TEST_ASSERT_EACH_EQUAL_INT(-2, p2, 3); + TEST_ASSERT_EACH_EQUAL_INT(1, p3, 1); +} + +void testNotEqualIntEachEqualNullActual(void) +{ + int* p1 = NULL; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_INT(1, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualIntEachEqual1(void) +{ + int p0[] = {1, 1, 1, -2}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_INT(1, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualIntEachEqual2(void) +{ + int p0[] = {-5, -5, -1, -5}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_INT(-5, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualIntEachEqual3(void) +{ + int p0[] = {1, 88, 88, 88}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_INT(88, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualEachEqualLengthZero(void) +{ + UNITY_UINT32 p0[1] = {1}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_INT(0, p0, 0); + VERIFY_FAILS_END +} + +void testEqualPtrArrays(void) +{ + char A = 1; + char B = 2; + char C = 3; + char* p0[] = {&A, &B, &C}; + char* p1[] = {&A, &B, &C, &A}; + char* p2[] = {&A, &B}; + char* p3[] = {&A}; + + TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p0, 3); + TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p1, 3); + TEST_ASSERT_EQUAL_PTR_ARRAY(p1, p2, 2); + TEST_ASSERT_EQUAL_PTR_ARRAY(p3, p0, 1); +} + +void testNotEqualPtrArraysNullExpected(void) +{ + char A = 1; + char B = 2; + char** p0 = NULL; + char* p1[] = {&A, &B}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p1, 2); + VERIFY_FAILS_END +} + +void testNotEqualPtrArraysNullActual(void) +{ + char A = 1; + char B = 2; + char** p0 = NULL; + char* p1[] = {&A, &B}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_PTR_ARRAY(p1, p0, 2); + VERIFY_FAILS_END +} + +void testNotEqualPtrArrays1(void) +{ + char A = 1; + char B = 2; + char C = 3; + char* p0[] = {&A, &B, &C, &B}; + char* p1[] = {&A, &B, &C, &A}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualPtrArrays2(void) +{ + char A = 1; + char B = 2; + char C = 3; + char* p0[] = {&B, &B, &C, &A}; + char* p1[] = {&A, &B, &C, &A}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualPtrArrays3(void) +{ + char A = 1; + char B = 2; + char C = 3; + char* p0[] = {&A, &B, &B, &A}; + char* p1[] = {&A, &B, &C, &A}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testEqualPtrEachEqual(void) +{ + char A = 1; + char B = 2; + char C = 3; + char* p0[] = {&A, &A, &A}; + char* p1[] = {&A, &B, &C, &A}; + char* p2[] = {&B, &B}; + char* p3[] = {&C}; + + TEST_ASSERT_EACH_EQUAL_PTR(&A, p0, 1); + TEST_ASSERT_EACH_EQUAL_PTR(&A, p0, 3); + TEST_ASSERT_EACH_EQUAL_PTR(&A, p1, 1); + TEST_ASSERT_EACH_EQUAL_PTR(&B, p2, 2); + TEST_ASSERT_EACH_EQUAL_PTR(&C, p3, 1); +} + +void testNotEqualPtrEachEqualNullExpected(void) +{ + char A = 1; + char B = 1; + char* p0[] = {&A, &B}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_PTR(&A, p0, 2); + VERIFY_FAILS_END +} + +void testNotEqualPtrEachEqualNullActual(void) +{ + char A = 1; + char** p0 = NULL; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_PTR(&A, p0, 2); + VERIFY_FAILS_END +} + +void testNotEqualPtrEachEqual1(void) +{ + char A = 1; + char B = 1; + char* p0[] = {&A, &A, &A, &B}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_PTR(&A, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualPtrEachEqual2(void) +{ + char A = 1; + char B = 1; + char* p0[] = {&B, &B, &A, &B}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_PTR(&B, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualPtrEachEqual3(void) +{ + char A = 1; + char B = 1; + char* p0[] = {&A, &B, &B, &B}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_PTR(&B, p0, 4); + VERIFY_FAILS_END +} + +void testEqualInt8Arrays(void) +{ + UNITY_INT8 p0[] = {1, 8, 117, -2}; + UNITY_INT8 p1[] = {1, 8, 117, -2}; + UNITY_INT8 p2[] = {1, 8, 117, 2}; + UNITY_INT8 p3[] = {1, 50, 60, 70}; + + TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p3, 1); +} + +void testNotEqualInt8Arrays(void) +{ + UNITY_INT8 p0[] = {1, 8, 36, -2}; + UNITY_INT8 p1[] = {1, 8, 36, 2}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testEqualInt8EachEqual(void) +{ + UNITY_INT8 p0[] = {1, 1, 1, 1}; + UNITY_INT8 p1[] = {117, 117, 117, -2}; + UNITY_INT8 p2[] = {-1, -1, 117, 2}; + UNITY_INT8 p3[] = {1, 50, 60, 70}; + + TEST_ASSERT_EACH_EQUAL_INT8(1, p0, 1); + TEST_ASSERT_EACH_EQUAL_INT8(1, p0, 4); + TEST_ASSERT_EACH_EQUAL_INT8(117, p1, 3); + TEST_ASSERT_EACH_EQUAL_INT8(-1, p2, 2); + TEST_ASSERT_EACH_EQUAL_INT8(1, p3, 1); +} + +void testNotEqualInt8EachEqual(void) +{ + UNITY_INT8 p0[] = {1, 8, 36, -2}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_INT8(1, p0, 2); + VERIFY_FAILS_END +} + +void testEqualUIntArrays(void) +{ + unsigned int p0[] = {1, 8, 987, 65132u}; + unsigned int p1[] = {1, 8, 987, 65132u}; + unsigned int p2[] = {1, 8, 987, 2}; + unsigned int p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p3, 1); +} + +void testNotEqualUIntArrays1(void) +{ + unsigned int p0[] = {1, 8, 987, 65132u}; + unsigned int p1[] = {1, 8, 987, 65131u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualUIntArrays2(void) +{ + unsigned int p0[] = {1, 8, 987, 65132u}; + unsigned int p1[] = {2, 8, 987, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualUIntArrays3(void) +{ + unsigned int p0[] = {1, 8, 987, 65132u}; + unsigned int p1[] = {1, 8, 986, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testEqualUIntEachEqual(void) +{ + unsigned int p0[] = {1, 1, 1, 1}; + unsigned int p1[] = {65132u, 65132u, 65132u, 65132u}; + unsigned int p2[] = {8, 8, 987, 2}; + unsigned int p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EACH_EQUAL_UINT(1, p0, 1); + TEST_ASSERT_EACH_EQUAL_UINT(1, p0, 4); + TEST_ASSERT_EACH_EQUAL_UINT(65132u, p1, 4); + TEST_ASSERT_EACH_EQUAL_UINT(8, p2, 2); + TEST_ASSERT_EACH_EQUAL_UINT(1, p3, 1); +} + +void testNotEqualUIntEachEqual1(void) +{ + unsigned int p0[] = {1, 65132u, 65132u, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_UINT(65132u, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualUIntEachEqual2(void) +{ + unsigned int p0[] = {987, 8, 987, 987}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_UINT(987, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualUIntEachEqual3(void) +{ + unsigned int p0[] = {1, 1, 1, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_UINT(1, p0, 4); + VERIFY_FAILS_END +} + +void testEqualInt16Arrays(void) +{ + UNITY_INT16 p0[] = {1, 8, 117, 3}; + UNITY_INT16 p1[] = {1, 8, 117, 3}; + UNITY_INT16 p2[] = {1, 8, 117, 2}; + UNITY_INT16 p3[] = {1, 50, 60, 70}; + + TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p3, 1); +} + +void testNotEqualInt16Arrays(void) +{ + UNITY_INT16 p0[] = {1, 8, 127, 3}; + UNITY_INT16 p1[] = {1, 8, 127, 2}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testEqualInt16EachEqual(void) +{ + UNITY_INT16 p0[] = {1, 1, 1, 1}; + UNITY_INT16 p1[] = {32111, 32111, 32111, 3}; + UNITY_INT16 p2[] = {-1, -1, -1, 2}; + UNITY_INT16 p3[] = {1, 50, 60, 70}; + + TEST_ASSERT_EACH_EQUAL_INT16(1, p0, 1); + TEST_ASSERT_EACH_EQUAL_INT16(1, p0, 4); + TEST_ASSERT_EACH_EQUAL_INT16(32111, p1, 3); + TEST_ASSERT_EACH_EQUAL_INT16(-1, p2, 3); + TEST_ASSERT_EACH_EQUAL_INT16(1, p3, 1); +} + +void testNotEqualInt16EachEqual(void) +{ + UNITY_INT16 p0[] = {127, 127, 127, 3}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_INT16(127, p0, 4); + VERIFY_FAILS_END +} + +void testEqualInt32Arrays(void) +{ + UNITY_INT32 p0[] = {1, 8, 117, 3}; + UNITY_INT32 p1[] = {1, 8, 117, 3}; + UNITY_INT32 p2[] = {1, 8, 117, 2}; + UNITY_INT32 p3[] = {1, 50, 60, 70}; + + TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p3, 1); +} + +void testNotEqualInt32Arrays(void) +{ + UNITY_INT32 p0[] = {1, 8, 127, 3}; + UNITY_INT32 p1[] = {1, 8, 127, 2}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testEqualInt32EachEqual(void) +{ + UNITY_INT32 p0[] = {8, 8, 8, 8}; + UNITY_INT32 p1[] = {65537, 65537, 65537, 65537}; + UNITY_INT32 p2[] = {-3, -3, -3, 2}; + UNITY_INT32 p3[] = {1, 50, 60, 70}; + + TEST_ASSERT_EACH_EQUAL_INT32(8, p0, 1); + TEST_ASSERT_EACH_EQUAL_INT32(8, p0, 4); + TEST_ASSERT_EACH_EQUAL_INT32(65537, p1, 4); + TEST_ASSERT_EACH_EQUAL_INT32(-3, p2, 3); + TEST_ASSERT_EACH_EQUAL_INT32(1, p3, 1); +} + +void testNotEqualInt32EachEqual(void) +{ + UNITY_INT32 p0[] = {127, 8, 127, 127}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_INT32(127, p0, 4); + VERIFY_FAILS_END +} + +void testEqualUINT8Arrays(void) +{ + UNITY_UINT8 p0[] = {1, 8, 100, 127}; + UNITY_UINT8 p1[] = {1, 8, 100, 127}; + UNITY_UINT8 p2[] = {1, 8, 100, 2}; + UNITY_UINT8 p3[] = {1, 50, 60, 70}; + + TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p3, 1); +} + +void testNotEqualUINT8Arrays1(void) +{ + unsigned char p0[] = {1, 8, 100, 127u}; + unsigned char p1[] = {1, 8, 100, 255u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualUINT8Arrays2(void) +{ + unsigned char p0[] = {1, 8, 100, 127u}; + unsigned char p1[] = {1, 8, 100, 255u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualUINT8Arrays3(void) +{ + unsigned char p0[] = {1, 8, 100, 127u}; + unsigned char p1[] = {1, 8, 100, 255u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + + +void testEqualUINT16Arrays(void) +{ + unsigned short p0[] = {1, 8, 987, 65132u}; + unsigned short p1[] = {1, 8, 987, 65132u}; + unsigned short p2[] = {1, 8, 987, 2}; + unsigned short p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p3, 1); +} + +void testNotEqualUINT16Arrays1(void) +{ + unsigned short p0[] = {1, 8, 987, 65132u}; + unsigned short p1[] = {1, 8, 987, 65131u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualUINT16Arrays2(void) +{ + unsigned short p0[] = {1, 8, 987, 65132u}; + unsigned short p1[] = {2, 8, 987, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualUINT16Arrays3(void) +{ + unsigned short p0[] = {1, 8, 987, 65132u}; + unsigned short p1[] = {1, 8, 986, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testEqualUINT32Arrays(void) +{ + UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT32 p1[] = {1, 8, 987, 65132u}; + UNITY_UINT32 p2[] = {1, 8, 987, 2}; + UNITY_UINT32 p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p3, 1); +} + +void testNotEqualUINT32Arrays1(void) +{ + UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT32 p1[] = {1, 8, 987, 65131u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualUINT32Arrays2(void) +{ + UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT32 p1[] = {2, 8, 987, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualUINT32Arrays3(void) +{ + UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT32 p1[] = {1, 8, 986, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testEqualHEXArrays(void) +{ + UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT32 p1[] = {1, 8, 987, 65132u}; + UNITY_UINT32 p2[] = {1, 8, 987, 2}; + UNITY_UINT32 p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EQUAL_HEX_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_HEX_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_HEX_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p3, 1); +} + +void testNotEqualHEXArrays1(void) +{ + UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT32 p1[] = {1, 8, 987, 65131u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEXArrays2(void) +{ + UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT32 p1[] = {2, 8, 987, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEXArrays3(void) +{ + UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT32 p1[] = {1, 8, 986, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testEqualHEX32Arrays(void) +{ + UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT32 p1[] = {1, 8, 987, 65132u}; + UNITY_UINT32 p2[] = {1, 8, 987, 2}; + UNITY_UINT32 p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p3, 1); +} + +void testNotEqualHEX32Arrays1(void) +{ + UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT32 p1[] = {1, 8, 987, 65131u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEX32Arrays2(void) +{ + UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT32 p1[] = {2, 8, 987, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEX32Arrays3(void) +{ + UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT32 p1[] = {1, 8, 986, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testEqualHEX16Arrays(void) +{ + unsigned short p0[] = {1, 8, 987, 65132u}; + unsigned short p1[] = {1, 8, 987, 65132u}; + unsigned short p2[] = {1, 8, 987, 2}; + unsigned short p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p3, 1); +} + +void testNotEqualHEX16Arrays1(void) +{ + unsigned short p0[] = {1, 8, 987, 65132u}; + unsigned short p1[] = {1, 8, 987, 65131u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEX16Arrays2(void) +{ + unsigned short p0[] = {1, 8, 987, 65132u}; + unsigned short p1[] = {2, 8, 987, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEX16Arrays3(void) +{ + unsigned short p0[] = {1, 8, 987, 65132u}; + unsigned short p1[] = {1, 8, 986, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testEqualHEX8Arrays(void) +{ + unsigned char p0[] = {1, 8, 254u, 123}; + unsigned char p1[] = {1, 8, 254u, 123}; + unsigned char p2[] = {1, 8, 254u, 2}; + unsigned char p3[] = {1, 23, 25, 26}; + + TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p3, 1); +} + +void testNotEqualHEX8Arrays1(void) +{ + unsigned char p0[] = {1, 8, 254u, 253u}; + unsigned char p1[] = {1, 8, 254u, 252u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEX8Arrays2(void) +{ + unsigned char p0[] = {1, 8, 254u, 253u}; + unsigned char p1[] = {2, 8, 254u, 253u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEX8Arrays3(void) +{ + unsigned char p0[] = {1, 8, 254u, 253u}; + unsigned char p1[] = {1, 8, 255u, 253u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testEqualUINT8EachEqual(void) +{ + UNITY_UINT8 p0[] = {127u, 127u, 127u, 127u}; + UNITY_UINT8 p1[] = {1u, 1u, 1u, 1u}; + UNITY_UINT8 p2[] = {128u, 128u, 128u, 2u}; + UNITY_UINT8 p3[] = {1u, 50u, 60u, 70u}; + + TEST_ASSERT_EACH_EQUAL_UINT8(127u, p0, 1); + TEST_ASSERT_EACH_EQUAL_UINT8(127u, p0, 4); + TEST_ASSERT_EACH_EQUAL_UINT8(1u, p1, 4); + TEST_ASSERT_EACH_EQUAL_UINT8(128u, p2, 3); + TEST_ASSERT_EACH_EQUAL_UINT8(1u, p3, 1); +} + +void testNotEqualUINT8EachEqual1(void) +{ + unsigned char p0[] = {127u, 127u, 128u, 127u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_UINT8(127u, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualUINT8EachEqual2(void) +{ + unsigned char p0[] = {1, 1, 1, 127u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_UINT8(1, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualUINT8EachEqual3(void) +{ + unsigned char p0[] = {54u, 55u, 55u, 55u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_UINT8(55u, p0, 4); + VERIFY_FAILS_END +} + +void testEqualUINT16EachEqual(void) +{ + unsigned short p0[] = {65132u, 65132u, 65132u, 65132u}; + unsigned short p1[] = {987, 987, 987, 987}; + unsigned short p2[] = {1, 1, 1, 2}; + unsigned short p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EACH_EQUAL_UINT16(65132u, p0, 1); + TEST_ASSERT_EACH_EQUAL_UINT16(65132u, p0, 4); + TEST_ASSERT_EACH_EQUAL_UINT16(987, p1, 4); + TEST_ASSERT_EACH_EQUAL_UINT16(1, p2, 3); + TEST_ASSERT_EACH_EQUAL_UINT16(1, p3, 1); +} + +void testNotEqualUINT16EachEqual1(void) +{ + unsigned short p0[] = {1, 65132u, 65132u, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_UINT16(65132u, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualUINT16EachEqual2(void) +{ + unsigned short p0[] = {65132u, 65132u, 987, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_UINT16(65132u, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualUINT16EachEqual3(void) +{ + unsigned short p0[] = {65132u, 65132u, 65132u, 65133u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_UINT16(65132u, p0, 4); + VERIFY_FAILS_END +} + +void testEqualUINT32EachEqual(void) +{ + UNITY_UINT32 p0[] = {65132u, 65132u, 65132u, 65132u}; + UNITY_UINT32 p1[] = {987, 987, 987, 987}; + UNITY_UINT32 p2[] = {8, 8, 8, 2}; + UNITY_UINT32 p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EACH_EQUAL_UINT32(65132u, p0, 1); + TEST_ASSERT_EACH_EQUAL_UINT32(65132u, p0, 4); + TEST_ASSERT_EACH_EQUAL_UINT32(987, p1, 4); + TEST_ASSERT_EACH_EQUAL_UINT32(8, p2, 3); + TEST_ASSERT_EACH_EQUAL_UINT32(1, p3, 1); +} + +void testNotEqualUINT32EachEqual1(void) +{ + UNITY_UINT32 p0[] = {65132u, 65132u, 987, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_UINT32(65132u, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualUINT32EachEqual2(void) +{ + UNITY_UINT32 p0[] = {1, 987, 987, 987}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_UINT32(987, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualUINT32EachEqual3(void) +{ + UNITY_UINT32 p0[] = {1, 1, 1, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_UINT32(1, p0, 4); + VERIFY_FAILS_END +} + +void testEqualHEXEachEqual(void) +{ + UNITY_UINT32 p0[] = {65132u, 65132u, 65132u, 65132u}; + UNITY_UINT32 p1[] = {987, 987, 987, 987}; + UNITY_UINT32 p2[] = {8, 8, 8, 2}; + UNITY_UINT32 p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EACH_EQUAL_HEX(65132u, p0, 1); + TEST_ASSERT_EACH_EQUAL_HEX(65132u, p0, 4); + TEST_ASSERT_EACH_EQUAL_HEX(987, p1, 4); + TEST_ASSERT_EACH_EQUAL_HEX(8, p2, 3); + TEST_ASSERT_EACH_EQUAL_HEX(1, p3, 1); +} + +void testNotEqualHEXEachEqual1(void) +{ + UNITY_UINT32 p0[] = {1, 65132u, 65132u, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_HEX32(65132u, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEXEachEqual2(void) +{ + UNITY_UINT32 p0[] = {987, 987, 987, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_HEX32(987, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEXEachEqual3(void) +{ + UNITY_UINT32 p0[] = {8, 8, 987, 8}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_HEX(8, p0, 4); + VERIFY_FAILS_END +} + +void testEqualHEX32EachEqual(void) +{ + UNITY_UINT32 p0[] = {65132u, 65132u, 65132u, 65132u}; + UNITY_UINT32 p1[] = {987, 987, 987, 987}; + UNITY_UINT32 p2[] = {8, 8, 8, 2}; + UNITY_UINT32 p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EACH_EQUAL_HEX32(65132u, p0, 1); + TEST_ASSERT_EACH_EQUAL_HEX32(65132u, p0, 4); + TEST_ASSERT_EACH_EQUAL_HEX32(987, p1, 4); + TEST_ASSERT_EACH_EQUAL_HEX32(8, p2, 3); + TEST_ASSERT_EACH_EQUAL_HEX32(1, p3, 1); +} + +void testNotEqualHEX32EachEqual1(void) +{ + UNITY_UINT32 p0[] = {65132u, 8, 65132u, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_HEX32(65132u, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEX32EachEqual2(void) +{ + UNITY_UINT32 p0[] = {1, 987, 987, 987}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_HEX32(987, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEX32EachEqual3(void) +{ + UNITY_UINT32 p0[] = {8, 8, 8, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_HEX32(8, p0, 4); + VERIFY_FAILS_END +} + +void testEqualHEX16EachEqual(void) +{ + UNITY_UINT16 p0[] = {65132u, 65132u, 65132u, 65132u}; + UNITY_UINT16 p1[] = {987, 987, 987, 987}; + UNITY_UINT16 p2[] = {8, 8, 8, 2}; + UNITY_UINT16 p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EACH_EQUAL_HEX16(65132u, p0, 1); + TEST_ASSERT_EACH_EQUAL_HEX16(65132u, p0, 4); + TEST_ASSERT_EACH_EQUAL_HEX16(987, p1, 4); + TEST_ASSERT_EACH_EQUAL_HEX16(8, p2, 3); + TEST_ASSERT_EACH_EQUAL_HEX16(1, p3, 1); +} + +void testNotEqualHEX16EachEqual1(void) +{ + unsigned short p0[] = {65132u, 65132u, 987, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_HEX16(65132u, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEX16EachEqual2(void) +{ + unsigned short p0[] = {1, 987, 987, 987}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_HEX16(987, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEX16EachEqual3(void) +{ + unsigned short p0[] = {8, 8, 8, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_HEX16(8, p0, 4); + VERIFY_FAILS_END +} + +void testEqualHEX8EachEqual(void) +{ + unsigned char p0[] = {254u, 254u, 254u, 254u}; + unsigned char p1[] = {123, 123, 123, 123}; + unsigned char p2[] = {8, 8, 8, 2}; + unsigned char p3[] = {1, 23, 25, 26}; + + TEST_ASSERT_EACH_EQUAL_HEX8(254u, p0, 1); + TEST_ASSERT_EACH_EQUAL_HEX8(254u, p0, 4); + TEST_ASSERT_EACH_EQUAL_HEX8(123, p1, 4); + TEST_ASSERT_EACH_EQUAL_HEX8(8, p2, 3); + TEST_ASSERT_EACH_EQUAL_HEX8(1, p3, 1); +} + +void testNotEqualHEX8EachEqual1(void) +{ + unsigned char p0[] = {253u, 253u, 254u, 253u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_HEX8(253u, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEX8EachEqual2(void) +{ + unsigned char p0[] = {254u, 254u, 254u, 253u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_HEX8(254u, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEX8EachEqual3(void) +{ + unsigned char p0[] = {1, 8, 8, 8}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_HEX8(8, p0, 4); + VERIFY_FAILS_END +} + +void testEqualMemoryArrays(void) +{ + int p0[] = {1, 8, 987, -2}; + int p1[] = {1, 8, 987, -2}; + int p2[] = {1, 8, 987, 2}; + int p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p0, sizeof(int), 1); + TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p0, sizeof(int), 4); + TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, sizeof(int), 4); + TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p2, sizeof(int), 3); + TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p3, sizeof(int), 1); +} + +void testNotEqualMemoryArraysExpectedNull(void) +{ + int* p0 = NULL; + int p1[] = {1, 8, 987, 2}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, sizeof(int), 4); + VERIFY_FAILS_END +} + +void testNotEqualMemoryArraysActualNull(void) +{ + int p0[] = {1, 8, 987, -2}; + int* p1 = NULL; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, sizeof(int), 4); + VERIFY_FAILS_END +} + +void testNotEqualMemoryArrays1(void) +{ + int p0[] = {1, 8, 987, -2}; + int p1[] = {1, 8, 987, 2}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, sizeof(int), 4); + VERIFY_FAILS_END +} + +void testNotEqualMemoryArrays2(void) +{ + int p0[] = {1, 8, 987, -2}; + int p1[] = {2, 8, 987, -2}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, sizeof(int), 4); + VERIFY_FAILS_END +} + +void testNotEqualMemoryArrays3(void) +{ + int p0[] = {1, 8, 987, -2}; + int p1[] = {1, 8, 986, -2}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, sizeof(int), 4); + VERIFY_FAILS_END +} + +void testEqualMemoryEachEqual(void) +{ + int p0[] = {1, 8, 987, -2}; + int p1[] = {1, 8, 987, -2, 1, 8, 987, -2}; + int p2[] = {8, 8, 8, 2}; + int p3[] = {8, 500, 600, 700}; + int v = 8; + + TEST_ASSERT_EACH_EQUAL_MEMORY(p0, p0, sizeof(int)*4, 1); + TEST_ASSERT_EACH_EQUAL_MEMORY(p0, p1, sizeof(int)*4, 2); + TEST_ASSERT_EACH_EQUAL_MEMORY(p0, p1, sizeof(int)*4, 1); + TEST_ASSERT_EACH_EQUAL_MEMORY(&v, p2, sizeof(int), 3); + TEST_ASSERT_EACH_EQUAL_MEMORY(&v, p3, sizeof(int), 1); +} + +void testNotEqualMemoryEachEqualExpectedNull(void) +{ + int* p0 = NULL; + int p1[] = {1, 8, 987, 2}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_MEMORY(p0, p1, sizeof(int), 4); + VERIFY_FAILS_END +} + +void testNotEqualMemoryEachEqualActualNull(void) +{ + int p0[] = {1, 8, 987, -2}; + int* p1 = NULL; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_MEMORY(p0, p1, sizeof(int), 4); + VERIFY_FAILS_END +} + +void testNotEqualMemoryEachEqual1(void) +{ + int p0[] = {1, 8, 987, -2}; + int p1[] = {9, 8, 987, -2, 1, 8, 987, -2, 1, 8, 987, -2}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_MEMORY(p0, p1, sizeof(int)*4, 3); + VERIFY_FAILS_END +} + +void testNotEqualMemoryEachEqual2(void) +{ + int p0[] = {1, 8, 987, -2}; + int p1[] = {1, 8, 987, -2, 1, 8, 987, -2, 1, 8, 987, 9}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_MEMORY(p0, p1, sizeof(int)*4, 3); + VERIFY_FAILS_END +} + +void testNotEqualMemoryEachEqual3(void) +{ + int p0[] = {1, 8, 987, -2}; + int p1[] = {1, 8, 987, -2, 1, 9, 987, -2, 1, 8, 987, -2}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_MEMORY(p0, p1, sizeof(int)*4, 3); + VERIFY_FAILS_END +} + +void testProtection(void) +{ + volatile int mask = 0; + + if (TEST_PROTECT()) + { + mask |= 1; + TEST_ABORT(); + } + else + { + Unity.CurrentTestFailed = 0; + mask |= 2; + } + + TEST_ASSERT_EQUAL(3, mask); +} + +void testIgnoredAndThenFailInTearDown(void) +{ + SetToOneToFailInTearDown = 1; + TEST_IGNORE(); +} + +// Tricky series of macros to set USING_OUTPUT_SPY +#define USING_SPY_AS(a) EXPAND_AND_USE_2ND(ASSIGN_VALUE(a), 0) +#define ASSIGN_VALUE(a) VAL_##a +#define VAL_putcharSpy 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 // true only if UNITY_OUTPUT_CHAR = putcharSpy +#endif + +#ifdef USING_OUTPUT_SPY +#include +#define SPY_BUFFER_MAX 40 +static char putcharSpyBuffer[SPY_BUFFER_MAX]; +#endif +static int indexSpyBuffer; +static int putcharSpyEnabled; + +void startPutcharSpy(void) {indexSpyBuffer = 0; putcharSpyEnabled = 1;} + +void endPutcharSpy(void) {putcharSpyEnabled = 0;} + +char* getBufferPutcharSpy(void) +{ +#ifdef USING_OUTPUT_SPY + putcharSpyBuffer[indexSpyBuffer] = '\0'; + return putcharSpyBuffer; +#else + return NULL; +#endif +} + +void putcharSpy(int c) +{ +#ifdef USING_OUTPUT_SPY + if (putcharSpyEnabled) + { + if (indexSpyBuffer < SPY_BUFFER_MAX - 1) + putcharSpyBuffer[indexSpyBuffer++] = (char)c; + } else + putchar((char)c); +#endif +} + +/* This is for counting the calls to the flushSpy */ +static int flushSpyEnabled; +static int flushSpyCalls = 0; + +void startFlushSpy(void) { flushSpyCalls = 0; flushSpyEnabled = 1; } +void endFlushSpy(void) { flushSpyCalls = 0; flushSpyEnabled = 0; } +int getFlushSpyCalls(void) { return flushSpyCalls; } + +void flushSpy(void) +{ + if (flushSpyEnabled){ flushSpyCalls++; } +} + +void testFailureCountIncrementsAndIsReturnedAtEnd(void) +{ + UNITY_UINT savedFailures = Unity.TestFailures; + Unity.CurrentTestFailed = 1; + startPutcharSpy(); // Suppress output + startFlushSpy(); + TEST_ASSERT_EQUAL(0, getFlushSpyCalls()); + UnityConcludeTest(); + endPutcharSpy(); + TEST_ASSERT_EQUAL(savedFailures + 1, Unity.TestFailures); +#if defined(UNITY_OUTPUT_FLUSH) && defined(UNITY_OUTPUT_FLUSH_HEADER_DECLARATION) + TEST_ASSERT_EQUAL(1, getFlushSpyCalls()); +#else + TEST_ASSERT_EQUAL(0, getFlushSpyCalls()); +#endif + endFlushSpy(); + + startPutcharSpy(); // Suppress output + int failures = UnityEnd(); + Unity.TestFailures--; + endPutcharSpy(); + TEST_ASSERT_EQUAL(savedFailures + 1, failures); +} + +void testCstringsEscapeSequence(void) +{ +#ifndef USING_OUTPUT_SPY + TEST_IGNORE(); +#else + startPutcharSpy(); + UnityPrint("\x16\x10"); + endPutcharSpy(); + TEST_ASSERT_EQUAL_STRING("\\x16\\x10", getBufferPutcharSpy()); +#endif +} + +void testHexPrintsUpToMaxNumberOfNibbles(void) +{ +#ifndef USING_OUTPUT_SPY + TEST_IGNORE(); +#else + startPutcharSpy(); + UnityPrintNumberHex(0xBEE, 21); + endPutcharSpy(); + TEST_ASSERT_EQUAL_INT(sizeof(UNITY_INT)*2, strlen(getBufferPutcharSpy())); +#endif +} + +#define TEST_ASSERT_EQUAL_PRINT_NUMBERS(expected, actual) { \ + startPutcharSpy(); UnityPrintNumber((actual)); endPutcharSpy(); \ + TEST_ASSERT_EQUAL_STRING((expected), getBufferPutcharSpy()); \ + } + +#define TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS(expected, actual) { \ + startPutcharSpy(); UnityPrintNumberUnsigned((actual)); endPutcharSpy(); \ + TEST_ASSERT_EQUAL_STRING((expected), getBufferPutcharSpy()); \ + } + +void testPrintNumbers32(void) +{ +#ifndef USING_OUTPUT_SPY + TEST_IGNORE_MESSAGE("Compile with '-D UNITY_OUTPUT_CHAR=putcharSpy' to enable print testing"); +#else + TEST_ASSERT_EQUAL_PRINT_NUMBERS("0", 0); + TEST_ASSERT_EQUAL_PRINT_NUMBERS("1", 1); + TEST_ASSERT_EQUAL_PRINT_NUMBERS("-1", -1); + TEST_ASSERT_EQUAL_PRINT_NUMBERS("2000000000", 2000000000); + TEST_ASSERT_EQUAL_PRINT_NUMBERS("-2147483648", (UNITY_INT32)0x80000000); + TEST_ASSERT_EQUAL_PRINT_NUMBERS("-1", (UNITY_INT32)0xFFFFFFFF); +#endif +} + +void testPrintNumbersUnsigned32(void) +{ +#ifndef USING_OUTPUT_SPY + TEST_IGNORE(); +#else + TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("0", 0); + TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("1", 1); + TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("1500000000", 1500000000); + TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("2147483648", (UNITY_UINT32)0x80000000); + TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("4294967295", (UNITY_UINT32)0xFFFFFFFF); +#endif +} + + +// ===================== THESE TEST WILL RUN IF YOUR CONFIG INCLUDES 64 BIT SUPPORT ================== + +void testPrintNumbersInt64(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + #ifndef USING_OUTPUT_SPY + TEST_IGNORE(); + #else + TEST_ASSERT_EQUAL_PRINT_NUMBERS("0", 0); + TEST_ASSERT_EQUAL_PRINT_NUMBERS("10000000000", 10000000000); + TEST_ASSERT_EQUAL_PRINT_NUMBERS("-9223372036854775808", (UNITY_INT)0x8000000000000000); + TEST_ASSERT_EQUAL_PRINT_NUMBERS("-1", (UNITY_INT)0xFFFFFFFFFFFFFFFF); + #endif +#endif +} + +void testPrintNumbersUInt64(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + #ifndef USING_OUTPUT_SPY + TEST_IGNORE(); + #else + TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("0", 0); + TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("70000000000", 70000000000); + TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("9223372036854775808", (UNITY_UINT)0x8000000000000000); + TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("18446744073709551615", (UNITY_UINT)0xFFFFFFFFFFFFFFFF); + #endif +#endif +} + +void testEqualHex64s(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 v0, v1; + UNITY_UINT64 *p0, *p1; + + v0 = 0x9876543201234567; + v1 = 0x9876543201234567; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_HEX64(0x9876543201234567, 0x9876543201234567); + TEST_ASSERT_EQUAL_HEX64(v0, v1); + TEST_ASSERT_EQUAL_HEX64(0x9876543201234567, v1); + TEST_ASSERT_EQUAL_HEX64(v0, 0x9876543201234567); + TEST_ASSERT_EQUAL_HEX64(*p0, v1); + TEST_ASSERT_EQUAL_HEX64(*p0, *p1); + TEST_ASSERT_EQUAL_HEX64(*p0, 0x9876543201234567); +#endif +} + +void testEqualUint64s(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 v0, v1; + UNITY_UINT64 *p0, *p1; + + v0 = 0x9876543201234567; + v1 = 0x9876543201234567; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_UINT64(0x9876543201234567, 0x9876543201234567); + TEST_ASSERT_EQUAL_UINT64(v0, v1); + TEST_ASSERT_EQUAL_UINT64(0x9876543201234567, v1); + TEST_ASSERT_EQUAL_UINT64(v0, 0x9876543201234567); + TEST_ASSERT_EQUAL_UINT64(*p0, v1); + TEST_ASSERT_EQUAL_UINT64(*p0, *p1); + TEST_ASSERT_EQUAL_UINT64(*p0, 0x9876543201234567); +#endif +} + +void testEqualInt64s(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 v0, v1; + UNITY_INT64 *p0, *p1; + + v0 = (UNITY_INT64)0x9876543201234567; + v1 = (UNITY_INT64)0x9876543201234567; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_INT64(0x9876543201234567, 0x9876543201234567); + TEST_ASSERT_EQUAL_INT64(v0, v1); + TEST_ASSERT_EQUAL_INT64(0x9876543201234567, v1); + TEST_ASSERT_EQUAL_INT64(v0, 0x9876543201234567); + TEST_ASSERT_EQUAL_INT64(*p0, v1); + TEST_ASSERT_EQUAL_INT64(*p0, *p1); + TEST_ASSERT_EQUAL_INT64(*p0, 0x9876543201234567); +#endif +} + + +void testNotEqualHex64s(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 v0, v1; + + v0 = 9000000000; + v1 = 9100000000; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX64(v0, v1); + VERIFY_FAILS_END +#endif +} + +void testNotEqualUint64s(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 v0, v1; + + v0 = 9000000000; + v1 = 9100000000; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT64(v0, v1); + VERIFY_FAILS_END +#endif +} + +void testNotEqualInt64s(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 v0, v1; + + v0 = -9000000000; + v1 = 9100000000; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT64(v0, v1); + VERIFY_FAILS_END +#endif +} + +void testNotEqualHex64sIfSigned(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 v0, v1; + + v0 = -9000000000; + v1 = 9000000000; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX64(v0, v1); + VERIFY_FAILS_END +#endif +} + +void testHEX64sWithinDelta(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + TEST_ASSERT_HEX64_WITHIN(1, 0x7FFFFFFFFFFFFFFF,0x7FFFFFFFFFFFFFFE); + TEST_ASSERT_HEX64_WITHIN(5, 5000, 4996); + TEST_ASSERT_HEX64_WITHIN(5, 5000, 5005); +#endif +} + +void testHEX64sNotWithinDelta(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX64_WITHIN(1, 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFC); + VERIFY_FAILS_END +#endif +} + +void testHEX64sNotWithinDeltaEvenThoughASignedIntWouldPass(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX64_WITHIN(5, 1, -1); + VERIFY_FAILS_END +#endif +} + +void testUINT64sWithinDelta(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + TEST_ASSERT_UINT64_WITHIN(1, 0x7FFFFFFFFFFFFFFF,0x7FFFFFFFFFFFFFFE); + TEST_ASSERT_UINT64_WITHIN(5, 5000, 4996); + TEST_ASSERT_UINT64_WITHIN(5, 5000, 5005); +#endif +} + +void testUINT64sNotWithinDelta(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT64_WITHIN(1, 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFC); + VERIFY_FAILS_END +#endif +} + +void testUINT64sNotWithinDeltaEvenThoughASignedIntWouldPass(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT64_WITHIN(5, 1, -1); + VERIFY_FAILS_END +#endif +} + +void testINT64sWithinDelta(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + TEST_ASSERT_INT64_WITHIN(1, 0x7FFFFFFFFFFFFFFF,0x7FFFFFFFFFFFFFFE); + TEST_ASSERT_INT64_WITHIN(5, 5000, 4996); + TEST_ASSERT_INT64_WITHIN(5, 5000, 5005); +#endif +} + +void testINT64sNotWithinDelta(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT64_WITHIN(1, 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFC); + VERIFY_FAILS_END +#endif +} + +void testINT64sNotWithinDeltaAndDifferenceOverflows(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT64_WITHIN(1, 0x8000000000000000, 0x7FFFFFFFFFFFFFFF); + VERIFY_FAILS_END +#endif +} + +void testEqualHEX64Arrays(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT64 p1[] = {1, 8, 987, 65132u}; + UNITY_UINT64 p2[] = {1, 8, 987, 2}; + UNITY_UINT64 p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p3, 1); +#endif +} + +void testEqualUint64Arrays(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT64 p1[] = {1, 8, 987, 65132u}; + UNITY_UINT64 p2[] = {1, 8, 987, 2}; + UNITY_UINT64 p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p3, 1); +#endif +} + +void testEqualInt64Arrays(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 p0[] = {1, 8, 987, -65132}; + UNITY_INT64 p1[] = {1, 8, 987, -65132}; + UNITY_INT64 p2[] = {1, 8, 987, -2}; + UNITY_INT64 p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p3, 1); +#endif +} + + +void testNotEqualHEX64Arrays1(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT64 p1[] = {1, 8, 987, 65131u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualHEX64Arrays2(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT64 p1[] = {2, 8, 987, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualUint64Arrays(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT64 p1[] = {1, 8, 987, 65131u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualInt64Arrays(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 p0[] = {1, 8, 987, -65132}; + UNITY_INT64 p1[] = {1, 8, 987, -65131}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} +// ===================== THESE TEST WILL RUN IF YOUR CONFIG INCLUDES FLOAT SUPPORT ================== + +void testFloatsWithinDelta(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_FLOAT_WITHIN(0.00003f, 187245.03485f, 187245.03488f); + TEST_ASSERT_FLOAT_WITHIN(1.0f, 187245.0f, 187246.0f); + TEST_ASSERT_FLOAT_WITHIN(0.05f, 9273.2549f, 9273.2049f); + TEST_ASSERT_FLOAT_WITHIN(0.007f, -726.93724f, -726.94424f); +#endif +} + +void testFloatsNotWithinDelta(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_FLOAT_WITHIN(0.05f, 9273.2649f, 9273.2049f); + VERIFY_FAILS_END +#endif +} + +void testFloatsEqual(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_EQUAL_FLOAT(187245.0f, 187246.0f); + TEST_ASSERT_EQUAL_FLOAT(18724.5f, 18724.6f); + TEST_ASSERT_EQUAL_FLOAT(9273.2549f, 9273.2599f); + TEST_ASSERT_EQUAL_FLOAT(-726.93724f, -726.9374f); +#endif +} + +void testFloatsNotEqual(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT(9273.9649f, 9273.0049f); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotEqualNegative1(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT(-9273.9649f, -9273.0049f); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotEqualNegative2(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT(-9273.0049f, -9273.9649f); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotEqualActualNaN(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT(85.963f, 0.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotEqualExpectedNaN(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT(0.0f / f_zero, 85.963f); + VERIFY_FAILS_END +#endif +} + +void testFloatsEqualBothNaN(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_EQUAL_FLOAT(0.0f / f_zero, 0.0f / f_zero); +#endif +} + +void testFloatsNotEqualInfNaN(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, 0.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotEqualNaNInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT(0.0f / f_zero, 1.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotEqualActualInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT(321.642f, 1.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotEqualExpectedInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, 321.642f); + VERIFY_FAILS_END +#endif +} + +void testFloatsEqualBothInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, 1.0f / f_zero); +#endif +} + +void testFloatsNotEqualPlusMinusInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, -1.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatIsPosInf1(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_FLOAT_IS_INF(2.0f / f_zero); +#endif +} + +void testFloatIsPosInf2(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_FLOAT_IS_NOT_INF(2.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatIsNegInf1(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_FLOAT_IS_NEG_INF(-3.0f / f_zero); +#endif +} + +void testFloatIsNegInf2(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_FLOAT_IS_NOT_NEG_INF(-3.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatIsNotPosInf1(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_FLOAT_IS_INF(2.0f); + VERIFY_FAILS_END +#endif +} + +void testFloatIsNotPosInf2(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_FLOAT_IS_NOT_INF(2.0f); +#endif +} + +void testFloatIsNotNegInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_FLOAT_IS_NEG_INF(-999.876f); + VERIFY_FAILS_END +#endif +} + +void testFloatIsNan1(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_FLOAT_IS_NAN(0.0f / f_zero); +#endif +} + +void testFloatIsNan2(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_FLOAT_IS_NOT_NAN(0.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatIsNotNan1(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_FLOAT_IS_NAN(234.9f); + VERIFY_FAILS_END +#endif +} + +void testFloatIsNotNan2(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_FLOAT_IS_NOT_NAN(234.9f); +#endif +} + +void testFloatInfIsNotNan(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_FLOAT_IS_NAN(1.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatNanIsNotInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_FLOAT_IS_INF(0.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatIsDeterminate1(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_FLOAT_IS_DETERMINATE(0.0f); + TEST_ASSERT_FLOAT_IS_DETERMINATE(123.3f); + TEST_ASSERT_FLOAT_IS_DETERMINATE(-88.3f); +#endif +} + +void testFloatIsDeterminate2(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(-88.3f); + VERIFY_FAILS_END +#endif +} + +void testFloatIsNotDeterminate1(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(1.0f / f_zero); + TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(-1.0f / f_zero); + TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(0.0f / f_zero); +#endif +} + +void testFloatIsNotDeterminate2(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_FLOAT_IS_DETERMINATE(-1.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatTraitFailsOnInvalidTrait(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + UnityAssertFloatSpecial(1.0f, NULL, __LINE__, UNITY_FLOAT_INVALID_TRAIT); + VERIFY_FAILS_END +#endif +} + + +void testEqualFloatArrays(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {1.0f, -8.0f, 25.4f, -0.123f}; + float p1[] = {1.0f, -8.0f, 25.4f, -0.123f}; + float p2[] = {1.0f, -8.0f, 25.4f, -0.2f}; + float p3[] = {1.0f, -23.0f, 25.0f, -0.26f}; + + TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p3, 1); + TEST_ASSERT_EQUAL_FLOAT_ARRAY(NULL, NULL, 1); +#endif +} + +void testNotEqualFloatArraysExpectedNull(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float* p0 = NULL; + float p1[] = {1.0f, 8.0f, 25.4f, 0.252f}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualFloatArraysActualNull(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {1.0f, 8.0f, 25.4f, 0.253f}; + float* p1 = NULL; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualFloatArrays1(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {1.0f, 8.0f, 25.4f, 0.253f}; + float p1[] = {1.0f, 8.0f, 25.4f, 0.252f}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualFloatArrays2(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {1.0f, 8.0f, 25.4f, 0.253f}; + float p1[] = {2.0f, 8.0f, 25.4f, 0.253f}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualFloatArrays3(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {1.0f, 8.0f, 25.4f, 0.253f}; + float p1[] = {1.0f, 8.0f, 25.5f, 0.253f}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualFloatArraysNegative1(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {-1.0f, -8.0f, -25.4f, -0.253f}; + float p1[] = {-1.0f, -8.0f, -25.4f, -0.252f}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualFloatArraysNegative2(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {-1.0f, -8.0f, -25.4f, -0.253f}; + float p1[] = {-2.0f, -8.0f, -25.4f, -0.253f}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualFloatArraysNegative3(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {-1.0f, -8.0f, -25.4f, -0.253f}; + float p1[] = {-1.0f, -8.0f, -25.5f, -0.253f}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testEqualFloatArraysNaN(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {1.0f, 0.0f / f_zero, 25.4f, 0.253f}; + float p1[] = {1.0f, 0.0f / f_zero, 25.4f, 0.253f}; + + TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); +#endif +} + +void testEqualFloatArraysInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {1.0f, 1.0f / f_zero, 25.4f, 0.253f}; + float p1[] = {1.0f, 1.0f / f_zero, 25.4f, 0.253f}; + + TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); +#endif +} + +void testNotEqualFloatArraysLengthZero(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[1] = {0.0f}; + float p1[1] = {0.0f}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 0); + VERIFY_FAILS_END +#endif +} + +void testEqualFloatEachEqual(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {1.0f, 1.0f, 1.0f, 1.0f}; + float p1[] = {-0.123f, -0.123f, -0.123f, -0.123f}; + float p2[] = {25.4f, 25.4f, 25.4f, -0.2f}; + float p3[] = {1.0f, -23.0f, 25.0f, -0.26f}; + + TEST_ASSERT_EACH_EQUAL_FLOAT(1.0f, p0, 1); + TEST_ASSERT_EACH_EQUAL_FLOAT(1.0f, p0, 4); + TEST_ASSERT_EACH_EQUAL_FLOAT(-0.123f, p1, 4); + TEST_ASSERT_EACH_EQUAL_FLOAT(25.4f, p2, 3); + TEST_ASSERT_EACH_EQUAL_FLOAT(1.0f, p3, 1); +#endif +} + +void testNotEqualFloatEachEqualActualNull(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float* p0 = NULL; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_FLOAT(5, p0, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualFloatEachEqual1(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {0.253f, 8.0f, 0.253f, 0.253f}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_FLOAT(0.253f, p0, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualFloatEachEqual2(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {8.0f, 8.0f, 8.0f, 0.253f}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_FLOAT(8.0f, p0, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualFloatEachEqual3(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {1.0f, 1.0f, 1.0f, 0.253f}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_FLOAT(1.0f, p0, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualFloatEachEqualNegative1(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {-1.0f, -0.253f, -0.253f, -0.253f}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_FLOAT(-0.253f, p0, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualFloatEachEqualNegative2(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {-25.4f, -8.0f, -25.4f, -25.4f}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_FLOAT(-25.4f, p0, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualFloatEachEqualNegative3(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {-8.0f, -8.0f, -8.0f, -0.253f}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_FLOAT(-8.0f, p0, 4); + VERIFY_FAILS_END +#endif +} + +void testEqualFloatEachEqualNaN(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {0.0f / f_zero, 0.0f / f_zero, 0.0f / f_zero, 0.0f / f_zero}; + + TEST_ASSERT_EACH_EQUAL_FLOAT(0.0f / f_zero, p0, 4); +#endif +} + +void testEqualFloatEachEqualInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {1.0f / f_zero, 1.0f / f_zero, 25.4f, 0.253f}; + + TEST_ASSERT_EACH_EQUAL_FLOAT(1.0f / f_zero, p0, 2); +#endif +} + +void testNotEqualFloatEachEqualLengthZero(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[1] = {0.0f}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_FLOAT(0.0f, p0, 0); + VERIFY_FAILS_END +#endif +} + +#define TEST_ASSERT_EQUAL_PRINT_FLOATING(expected, actual) { \ + startPutcharSpy(); UnityPrintFloat((actual)); endPutcharSpy(); \ + TEST_ASSERT_EQUAL_STRING((expected), getBufferPutcharSpy()); \ + } + +void testFloatPrinting(void) +{ +#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_INCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY) + TEST_IGNORE(); +#else + TEST_ASSERT_EQUAL_PRINT_FLOATING("0", 0.0f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("4.99e-07", 0.000000499f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("0.1004695", 0.100469499f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("2", 1.9999995f); /*Rounding to int place*/ + TEST_ASSERT_EQUAL_PRINT_FLOATING("1", 1.0f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("1.25", 1.25f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("7.999999", 7.999999f); /*Not rounding*/ + TEST_ASSERT_EQUAL_PRINT_FLOATING("16.00002", 16.00002f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("16.00004", 16.00004f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("16.00006", 16.00006f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("9999999", 9999999.0f); /*Last full print integer*/ + + TEST_ASSERT_EQUAL_PRINT_FLOATING("-0", -0.0f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.99e-07", -0.000000499f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.1004695", -0.100469499f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-2", -1.9999995f); /*Rounding to int place*/ + TEST_ASSERT_EQUAL_PRINT_FLOATING("-1", -1.0f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-1.25", -1.25f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-7.999999", -7.999999f); /*Not rounding*/ + TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.00002", -16.00002f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.00004", -16.00004f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.00006", -16.00006f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-9999999", -9999999.0f); /*Last full print integer*/ + + /* Fails, prints "4.294968e+09" due to FP math imprecision + * TEST_ASSERT_EQUAL_PRINT_FLOATING("4.294967e+09", 4294967296.0f); */ + TEST_ASSERT_EQUAL_PRINT_FLOATING("5e+09", 5000000000.0f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("8e+09", 8.0e+09f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("8.309999e+09", 8309999104.0f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("1e+10", 1.0e+10f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("1e+10", 10000000000.0f); + /* Some compilers have trouble with inexact float constants, a float cast works generally */ + TEST_ASSERT_EQUAL_PRINT_FLOATING("1.000055e+10", (float)1.000055e+10f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("1.1e+38", (float)1.10000005e+38f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("1.635299e+10", 1.63529943e+10f); + /* Fails, prints "3.402824e+38" due to FP math imprecision + * TEST_ASSERT_EQUAL_PRINT_FLOATING("3.402823e+38", 3.40282346638e38f); */ + + TEST_ASSERT_EQUAL_PRINT_FLOATING("-1e+10", -1.0e+10f); + /* Fails, prints "-3.402824e+38" due to FP math imprecision + * TEST_ASSERT_EQUAL_PRINT_FLOATING("-3.402823e+38", -3.40282346638e38f); */ +#endif +} + +void testFloatPrintingRoundTiesToEven(void) +{ +#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_INCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY) + TEST_IGNORE(); +#else + #ifdef UNITY_ROUND_TIES_AWAY_FROM_ZERO + TEST_ASSERT_EQUAL_PRINT_FLOATING("0.0004882813", 0.00048828125f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("488281.3", 488281.25f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("5.000001e-07", 0.00000050000005f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-5.000001e-07", -0.00000050000005f); + #else /* Default to Round ties to even */ + TEST_ASSERT_EQUAL_PRINT_FLOATING("0.0004882812", 0.00048828125f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("488281.2", 488281.25f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("5e-07", 0.00000050000005f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-5e-07", -0.00000050000005f); + #endif +#endif +} + +void testFloatPrintingInfinityAndNaN(void) +{ +#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || !defined(USING_OUTPUT_SPY) + TEST_IGNORE(); +#else + TEST_ASSERT_EQUAL_PRINT_FLOATING("inf", 1.0f / f_zero); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-inf", -1.0f / f_zero); + + TEST_ASSERT_EQUAL_PRINT_FLOATING("nan", 0.0f / f_zero); +#endif +} + +#if defined(UNITY_TEST_ALL_FLOATS_PRINT_OK) && defined(USING_OUTPUT_SPY) +#ifdef UNITY_INCLUDE_DOUBLE +static void printFloatValue(float f) +{ + char expected[18]; + + startPutcharSpy(); + UnityPrintFloat(f); + + sprintf(expected, "%.9g", f); + /* We print all NaN's as "nan", not "-nan" */ + if (strcmp(expected, "-nan") == 0) strcpy(expected, "nan"); + + if (strcmp(expected, getBufferPutcharSpy())) + { + /* Fail with diagnostic printing */ + TEST_ASSERT_EQUAL_PRINT_FLOATING(expected, f); + } +} +#else +static void printFloatValue(float f) +{ + char expected[18]; + char expected_lower[18]; + char expected_lower2[18]; + char expected_lower3[18]; + char expected_higher[18]; + char expected_higher2[18]; + char expected_higher3[18]; + + startPutcharSpy(); + UnityPrintFloat(f); + + sprintf(expected, "%.7g", f); + /* We print all NaN's as "nan", not "-nan" */ + if (strcmp(expected, "-nan") == 0) strcpy(expected, "nan"); + + strcpy(expected_lower, expected); + strcpy(expected_lower2, expected); + strcpy(expected_lower3, expected); + strcpy(expected_higher, expected); + strcpy(expected_higher2, expected); + strcpy(expected_higher3, expected); + + /* Allow for rounding differences in the last digit */ + double lower = (double)f * 0.99999995; + double higher = (double)f * 1.00000005; + + if(isfinite(lower)) sprintf(expected_lower, "%.7g", lower); + if(isfinite(higher)) sprintf(expected_higher, "%.7g", higher); + + /* Outside [1,10000000] allow for relative error of +/-2.5e-7 */ + if (f < 1.0 || f > 10000000) + { + double lower2 = (double)f * 0.99999985; + double lower3 = (double)f * 0.99999975; + double higher2 = (double)f * 1.00000015; + double higher3 = (double)f * 1.00000025; + + if (isfinite(lower2)) sprintf(expected_lower2, "%.7g", lower2); + if (isfinite(lower3)) sprintf(expected_lower3, "%.7g", lower3); + if (isfinite(higher2)) sprintf(expected_higher2, "%.7g", higher2); + if (isfinite(higher3)) sprintf(expected_higher3, "%.7g", higher3); + } + + if (strcmp(expected, getBufferPutcharSpy()) != 0 && + strcmp(expected_lower, getBufferPutcharSpy()) != 0 && + strcmp(expected_lower2, getBufferPutcharSpy()) != 0 && + strcmp(expected_lower3, getBufferPutcharSpy()) != 0 && + strcmp(expected_higher, getBufferPutcharSpy()) != 0 && + strcmp(expected_higher2, getBufferPutcharSpy()) != 0 && + strcmp(expected_higher3, getBufferPutcharSpy()) != 0) + { + /* Fail with diagnostic printing */ + TEST_ASSERT_EQUAL_PRINT_FLOATING(expected, f); + } +} +#endif +#endif + +void testFloatPrintingRandomSamples(void) +{ +#if !defined(UNITY_TEST_ALL_FLOATS_PRINT_OK) || !defined(USING_OUTPUT_SPY) + TEST_IGNORE(); +#else + union { float f_value; uint32_t int_value; } u; + + /* These values are not covered by the MINSTD generator */ + u.int_value = 0x00000000; printFloatValue(u.f_value); + u.int_value = 0x80000000; printFloatValue(u.f_value); + u.int_value = 0x7fffffff; printFloatValue(u.f_value); + u.int_value = 0xffffffff; printFloatValue(u.f_value); + + uint32_t a = 1; + for(int num_tested = 0; num_tested < 1000000; num_tested++) + { + /* MINSTD pseudo-random number generator */ + a = (uint32_t)(((uint64_t)a * 48271u) % 2147483647u); + + /* MINSTD does not set the highest bit; test both possibilities */ + u.int_value = a; printFloatValue(u.f_value); + u.int_value = a | 0x80000000; printFloatValue(u.f_value); + } +#endif +} + +// ===================== THESE TEST WILL RUN IF YOUR CONFIG INCLUDES DOUBLE SUPPORT ================== + +void testDoublesWithinDelta(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + TEST_ASSERT_DOUBLE_WITHIN(0.00003, 187245.03485, 187245.03488); + TEST_ASSERT_DOUBLE_WITHIN(1.0, 187245.0, 187246.0); + TEST_ASSERT_DOUBLE_WITHIN(0.05, 9273.2549, 9273.2049); + TEST_ASSERT_DOUBLE_WITHIN(0.007, -726.93725, -726.94424); +#endif +} + +void testDoublesNotWithinDelta(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_DOUBLE_WITHIN(0.05, 9273.2649, 9273.2049); + VERIFY_FAILS_END +#endif +} + + +void testDoublesEqual(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + TEST_ASSERT_EQUAL_DOUBLE(187245123456.0, 187245123456.0); + TEST_ASSERT_EQUAL_DOUBLE(187241234567.5, 187241234567.6); + TEST_ASSERT_EQUAL_DOUBLE(9273.2512345649, 9273.25123455699); + TEST_ASSERT_EQUAL_DOUBLE(-726.12345693724, -726.1234569374); +#endif +} + +void testDoublesNotEqual(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE(9273.9649, 9273.0049); + VERIFY_FAILS_END +#endif +} + +void testDoublesNotEqualNegative1(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE(-9273.9649, -9273.0049); + VERIFY_FAILS_END +#endif +} + +void testDoublesNotEqualNegative2(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE(-9273.0049, -9273.9649); + VERIFY_FAILS_END +#endif +} + +void testDoublesNotEqualActualNaN(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE(85.963, 0.0 / d_zero); + VERIFY_FAILS_END +#endif +} + +void testDoublesNotEqualExpectedNaN(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE(0.0 / d_zero, 85.963); + VERIFY_FAILS_END +#endif +} + +void testDoublesEqualBothNaN(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + TEST_ASSERT_EQUAL_DOUBLE(0.0 / d_zero, 0.0 / d_zero); +#endif +} + +void testDoublesNotEqualInfNaN(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, 0.0 / d_zero); + VERIFY_FAILS_END +#endif +} + +void testDoublesNotEqualNaNInf(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE(0.0 / d_zero, 1.0 / d_zero); + VERIFY_FAILS_END +#endif +} + +void testDoublesNotEqualActualInf(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE(321.642, 1.0 / d_zero); + VERIFY_FAILS_END +#endif +} + +void testDoublesNotEqualExpectedInf(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, 321.642); + VERIFY_FAILS_END +#endif +} + +void testDoublesEqualBothInf(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, 1.0 / d_zero); +#endif +} + +void testDoublesNotEqualPlusMinusInf(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, -1.0 / d_zero); + VERIFY_FAILS_END +#endif +} + +void testDoubleIsPosInf1(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + TEST_ASSERT_DOUBLE_IS_INF(2.0 / d_zero); +#endif +} + +void testDoubleIsPosInf2(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_DOUBLE_IS_NOT_INF(2.0 / d_zero); + VERIFY_FAILS_END +#endif +} + +void testDoubleIsNegInf1(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + TEST_ASSERT_DOUBLE_IS_NEG_INF(-3.0 / d_zero); +#endif +} + +void testDoubleIsNegInf2(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF(-3.0 / d_zero); + VERIFY_FAILS_END +#endif +} + +void testDoubleIsNotPosInf1(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_DOUBLE_IS_INF(2.0); + VERIFY_FAILS_END +#endif +} + +void testDoubleIsNotPosInf2(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + TEST_ASSERT_DOUBLE_IS_NOT_INF(2.0); +#endif +} + +void testDoubleIsNotNegInf(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_DOUBLE_IS_NEG_INF(-999.876); + VERIFY_FAILS_END +#endif +} + +void testDoubleIsNan1(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + TEST_ASSERT_DOUBLE_IS_NAN(0.0 / d_zero); +#endif +} + +void testDoubleIsNan2(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_DOUBLE_IS_NOT_NAN(0.0 / d_zero); + VERIFY_FAILS_END +#endif +} + +void testDoubleIsNotNan1(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_DOUBLE_IS_NAN(234.9); + VERIFY_FAILS_END +#endif +} + +void testDoubleIsNotNan2(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + TEST_ASSERT_DOUBLE_IS_NOT_NAN(234.9); +#endif +} + +void testDoubleInfIsNotNan(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_DOUBLE_IS_NAN(1.0 / d_zero); + VERIFY_FAILS_END +#endif +} + +void testDoubleNanIsNotInf(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_DOUBLE_IS_INF(0.0 / d_zero); + VERIFY_FAILS_END +#endif +} + +void testDoubleIsDeterminate1(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + TEST_ASSERT_DOUBLE_IS_DETERMINATE(0.0); + TEST_ASSERT_DOUBLE_IS_DETERMINATE(123.3); + TEST_ASSERT_DOUBLE_IS_DETERMINATE(-88.3); +#endif +} + +void testDoubleIsDeterminate2(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(-88.3); + VERIFY_FAILS_END +#endif +} + +void testDoubleIsNotDeterminate1(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(1.0 / d_zero); + TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(-1.0 / d_zero); + TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(0.0 / d_zero); +#endif +} + +void testDoubleIsNotDeterminate2(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_DOUBLE_IS_DETERMINATE(-1.0 / d_zero); + VERIFY_FAILS_END +#endif +} + +void testDoubleTraitFailsOnInvalidTrait(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + UnityAssertDoubleSpecial(1.0, NULL, __LINE__, UNITY_FLOAT_INVALID_TRAIT); + VERIFY_FAILS_END +#endif +} + +void testEqualDoubleArrays(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {1.0, -8.0, 25.4, -0.123}; + double p1[] = {1.0, -8.0, 25.4, -0.123}; + double p2[] = {1.0, -8.0, 25.4, -0.2}; + double p3[] = {1.0, -23.0, 25.0, -0.26}; + + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p3, 1); + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(NULL, NULL, 1); +#endif +} + +void testNotEqualDoubleArraysExpectedNull(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double* p0 = NULL; + double p1[] = {1.0, 8.0, 25.4, 0.252}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualDoubleArraysActualNull(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {1.0, 8.0, 25.4, 0.253}; + double* p1 = NULL; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualDoubleArrays1(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {1.0, 8.0, 25.4, 0.25666666667}; + double p1[] = {1.0, 8.0, 25.4, 0.25666666666}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualDoubleArrays2(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {1.0, 8.0, 25.4, 0.253}; + double p1[] = {2.0, 8.0, 25.4, 0.253}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualDoubleArrays3(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {1.0, 8.0, 25.4, 0.253}; + double p1[] = {1.0, 8.0, 25.5, 0.253}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualDoubleArraysNegative1(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {-1.0, -8.0, -25.4, -0.2566666667}; + double p1[] = {-1.0, -8.0, -25.4, -0.2566666666}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualDoubleArraysNegative2(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {-1.0, -8.0, -25.4, -0.253}; + double p1[] = {-2.0, -8.0, -25.4, -0.253}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualDoubleArraysNegative3(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {-1.0, -8.0, -25.4, -0.253}; + double p1[] = {-1.0, -8.0, -25.5, -0.253}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testEqualDoubleArraysNaN(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {1.0, 0.0 / d_zero, 25.4, 0.253}; + double p1[] = {1.0, 0.0 / d_zero, 25.4, 0.253}; + + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); +#endif +} + +void testEqualDoubleArraysInf(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {1.0, 1.0 / d_zero, 25.4, 0.253}; + double p1[] = {1.0, 1.0 / d_zero, 25.4, 0.253}; + + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); +#endif +} + +void testNotEqualDoubleArraysLengthZero(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[1] = {0.0}; + double p1[1] = {0.0}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 0); + VERIFY_FAILS_END +#endif +} + +void testEqualDoubleEachEqual(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {1.0, 1.0, 1.0, 1.0}; + double p1[] = {-0.123, -0.123, -0.123, -0.123}; + double p2[] = {25.4, 25.4, 25.4, -0.2}; + double p3[] = {1.0, -23.0, 25.0, -0.26}; + + TEST_ASSERT_EACH_EQUAL_DOUBLE(1.0, p0, 1); + TEST_ASSERT_EACH_EQUAL_DOUBLE(1.0, p0, 4); + TEST_ASSERT_EACH_EQUAL_DOUBLE(-0.123, p1, 4); + TEST_ASSERT_EACH_EQUAL_DOUBLE(25.4, p2, 3); + TEST_ASSERT_EACH_EQUAL_DOUBLE(1.0, p3, 1); +#endif +} + +void testNotEqualDoubleEachEqualActualNull(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double* p0 = NULL; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_DOUBLE(5, p0, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualDoubleEachEqual1(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {0.253, 8.0, 0.253, 0.253}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_DOUBLE(0.253, p0, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualDoubleEachEqual2(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {8.0, 8.0, 8.0, 0.253}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_DOUBLE(8.0, p0, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualDoubleEachEqual3(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {1.0, 1.0, 1.0, 0.253}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_DOUBLE(1.0, p0, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualDoubleEachEqualNegative1(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {-1.0, -0.253, -0.253, -0.253}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_DOUBLE(-0.253, p0, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualDoubleEachEqualNegative2(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {-25.4, -8.0, -25.4, -25.4}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_DOUBLE(-25.4, p0, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualDoubleEachEqualNegative3(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {-8.0, -8.0, -8.0, -0.253}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_DOUBLE(-8.0, p0, 4); + VERIFY_FAILS_END +#endif +} + +void testEqualDoubleEachEqualNaN(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {0.0 / d_zero, 0.0 / d_zero, 0.0 / d_zero, 0.0 / d_zero}; + + TEST_ASSERT_EACH_EQUAL_DOUBLE(0.0 / d_zero, p0, 4); +#endif +} + +void testEqualDoubleEachEqualInf(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {1.0 / d_zero, 1.0 / d_zero, 25.4, 0.253}; + + TEST_ASSERT_EACH_EQUAL_DOUBLE(1.0 / d_zero, p0, 2); +#endif +} + +void testNotEqualDoubleEachEqualLengthZero(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[1] = {0.0}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_DOUBLE(0.0, p0, 0); + VERIFY_FAILS_END +#endif +} + +void testDoublePrinting(void) +{ +#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_EXCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY) + TEST_IGNORE(); +#else + TEST_ASSERT_EQUAL_PRINT_FLOATING("0", 0.0); + TEST_ASSERT_EQUAL_PRINT_FLOATING("4.99e-07", 0.000000499); + TEST_ASSERT_EQUAL_PRINT_FLOATING("5.0000005e-07", 0.00000050000005); + TEST_ASSERT_EQUAL_PRINT_FLOATING("0.100469499", 0.100469499); + TEST_ASSERT_EQUAL_PRINT_FLOATING("1", 0.9999999995); /*Rounding to int place*/ + TEST_ASSERT_EQUAL_PRINT_FLOATING("1", 1.0); + TEST_ASSERT_EQUAL_PRINT_FLOATING("1.25", 1.25); + TEST_ASSERT_EQUAL_PRINT_FLOATING("7.99999999", 7.99999999); /*Not rounding*/ + TEST_ASSERT_EQUAL_PRINT_FLOATING("16.0000002", 16.0000002); + TEST_ASSERT_EQUAL_PRINT_FLOATING("16.0000004", 16.0000004); + TEST_ASSERT_EQUAL_PRINT_FLOATING("16.0000006", 16.0000006); + TEST_ASSERT_EQUAL_PRINT_FLOATING("999999999", 999999999.0); /*Last full print integer*/ + + TEST_ASSERT_EQUAL_PRINT_FLOATING("-0", -0.0); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.99e-07", -0.000000499); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-5.0000005e-07", -0.00000050000005); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.100469499", -0.100469499); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-1", -0.9999999995); /*Rounding to int place*/ + TEST_ASSERT_EQUAL_PRINT_FLOATING("-1", -1.0); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-1.25", -1.25); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-7.99999999", -7.99999999); /*Not rounding*/ + TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.0000002", -16.0000002); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.0000004", -16.0000004); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.0000006", -16.0000006); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-999999999", -999999999.0); /*Last full print integer*/ + + TEST_ASSERT_EQUAL_PRINT_FLOATING("0.1004695", 0.10046949999999999); + TEST_ASSERT_EQUAL_PRINT_FLOATING("4.2949673e+09", 4294967295.9); + TEST_ASSERT_EQUAL_PRINT_FLOATING("4.2949673e+09", 4294967296.0); + TEST_ASSERT_EQUAL_PRINT_FLOATING("1e+10", 9999999995.0); + TEST_ASSERT_EQUAL_PRINT_FLOATING("9.00719925e+15", 9007199254740990.0); + TEST_ASSERT_EQUAL_PRINT_FLOATING("7e+100", 7.0e+100); + TEST_ASSERT_EQUAL_PRINT_FLOATING("3e+200", 3.0e+200); + TEST_ASSERT_EQUAL_PRINT_FLOATING("9.23456789e+300", 9.23456789e+300); + + TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.1004695", -0.10046949999999999); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.2949673e+09", -4294967295.9); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.2949673e+09", -4294967296.0); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-7e+100", -7.0e+100); +#endif +} + +void testDoublePrintingRoundTiesToEven(void) +{ +#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_EXCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY) + TEST_IGNORE(); +#else + #ifdef UNITY_ROUND_TIES_AWAY_FROM_ZERO + TEST_ASSERT_EQUAL_PRINT_FLOATING("1.00000001e+10", 10000000050.0); + TEST_ASSERT_EQUAL_PRINT_FLOATING("9.00719925e+15", 9007199245000000.0); + #else /* Default to Round ties to even */ + TEST_ASSERT_EQUAL_PRINT_FLOATING("1e+10", 10000000050.0); + TEST_ASSERT_EQUAL_PRINT_FLOATING("9.00719924e+15", 9007199245000000.0); + #endif +#endif +} + +void testDoublePrintingInfinityAndNaN(void) +{ +#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_EXCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY) + TEST_IGNORE(); +#else + TEST_ASSERT_EQUAL_PRINT_FLOATING("inf", 1.0 / d_zero); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-inf", -1.0 / d_zero); + + TEST_ASSERT_EQUAL_PRINT_FLOATING("nan", 0.0 / d_zero); +#endif +} + +// ===================== THESE TEST WILL RUN IF YOUR CONFIG INCLUDES DETAIL SUPPORT ================== + +void testThatDetailsCanBeHandleOneDetail(void) +{ +#ifdef UNITY_EXCLUDE_DETAILS + TEST_IGNORE(); +#else + UNITY_SET_DETAIL("Detail1"); + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT_MESSAGE(5, 6, "Should Fail And Say Detail1"); + VERIFY_FAILS_END +#endif +} + +void testThatDetailsCanHandleTestFail(void) +{ +#ifdef UNITY_EXCLUDE_DETAILS + TEST_IGNORE(); +#else + UNITY_SET_DETAILS("Detail1","Detail2"); + + EXPECT_ABORT_BEGIN + TEST_FAIL_MESSAGE("Should Fail And Say Detail1 and Detail2"); + VERIFY_FAILS_END +#endif +} + +void testThatDetailsCanBeHandleTwoDetails(void) +{ +#ifdef UNITY_EXCLUDE_DETAILS + TEST_IGNORE(); +#else + UNITY_SET_DETAILS("Detail1","Detail2"); + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX8_MESSAGE(7, 8, "Should Fail And Say Detail1 and Detail2"); + VERIFY_FAILS_END +#endif +} + +void testThatDetailsCanBeHandleSingleDetailClearingTwoDetails(void) +{ +#ifdef UNITY_EXCLUDE_DETAILS + TEST_IGNORE(); +#else + UNITY_SET_DETAILS("Detail1","Detail2"); + UNITY_SET_DETAIL("DetailNew"); + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING_MESSAGE("MEH", "GUH", "Should Fail And Say DetailNew"); + VERIFY_FAILS_END +#endif +}