New unity component can be used for testing other applications.
Upstream version of Unity is included as a submodule.
Utilities specific to ESP-IDF unit tests (partitions, leak checking
setup/teardown functions, etc) are kept only in unit-test-app.
Kconfig options are added to allow disabling certain Unity features.
[submodule "components/protobuf-c/protobuf-c"]
path = components/protobuf-c/protobuf-c
url = https://github.com/protobuf-c/protobuf-c
+[submodule "components/unity/unity"]
+ path = components/unity/unity
+ url = https://github.com/ThrowTheSwitch/Unity
set(COMPONENT_SRCDIRS ".")
set(COMPONENT_ADD_INCLUDEDIRS ".")
-set(COMPONENT_REQUIRES unity app_update bootloader_support nvs_flash)
+set(COMPONENT_REQUIRES unity test_utils app_update bootloader_support nvs_flash)
register_component()
\ No newline at end of file
set(COMPONENT_SRCDIRS ".")
set(COMPONENT_ADD_INCLUDEDIRS ".")
-set(COMPONENT_REQUIRES unity driver nvs_flash)
+set(COMPONENT_REQUIRES unity test_utils driver nvs_flash)
register_component()
\ No newline at end of file
#include "freertos/ringbuf.h"
#include "soc/gpio_periph.h"
#include "sdkconfig.h"
-#include "unity_config.h"
+#include "test_utils.h"
const static char TAG[] = "test_spi";
}
-//TODO: add a case when a non-polling transaction happened in the bus-acquiring time and then release the bus then queue a new trans
\ No newline at end of file
+//TODO: add a case when a non-polling transaction happened in the bus-acquiring time and then release the bus then queue a new trans
// limitations under the License.
#pragma once
+#include <stdint.h>
/**
* @file esp_clk.h
set(COMPONENT_SRCDIRS ".")
set(COMPONENT_ADD_INCLUDEDIRS ". ${CMAKE_CURRENT_BINARY_DIR}")
-set(COMPONENT_REQUIRES unity nvs_flash ulp)
+set(COMPONENT_REQUIRES unity test_utils nvs_flash ulp)
register_component()
#include "freertos/xtensa_timer.h"
#include "soc/cpu.h"
#include "unity.h"
+#include "test_utils.h"
#include "rom/uart.h"
#include "rom/sha.h"
#include "soc/uart_reg.h"
#include "freertos/xtensa_timer.h"
#include "soc/cpu.h"
#include "unity.h"
+#include "test_utils.h"
#include "rom/uart.h"
#include "soc/uart_reg.h"
#include "soc/dport_reg.h"
#include "soc/rtc.h"
+
#define MHZ (1000000)
static volatile bool exit_flag;
static bool dport_test_result;
#include "soc/soc.h" // for direct register read macros
#include "rom/rtc.h"
#include "esp_newlib.h"
+#include "test_utils.h"
#define ESP_EXT0_WAKEUP_LEVEL_LOW 0
#define ESP_EXT0_WAKEUP_LEVEL_HIGH 1
set(COMPONENT_SRCDIRS ".")
set(COMPONENT_PRIV_INCLUDEDIRS "../private_include" ".")
-set(COMPONENT_PRIV_REQUIRES unity esp_event)
+set(COMPONENT_PRIV_REQUIRES unity test_utils esp_event)
register_component()
\ No newline at end of file
#include "sdkconfig.h"
#include "unity.h"
-#include "idf_performance.h"
+#include "test_utils.h"
static const char* TAG = "test_event";
set(COMPONENT_SRCDIRS ".")
set(COMPONENT_ADD_INCLUDEDIRS ".")
-set(COMPONENT_REQUIRES unity esp_http_server)
+set(COMPONENT_REQUIRES unity test_utils esp_http_server)
register_component()
set(COMPONENT_SRCDIRS ".")
set(COMPONENT_ADD_INCLUDEDIRS ".")
-set(COMPONENT_REQUIRES unity)
+set(COMPONENT_REQUIRES unity test_utils)
register_component()
#include "driver/timer.h"
#include "esp_spi_flash.h"
#include "unity.h"
+#include "test_utils.h"
//Definitions used in multiple test cases
#define TIMEOUT_TICKS 10
set(COMPONENT_SRCDIRS ".")
set(COMPONENT_ADD_INCLUDEDIRS ".")
-set(COMPONENT_REQUIRES unity vfs fatfs)
+set(COMPONENT_REQUIRES unity test_utils vfs fatfs)
set(COMPONENT_EMBED_TXTFILES fatfs.img)
set(COMPONENT_SRCDIRS ".")
set(COMPONENT_ADD_INCLUDEDIRS ".")
-set(COMPONENT_REQUIRES unity)
+set(COMPONENT_REQUIRES unity test_utils)
register_component()
\ No newline at end of file
#include "freertos/semphr.h"
#include "freertos/event_groups.h"
#include "unity.h"
+#include "test_utils.h"
/* ---------------------Test 1: Backported Timer functions-----------------------
* Test xTimerCreateStatic(), vTimerSetTimerId(), xTimerGetPeriod(), xTimerGetExpiryTime()
#include "freertos/semphr.h"
#include "freertos/queue.h"
#include "unity.h"
+#include "test_utils.h"
#if (CONFIG_FREERTOS_QUEUE_REGISTRY_SIZE > 0)
#define NO_OF_QUEUES_PER_CORE ((int)((CONFIG_FREERTOS_QUEUE_REGISTRY_SIZE - 3)/portNUM_PROCESSORS)) //Save space for some preallocated tasks
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "unity.h"
+#include "test_utils.h"
#define TSK_PRIORITY (UNITY_FREERTOS_PRIORITY + 1)
#include "rom/ets_sys.h"
#include "unity.h"
+#include "test_utils.h"
#define NO_OF_TSKS 3
#define DELAY_TICKS 2
#include "driver/timer.h"
#include "esp_ipc.h"
#include "unity.h"
+#include "test_utils.h"
#define NO_OF_NOTIFS 4
#define NO_OF_TASKS 2 //Sender and receiver
#include "freertos/semphr.h"
#include "freertos/event_groups.h"
#include "unity.h"
+#include "test_utils.h"
#ifdef CONFIG_FREERTOS_USE_TRACE_FACILITY
#define TSK_PRIORITY (UNITY_FREERTOS_PRIORITY + 1)
#include "freertos/xtensa_api.h"
#include "unity.h"
#include "soc/cpu.h"
+#include "test_utils.h"
static volatile bool trigger;
static volatile bool flag;
#include "soc/io_mux_reg.h"
#include "soc/cpu.h"
-#include "idf_performance.h"
+#include "test_utils.h"
#define REPEAT_OPS 10000
#include "freertos/xtensa_api.h"
#include "unity.h"
#include "soc/cpu.h"
+#include "test_utils.h"
#include "driver/timer.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "unity.h"
+#include "test_utils.h"
static void counter_task(void *param)
#include "freertos/xtensa_api.h"
#include "unity.h"
#include "soc/cpu.h"
+#include "test_utils.h"
#include "driver/timer.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "unity.h"
+#include "test_utils.h"
#include "sdkconfig.h"
static __thread int tl_test_var1;
set(COMPONENT_SRCDIRS ".")
set(COMPONENT_ADD_INCLUDEDIRS ".")
-set(COMPONENT_REQUIRES unity)
+set(COMPONENT_REQUIRES unity test_utils)
register_component()
\ No newline at end of file
-
-/* @brief macro to print IDF performance
- * @param mode : performance item name. a string pointer.
- * @param value_fmt: print format and unit of the value, for example: "%02fms", "%dKB"
- * @param value : the performance value.
-*/
-#define IDF_LOG_PERFORMANCE(item, value_fmt, value) \
- printf("[Performance][%s]: "value_fmt"\n", item, value)
-
+#pragma once
/* declare the performance here */
#define IDF_PERFORMANCE_MAX_HTTPS_REQUEST_BIN_SIZE 800
set(COMPONENT_SRCDIRS ".")
set(COMPONENT_ADD_INCLUDEDIRS ".")
-set(COMPONENT_REQUIRES unity mbedtls)
+set(COMPONENT_REQUIRES unity test_utils mbedtls)
register_component()
\ No newline at end of file
#include "freertos/task.h"
#include "soc/uart_reg.h"
#include "test_apb_dport_access.h"
+#include "test_utils.h"
#ifndef CONFIG_FREERTOS_UNICORE
set(COMPONENT_SRCDIRS ".")
set(COMPONENT_ADD_INCLUDEDIRS ".")
-set(COMPONENT_REQUIRES unity)
+set(COMPONENT_REQUIRES unity test_utils)
register_component()
\ No newline at end of file
#include "soc/rtc.h"
#include "esp_clk.h"
#include "esp_system.h"
+#include "test_utils.h"
#if portNUM_PROCESSORS == 2
set(COMPONENT_SRCDIRS ".")
set(COMPONENT_ADD_INCLUDEDIRS ".")
-set(COMPONENT_REQUIRES unity nvs_flash bootloader_support)
+set(COMPONENT_REQUIRES unity test_utils nvs_flash bootloader_support)
register_component()
set(COMPONENT_SRCDIRS ".")
set(COMPONENT_ADD_INCLUDEDIRS ".")
-set(COMPONENT_REQUIRES unity)
+set(COMPONENT_REQUIRES unity test_utils)
register_component()
\ No newline at end of file
set(COMPONENT_SRCDIRS ".")
set(COMPONENT_ADD_INCLUDEDIRS ".")
-set(COMPONENT_REQUIRES unity pthread)
+set(COMPONENT_REQUIRES unity test_utils pthread)
register_component()
\ No newline at end of file
#include "unity.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
+#include "test_utils.h"
TEST_CASE("pthread local storage basics", "[pthread]")
{
set(COMPONENT_SRCDIRS "../${SOC_NAME}/test")
set(COMPONENT_ADD_INCLUDEDIRS "../${SOC_NAME}/test")
- set(COMPONENT_REQUIRES unity)
+ set(COMPONENT_REQUIRES unity test_utils)
register_component()
endif()
set(COMPONENT_SRCDIRS ".")
set(COMPONENT_ADD_INCLUDEDIRS ".")
-set(COMPONENT_REQUIRES unity spi_flash bootloader_support app_update)
+set(COMPONENT_REQUIRES unity test_utils spi_flash bootloader_support app_update)
register_component()
\ No newline at end of file
#include <esp_attr.h>
#include "driver/timer.h"
#include "esp_intr_alloc.h"
+#include "test_utils.h"
struct flash_test_ctx {
uint32_t offset;
set(COMPONENT_SRCDIRS ".")
set(COMPONENT_ADD_INCLUDEDIRS ".")
-set(COMPONENT_REQUIRES unity spiffs)
+set(COMPONENT_REQUIRES unity test_utils spiffs)
register_component()
\ No newline at end of file
--- /dev/null
+set(COMPONENT_SRCS "unity/src/unity.c"
+ "unity_port_esp32.c")
+
+set(COMPONENT_ADD_INCLUDEDIRS "include"
+ "unity/src")
+
+if(CONFIG_UNITY_ENABLE_IDF_TEST_RUNNER)
+ list(APPEND COMPONENT_SRCS "unity_runner.c")
+endif()
+
+if(CONFIG_UNITY_ENABLE_FIXTURE)
+ list(APPEND COMPONENT_SRCS "unity/extras/fixture/src/unity_fixture.c")
+endif()
+
+register_component()
+
+target_compile_definitions(unity PUBLIC
+ -DUNITY_INCLUDE_CONFIG_H
+)
+
+if(GCC_NOT_5_2_0)
+ component_compile_options(-Wno-unused-const-variable)
+endif()
--- /dev/null
+menu "Unity unit testing library"
+
+config UNITY_ENABLE_FLOAT
+bool "Support for float type"
+default y
+help
+ If not set, assertions on float arguments will not be available.
+
+
+config UNITY_ENABLE_DOUBLE
+bool "Support for double type"
+default y
+help
+ If not set, assertions on double arguments will not be available.
+
+config UNITY_ENABLE_COLOR
+bool "Colorize test output"
+default n
+help
+ If set, Unity will colorize test results using console escape sequences.
+
+
+config UNITY_ENABLE_IDF_TEST_RUNNER
+bool "Include ESP-IDF test registration/running helpers"
+default y
+help
+ If set, then the following features will be available:
+
+ - TEST_CASE macro which performs automatic registration of test functions
+ - Functions to run registered test functions: unity_run_all_tests,
+ unity_run_tests_with_filter, unity_run_single_test_by_name.
+ - Interactive menu which lists test cases and allows choosing the tests to
+ be run, available via unity_run_menu function.
+
+ Disable if a different test registration mechanism is used.
+
+config UNITY_ENABLE_FIXTURE
+bool "Include Unity test fixture"
+default n
+help
+ If set, unity_fixture.h header file and associated source files are part of
+ the build. These provide an optional set of macros and functions to
+ implement test groups.
+
+endmenu # "Unity unit testing library"
--- /dev/null
+CPPFLAGS += -DUNITY_INCLUDE_CONFIG_H
--- /dev/null
+#
+# Component Makefile
+#
+
+ifeq ($(GCC_NOT_5_2_0), 1)
+unity/src/unity.o: CFLAGS += -Wno-unused-const-variable
+endif
+
+COMPONENT_ADD_INCLUDEDIRS = include unity/src
+COMPONENT_SRCDIRS = unity/src .
+
+ifndef CONFIG_UNITY_ENABLE_IDF_TEST_RUNNER
+COMPONENT_OBJEXCLUDE += unity_runner.o
+endif
+
+ifdef CONFIG_UNITY_ENABLE_FIXTURE
+COMPONENT_SRCDIRS += unity/extras/fixture/src
+COMPONENT_ADD_INCLUDEDIRS += unity/extras/fixture/src
+endif
+
+COMPONENT_SUBMODULES := unity
--- /dev/null
+#ifndef UNITY_CONFIG_H
+#define UNITY_CONFIG_H
+
+// This file gets included from unity.h via unity_internals.h
+// It is inside #ifdef __cplusplus / extern "C" block, so we can
+// only use C features here
+
+#include <esp_err.h>
+#include <stddef.h>
+#include "sdkconfig.h"
+
+#ifdef CONFIG_UNITY_ENABLE_FLOAT
+#define UNITY_INCLUDE_FLOAT
+#else
+#define UNITY_EXCLUDE_FLOAT
+#endif //CONFIG_UNITY_ENABLE_FLOAT
+
+#ifdef CONFIG_UNITY_ENABLE_DOUBLE
+#define UNITY_INCLUDE_DOUBLE
+#else
+#define UNITY_EXCLUDE_DOUBLE
+#endif //CONFIG_UNITY_ENABLE_DOUBLE
+
+#ifdef CONFIG_UNITY_ENABLE_COLOR
+#define UNITY_OUTPUT_COLOR
+#endif
+
+#define UNITY_EXCLUDE_TIME_H
+
+void unity_flush(void);
+void unity_putc(int c);
+void unity_gets(char* dst, size_t len);
+void unity_exec_time_start(void);
+void unity_exec_time_stop(void);
+uint32_t unity_exec_time_get_ms(void);
+
+#define UNITY_OUTPUT_CHAR(a) unity_putc(a)
+#define UNITY_OUTPUT_FLUSH() unity_flush()
+#define UNITY_EXEC_TIME_START() unity_exec_time_start()
+#define UNITY_EXEC_TIME_STOP() unity_exec_time_stop()
+#define UNITY_EXEC_TIME_MS() unity_exec_time_get_ms()
+
+#ifdef CONFIG_UNITY_ENABLE_TEST_RUNNER
+
+#include "unity_test_case.h"
+
+void unity_run_menu() __attribute__((noreturn));
+
+void unity_run_tests_with_filter(const char* filter);
+
+void unity_run_all_tests();
+
+void unity_run_single_test_by_name(const char* name);
+
+#endif //CONFIG_UNITY_ENABLE_TEST_RUNNER
+
+// shorthand to check esp_err_t return code
+#define TEST_ESP_OK(rc) TEST_ASSERT_EQUAL_HEX32(ESP_OK, rc)
+#define TEST_ESP_ERR(err, rc) TEST_ASSERT_EQUAL_HEX32(err, rc)
+
+#endif //UNITY_CONFIG_H
-#ifndef UNITY_CONFIG_H
-#define UNITY_CONFIG_H
-
-// This file gets included from unity.h via unity_internals.h
+// Copyright 2016-2018 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#pragma once
+
+#include <stdint.h>
+
+// This file gets included from unity.h via unity_internals.h via unity_config.h
// It is inside #ifdef __cplusplus / extern "C" block, so we can
// only use C features here
-// Adapt Unity to our environment, disable FP support
-
-#include <esp_err.h>
-#include <sdkconfig.h>
-
-/* Some definitions applicable to Unity running in FreeRTOS */
-#define UNITY_FREERTOS_PRIORITY CONFIG_UNITY_FREERTOS_PRIORITY
-#define UNITY_FREERTOS_CPU CONFIG_UNITY_FREERTOS_CPU
-#define UNITY_FREERTOS_STACK_SIZE CONFIG_UNITY_FREERTOS_STACK_SIZE
-
-#define UNITY_EXCLUDE_FLOAT
-#define UNITY_EXCLUDE_DOUBLE
-
-#define UNITY_OUTPUT_CHAR unity_putc
-#define UNITY_OUTPUT_FLUSH unity_flush
-
// Define helpers to register test cases from multiple files
#define UNITY_EXPAND2(a, b) a ## b
#define UNITY_EXPAND(a, b) UNITY_EXPAND2(a, b)
void unity_testcase_register(struct test_desc_t* desc);
-void unity_run_menu() __attribute__((noreturn));
-
-void unity_run_tests_with_filter(const char* filter);
-
-void unity_run_all_tests();
/* Test case macro, a-la CATCH framework.
- First argument is a free-form description,
- second argument is (by convention) a list of identifiers, each one in square brackets.
- Identifiers are used to group related tests, or tests with specific properties.
+ First argument is a free-form description,
+ second argument is (by convention) a list of identifiers, each one in square brackets.
+ Identifiers are used to group related tests, or tests with specific properties.
Use like:
- TEST_CASE("Frobnicator forbnicates", "[frobnicator][rom]")
- {
- // test goes here
- }
+ TEST_CASE("Frobnicator forbnicates", "[frobnicator][rom]")
+ {
+ // test goes here
+ }
*/
#define TEST_CASE(name_, desc_) \
* field names are treated as annotations and don't affect initialization
* order. Also make sure all the fields are initialized.
*/
-
-// shorthand to check esp_err_t return code
-#define TEST_ESP_OK(rc) TEST_ASSERT_EQUAL_HEX32(ESP_OK, rc)
-#define TEST_ESP_ERR(err, rc) TEST_ASSERT_EQUAL_HEX32(err, rc)
-
-
-#endif //UNITY_CONFIG_H
--- /dev/null
+Subproject commit 7d2bf62b7e6afaf38153041a9d53c21aeeca9a25
--- /dev/null
+// Copyright 2016-2018 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#include <string.h>
+#include "unity.h"
+#include "sdkconfig.h"
+#include "rom/uart.h"
+#include "esp_clk.h"
+#include "soc/cpu.h"
+
+static uint32_t s_test_start, s_test_stop;
+
+void unity_putc(int c)
+{
+ if (c == '\n') {
+ uart_tx_one_char('\r');
+ uart_tx_one_char('\n');
+ } else if (c == '\r') {
+ } else {
+ uart_tx_one_char(c);
+ }
+}
+
+void unity_flush()
+{
+ uart_tx_wait_idle(CONFIG_CONSOLE_UART_NUM);
+}
+
+void unity_gets(char *dst, size_t len)
+{
+ /* UartRxString length argument is uint8_t */
+ if (len >= UINT8_MAX) {
+ len = UINT8_MAX;
+ }
+ /* Flush anything already in the RX buffer */
+ uint8_t ignore;
+ while (uart_rx_one_char(&ignore) == OK) {
+ }
+ /* Read input */
+ UartRxString((uint8_t *) dst, len);
+}
+
+void unity_exec_time_start(void)
+{
+ RSR(CCOUNT, s_test_start);
+}
+
+void unity_exec_time_stop(void)
+{
+ RSR(CCOUNT, s_test_stop);
+}
+
+uint32_t unity_exec_time_get_ms(void)
+{
+ return (s_test_stop - s_test_start) / (esp_clk_cpu_freq() / 1000);
+}
+// Copyright 2016-2018 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <stdio.h>
-#include "unity.h"
-#include "rom/ets_sys.h"
-#include "rom/uart.h"
-#include "freertos/FreeRTOS.h"
-#include "freertos/task.h"
-#include "esp_log.h"
#include "esp_clk.h"
#include "soc/cpu.h"
-#include "esp_heap_caps.h"
-#include "test_utils.h"
+#include "unity.h"
-#ifdef CONFIG_HEAP_TRACING
-#include "esp_heap_trace.h"
-#endif
// Pointers to the head and tail of linked list of test description structs:
static struct test_desc_t* s_unity_tests_first = NULL;
// Inverse of the filter
static bool s_invert = false;
-
-static size_t before_free_8bit;
-static size_t before_free_32bit;
-
-/* Each unit test is allowed to "leak" this many bytes.
-
- TODO: Make this value editable by the test.
-
- Will always need to be some value here, as fragmentation can reduce free space even when no leak is occuring.
-*/
-const size_t WARN_LEAK_THRESHOLD = 256;
-const size_t CRITICAL_LEAK_THRESHOLD = 4096;
-
-void unity_reset_leak_checks(void)
-{
- before_free_8bit = heap_caps_get_free_size(MALLOC_CAP_8BIT);
- before_free_32bit = heap_caps_get_free_size(MALLOC_CAP_32BIT);
-
-#ifdef CONFIG_HEAP_TRACING
- heap_trace_start(HEAP_TRACE_LEAKS);
-#endif
-}
-
-/* setUp runs before every test */
-void setUp(void)
-{
-// If heap tracing is enabled in kconfig, leak trace the test
-#ifdef CONFIG_HEAP_TRACING
- const size_t num_heap_records = 80;
- static heap_trace_record_t *record_buffer;
- if (!record_buffer) {
- record_buffer = malloc(sizeof(heap_trace_record_t) * num_heap_records);
- assert(record_buffer);
- heap_trace_init_standalone(record_buffer, num_heap_records);
- }
-#endif
-
- printf("%s", ""); /* sneakily lazy-allocate the reent structure for this test task */
- get_test_data_partition(); /* allocate persistent partition table structures */
-
- unity_reset_leak_checks();
-}
-
-static void check_leak(size_t before_free, size_t after_free, const char *type)
-{
- if (before_free <= after_free) {
- return;
- }
- size_t leaked = before_free - after_free;
- if (leaked < WARN_LEAK_THRESHOLD) {
- return;
- }
-
- printf("MALLOC_CAP_%s %s leak: Before %u bytes free, After %u bytes free (delta %u)\n",
- type,
- leaked < CRITICAL_LEAK_THRESHOLD ? "potential" : "critical",
- before_free, after_free, leaked);
- fflush(stdout);
- TEST_ASSERT_MESSAGE(leaked < CRITICAL_LEAK_THRESHOLD, "The test leaked too much memory");
-}
-
-/* tearDown runs after every test */
-void tearDown(void)
-{
- /* some FreeRTOS stuff is cleaned up by idle task */
- vTaskDelay(5);
-
- /* We want the teardown to have this file in the printout if TEST_ASSERT fails */
- const char *real_testfile = Unity.TestFile;
- Unity.TestFile = __FILE__;
-
- /* check if unit test has caused heap corruption in any heap */
- TEST_ASSERT_MESSAGE( heap_caps_check_integrity(MALLOC_CAP_INVALID, true), "The test has corrupted the heap");
-
- /* check for leaks */
-#ifdef CONFIG_HEAP_TRACING
- heap_trace_stop();
- heap_trace_dump();
-#endif
- size_t after_free_8bit = heap_caps_get_free_size(MALLOC_CAP_8BIT);
- size_t after_free_32bit = heap_caps_get_free_size(MALLOC_CAP_32BIT);
-
- check_leak(before_free_8bit, after_free_8bit, "8BIT");
- check_leak(before_free_32bit, after_free_32bit, "32BIT");
-
- Unity.TestFile = real_testfile; // go back to the real filename
-}
-
-void unity_putc(int c)
-{
- if (c == '\n')
- {
- uart_tx_one_char('\r');
- uart_tx_one_char('\n');
- }
- else if (c == '\r')
- {
- }
- else
- {
- uart_tx_one_char(c);
- }
-}
-
-void unity_flush()
-{
- uart_tx_wait_idle(0); // assume that output goes to UART0
-}
-
void unity_testcase_register(struct test_desc_t* desc)
{
if (!s_unity_tests_first)
print_multiple_function_test_menu(test_ms);
while(strlen(cmdline) == 0)
{
- /* Flush anything already in the RX buffer */
- while(uart_rx_one_char((uint8_t *) cmdline) == OK) {
-
- }
- UartRxString((uint8_t*) cmdline, sizeof(cmdline) - 1);
+ unity_gets(cmdline, sizeof(cmdline));
if(strlen(cmdline) == 0) {
/* if input was newline, print a new menu */
print_multiple_function_test_menu(test_ms);
printf("Running %s...\n", test->name);
// Unit test runner expects to see test name before the test starts
fflush(stdout);
- uart_tx_wait_idle(CONFIG_CONSOLE_UART_NUM);
+ unity_flush();
Unity.TestFile = test->file;
Unity.CurrentDetail1 = test->desc;
}
}
-static void unity_run_single_test_by_name(const char* filter)
+void unity_run_single_test_by_name(const char* filter)
{
if (s_invert)
{
char cmdline[256] = { 0 };
while(strlen(cmdline) == 0)
{
- /* Flush anything already in the RX buffer */
- while(uart_rx_one_char((uint8_t *) cmdline) == OK) {
- }
- /* Read input */
- UartRxString((uint8_t*) cmdline, sizeof(cmdline) - 1);
+ unity_gets(cmdline, sizeof(cmdline));
trim_trailing_space(cmdline);
if(strlen(cmdline) == 0) {
/* if input was newline, print a new menu */
set(COMPONENT_SRCDIRS ".")
set(COMPONENT_ADD_INCLUDEDIRS ".")
-set(COMPONENT_REQUIRES unity vfs fatfs spiffs)
+set(COMPONENT_REQUIRES unity test_utils vfs fatfs spiffs)
register_component()
\ No newline at end of file
#include "esp_vfs.h"
#include "unity.h"
#include "esp_log.h"
+#include "test_utils.h"
#define VFS_PREF1 "/vfs1"
#define VFS_PREF2 "/vfs2"
set(COMPONENT_SRCDIRS ".")
set(COMPONENT_ADD_INCLUDEDIRS ".")
-set(COMPONENT_REQUIRES unity wear_levelling)
+set(COMPONENT_REQUIRES unity test_utils wear_levelling)
set(COMPONENT_EMBED_FILES test_partition_v1.bin)
third-party/neverbleed @GENERAL_MIRROR_SERVER@/idf/neverbleed.git ALLOW_TO_SYNC_FROM_PUBLIC
components/mqtt/esp-mqtt @GENERAL_MIRROR_SERVER@/idf/esp-mqtt.git ALLOW_TO_SYNC_FROM_PUBLIC
components/protobuf-c/protobuf-c @GENERAL_MIRROR_SERVER@/idf/protobuf-c.git ALLOW_TO_SYNC_FROM_PUBLIC
+components/unity/unity @GENERAL_MIRROR_SERVER@/idf/Unity.git ALLOW_TO_SYNC_FROM_PUBLIC
\ No newline at end of file
--- /dev/null
+set(COMPONENT_SRCS "ref_clock.c"
+ "test_runner.c"
+ "test_utils.c")
+set(COMPONENT_ADD_INCLUDEDIRS include)
+
+set(COMPONENT_REQUIRES spi_flash idf_test unity)
+
+register_component()
+
-menu "Unity test framework"
+menu "IDF unit test"
config UNITY_FREERTOS_PRIORITY
int "Priority of Unity test task"
-// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+// Copyright 2015-2018 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
#include <stdint.h>
#include <esp_partition.h>
+#include "sdkconfig.h"
+
+/* include performance pass standards header file */
+#include "idf_performance.h"
+
+/* For performance check with unity test on IDF */
+/* These macros should only be used with ESP-IDF.
+ * To use performance check, we need to first define pass standard in idf_performance.h.
+ */
+#define TEST_PERFORMANCE_LESS_THAN(name, value_fmt, value) do { \
+ printf("[Performance]["#name"]: "value_fmt"\n", value); \
+ TEST_ASSERT(value < IDF_PERFORMANCE_MAX_##name); \
+} while(0)
+
+#define TEST_PERFORMANCE_GREATER_THAN(name, value_fmt, value) do { \
+ printf("[Performance]["#name"]: "value_fmt"\n", value); \
+ TEST_ASSERT(value > IDF_PERFORMANCE_MIN_##name); \
+} while(0)
+
+
+/* @brief macro to print IDF performance
+ * @param mode : performance item name. a string pointer.
+ * @param value_fmt: print format and unit of the value, for example: "%02fms", "%dKB"
+ * @param value : the performance value.
+*/
+#define IDF_LOG_PERFORMANCE(item, value_fmt, value) \
+ printf("[Performance][%s]: "value_fmt"\n", item, value)
+
+
+/* Some definitions applicable to Unity running in FreeRTOS */
+#define UNITY_FREERTOS_PRIORITY CONFIG_UNITY_FREERTOS_PRIORITY
+#define UNITY_FREERTOS_CPU CONFIG_UNITY_FREERTOS_CPU
+#define UNITY_FREERTOS_STACK_SIZE CONFIG_UNITY_FREERTOS_STACK_SIZE
/* Return the 'flash_test' custom data partition (type 0x55)
defined in the custom partition table.
*/
uint64_t ref_clock_get();
+/**
+ * @brief Entry point of the test application
+ *
+ * Starts Unity test runner in a separate task and returns.
+ */
+void test_main();
/**
* @brief Reset automatic leak checking which happens in unit tests.
--- /dev/null
+// Copyright 2016-2018 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <stdio.h>
+#include "esp_heap_caps.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "unity.h"
+#include "test_utils.h"
+
+#ifdef CONFIG_HEAP_TRACING
+#include "esp_heap_trace.h"
+#endif
+
+static size_t before_free_8bit;
+static size_t before_free_32bit;
+
+/* Each unit test is allowed to "leak" this many bytes.
+
+ TODO: Make this value editable by the test.
+
+ Will always need to be some value here, as fragmentation can reduce free space even when no leak is occurring.
+*/
+const size_t WARN_LEAK_THRESHOLD = 256;
+const size_t CRITICAL_LEAK_THRESHOLD = 4096;
+
+static void unity_task(void *pvParameters)
+{
+ vTaskDelay(2); /* Delay a bit to let the main task be deleted */
+ unity_run_menu(); /* Doesn't return */
+}
+
+void test_main()
+{
+ // Note: if unpinning this task, change the way run times are calculated in
+ // unity_port_esp32.c
+ xTaskCreatePinnedToCore(unity_task, "unityTask", UNITY_FREERTOS_STACK_SIZE, NULL,
+ UNITY_FREERTOS_PRIORITY, NULL, UNITY_FREERTOS_CPU);
+}
+
+void unity_reset_leak_checks(void)
+{
+ before_free_8bit = heap_caps_get_free_size(MALLOC_CAP_8BIT);
+ before_free_32bit = heap_caps_get_free_size(MALLOC_CAP_32BIT);
+
+#ifdef CONFIG_HEAP_TRACING
+ heap_trace_start(HEAP_TRACE_LEAKS);
+#endif
+}
+
+/* setUp runs before every test */
+void setUp(void)
+{
+// If heap tracing is enabled in kconfig, leak trace the test
+#ifdef CONFIG_HEAP_TRACING
+ const size_t num_heap_records = 80;
+ static heap_trace_record_t *record_buffer;
+ if (!record_buffer) {
+ record_buffer = malloc(sizeof(heap_trace_record_t) * num_heap_records);
+ assert(record_buffer);
+ heap_trace_init_standalone(record_buffer, num_heap_records);
+ }
+#endif
+
+ printf("%s", ""); /* sneakily lazy-allocate the reent structure for this test task */
+ get_test_data_partition(); /* allocate persistent partition table structures */
+
+ unity_reset_leak_checks();
+}
+
+static void check_leak(size_t before_free, size_t after_free, const char *type)
+{
+ if (before_free <= after_free) {
+ return;
+ }
+ size_t leaked = before_free - after_free;
+ if (leaked < WARN_LEAK_THRESHOLD) {
+ return;
+ }
+
+ printf("MALLOC_CAP_%s %s leak: Before %u bytes free, After %u bytes free (delta %u)\n",
+ type,
+ leaked < CRITICAL_LEAK_THRESHOLD ? "potential" : "critical",
+ before_free, after_free, leaked);
+ fflush(stdout);
+ TEST_ASSERT_MESSAGE(leaked < CRITICAL_LEAK_THRESHOLD, "The test leaked too much memory");
+}
+
+/* tearDown runs after every test */
+void tearDown(void)
+{
+ /* some FreeRTOS stuff is cleaned up by idle task */
+ vTaskDelay(5);
+
+ /* We want the teardown to have this file in the printout if TEST_ASSERT fails */
+ const char *real_testfile = Unity.TestFile;
+ Unity.TestFile = __FILE__;
+
+ /* check if unit test has caused heap corruption in any heap */
+ TEST_ASSERT_MESSAGE( heap_caps_check_integrity(MALLOC_CAP_INVALID, true), "The test has corrupted the heap");
+
+ /* check for leaks */
+#ifdef CONFIG_HEAP_TRACING
+ heap_trace_stop();
+ heap_trace_dump();
+#endif
+ size_t after_free_8bit = heap_caps_get_free_size(MALLOC_CAP_8BIT);
+ size_t after_free_32bit = heap_caps_get_free_size(MALLOC_CAP_32BIT);
+
+ check_leak(before_free_8bit, after_free_8bit, "8BIT");
+ check_leak(before_free_32bit, after_free_32bit, "32BIT");
+
+ Unity.TestFile = real_testfile; // go back to the real filename
+}
+
+++ /dev/null
-set(COMPONENT_SRCDIRS .)
-set(COMPONENT_ADD_INCLUDEDIRS include)
-
-set(COMPONENT_REQUIRES spi_flash idf_test)
-
-register_component()
-
-if(GCC_NOT_5_2_0)
- component_compile_options(-Wno-unused-const-variable)
-endif()
\ No newline at end of file
+++ /dev/null
-#
-# Component Makefile
-#
-
-ifeq ($(GCC_NOT_5_2_0), 1)
-unity.o: CFLAGS += -Wno-unused-const-variable
-endif
\ No newline at end of file
+++ /dev/null
-/* ==========================================
- Unity Project - A Test Framework for C
- Copyright (c) 2007-14 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
-
-#define UNITY_INCLUDE_CONFIG_H
-#include "unity_internals.h"
-
-/* include performance pass standards header file */
-#include "idf_performance.h"
-
-void setUp(void);
-void tearDown(void);
-
-/*-------------------------------------------------------
- * Configuration Options
- *-------------------------------------------------------
- * All options described below should be passed as a compiler flag to all files using Unity. If you must add #defines, place them BEFORE the #include above.
-
- * Integers/longs/pointers
- * - Unity attempts to automatically discover your integer sizes
- * - define UNITY_EXCLUDE_STDINT_H to stop attempting to look in <stdint.h>
- * - define UNITY_EXCLUDE_LIMITS_H to stop attempting to look in <limits.h>
- * - define UNITY_EXCLUDE_SIZEOF to stop attempting to use sizeof in macros
- * - If you cannot use the automatic methods above, you can force Unity by using these options:
- * - define UNITY_SUPPORT_64
- * - define UNITY_INT_WIDTH
- * - UNITY_LONG_WIDTH
- * - 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_FLOAT_VERBOSE to print floating point values in errors (uses sprintf)
- * - 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_DOUBLE_VERBOSE to print floating point values in errors (uses sprintf)
- * - define UNITY_VERBOSE_NUMBER_MAX_LENGTH to change maximum length of printed numbers (used by sprintf)
-
- * 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
-
- *-------------------------------------------------------
- * 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() longjmp(Unity.AbortFrame, 1)
-
-/*-------------------------------------------------------
- * 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), (_UU32)(-1), (actual), __LINE__, NULL)
-#define TEST_ASSERT_BITS_LOW(mask, actual) UNITY_TEST_ASSERT_BITS((mask), (_UU32)(0), (actual), __LINE__, NULL)
-#define TEST_ASSERT_BIT_HIGH(bit, actual) UNITY_TEST_ASSERT_BITS(((_UU32)1 << (bit)), (_UU32)(-1), (actual), __LINE__, NULL)
-#define TEST_ASSERT_BIT_LOW(bit, actual) UNITY_TEST_ASSERT_BITS(((_UU32)1 << (bit)), (_UU32)(0), (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)
-
-/* 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)
-
-/* 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_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_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), (_UU32)(-1), (actual), __LINE__, (message))
-#define TEST_ASSERT_BITS_LOW_MESSAGE(mask, actual, message) UNITY_TEST_ASSERT_BITS((mask), (_UU32)(0), (actual), __LINE__, (message))
-#define TEST_ASSERT_BIT_HIGH_MESSAGE(bit, actual, message) UNITY_TEST_ASSERT_BITS(((_UU32)1 << (bit)), (_UU32)(-1), (actual), __LINE__, (message))
-#define TEST_ASSERT_BIT_LOW_MESSAGE(bit, actual, message) UNITY_TEST_ASSERT_BITS(((_UU32)1 << (bit)), (_UU32)(0), (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))
-
-/* 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))
-
-/* 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_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_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))
-
-/* For performance check with unity test on IDF */
-/* These macros should only be used with ESP-IDF.
- * To use performance check, we need to first define pass standard in idf_performance.h.
- */
-#define TEST_PERFORMANCE_LESS_THAN(name, value_fmt, value) do { \
- printf("[Performance]["#name"]: "value_fmt"\n", value); \
- TEST_ASSERT(value < IDF_PERFORMANCE_MAX_##name); \
-} while(0)
-
-#define TEST_PERFORMANCE_GREATER_THAN(name, value_fmt, value) do { \
- printf("[Performance]["#name"]: "value_fmt"\n", value); \
- TEST_ASSERT(value > IDF_PERFORMANCE_MIN_##name); \
-} while(0)
-
-/* end of UNITY_FRAMEWORK_H */
-#ifdef __cplusplus
-}
-#endif
-#endif
+++ /dev/null
-/* ==========================================
- Unity Project - A Test Framework for C
- Copyright (c) 2007-14 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
-
-#include <setjmp.h>
-
-/* Unity Attempts to Auto-Detect Integer Types
- * Attempt 1: UINT_MAX, ULONG_MAX, etc in <stdint.h>
- * Attempt 2: UINT_MAX, ULONG_MAX, etc in <limits.h>
- * Attempt 3: Deduced from sizeof() macros */
-#ifndef UNITY_EXCLUDE_STDINT_H
-#include <stdint.h>
-#endif
-
-#ifndef UNITY_EXCLUDE_LIMITS_H
-#include <limits.h>
-#endif
-
-#ifndef UNITY_EXCLUDE_SIZEOF
-#ifndef UINT_MAX
-#define UINT_MAX (sizeof(unsigned int) * 256 - 1)
-#endif
-#ifndef ULONG_MAX
-#define ULONG_MAX (sizeof(unsigned long) * 256 - 1)
-#endif
-#ifndef UINTPTR_MAX
-/* apparently this is not a constant expression: (sizeof(unsigned int *) * 256 - 1) so we have to just let this fall through */
-#endif
-#endif
-
-#ifndef UNITY_EXCLUDE_MATH_H
-#include <math.h>
-#endif
-
-/*-------------------------------------------------------
- * Guess Widths If Not Specified
- *-------------------------------------------------------*/
-
-/* Determine the size of an int, if not already specificied.
- * We cannot use sizeof(int), because it is not yet defined
- * at this stage in the trnslation 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
- #endif
-#endif
-#ifndef UNITY_INT_WIDTH
- #define UNITY_INT_WIDTH (32)
-#endif
-
-/* Determine the size of a long, if not already specified,
- * by following the process used above to define
- * UNITY_INT_WIDTH. */
-#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
- #endif
-#endif
-#ifndef UNITY_LONG_WIDTH
- #define UNITY_LONG_WIDTH (32)
-#endif
-
-/* Determine the size of a pointer, if not already specified,
- * by following the process used above to define
- * UNITY_INT_WIDTH. */
-#ifndef UNITY_POINTER_WIDTH
- #ifdef UINTPTR_MAX
- #if (UINTPTR_MAX+0 <= 0xFFFF)
- #define UNITY_POINTER_WIDTH (16)
- #elif (UINTPTR_MAX+0 <= 0xFFFFFFFF)
- #define UNITY_POINTER_WIDTH (32)
- #elif (UINTPTR_MAX+0 <= 0xFFFFFFFFFFFFFFFF)
- #define UNITY_POINTER_WIDTH (64)
- #endif
- #endif
-#endif
-#ifndef UNITY_POINTER_WIDTH
- #ifdef INTPTR_MAX
- #if (INTPTR_MAX+0 <= 0x7FFF)
- #define UNITY_POINTER_WIDTH (16)
- #elif (INTPTR_MAX+0 <= 0x7FFFFFFF)
- #define UNITY_POINTER_WIDTH (32)
- #elif (INTPTR_MAX+0 <= 0x7FFFFFFFFFFFFFFF)
- #define UNITY_POINTER_WIDTH (64)
- #endif
- #endif
-#endif
-#ifndef UNITY_POINTER_WIDTH
- #define UNITY_POINTER_WIDTH UNITY_LONG_WIDTH
-#endif
-
-/*-------------------------------------------------------
- * Int Support (Define types based on detected sizes)
- *-------------------------------------------------------*/
-
-#if (UNITY_INT_WIDTH == 32)
- typedef unsigned char _UU8;
- typedef unsigned short _UU16;
- typedef unsigned int _UU32;
- typedef signed char _US8;
- typedef signed short _US16;
- typedef signed int _US32;
-#elif (UNITY_INT_WIDTH == 16)
- typedef unsigned char _UU8;
- typedef unsigned int _UU16;
- typedef unsigned long _UU32;
- typedef signed char _US8;
- typedef signed int _US16;
- typedef signed long _US32;
-#else
- #error Invalid UNITY_INT_WIDTH specified! (16 or 32 are supported)
-#endif
-
-/*-------------------------------------------------------
- * 64-bit Support
- *-------------------------------------------------------*/
-
-#ifndef UNITY_SUPPORT_64
-#if UNITY_LONG_WIDTH > 32
-#define UNITY_SUPPORT_64
-#endif
-#endif
-#ifndef UNITY_SUPPORT_64
-#if UNITY_POINTER_WIDTH > 32
-#define UNITY_SUPPORT_64
-#endif
-#endif
-
-#ifndef UNITY_SUPPORT_64
-
-/* No 64-bit Support */
-typedef _UU32 _U_UINT;
-typedef _US32 _U_SINT;
-
-#else
-
-/* 64-bit Support */
-#if (UNITY_LONG_WIDTH == 32)
- typedef unsigned long long _UU64;
- typedef signed long long _US64;
-#elif (UNITY_LONG_WIDTH == 64)
- typedef unsigned long _UU64;
- typedef signed long _US64;
-#else
- #error Invalid UNITY_LONG_WIDTH specified! (32 or 64 are supported)
-#endif
-typedef _UU64 _U_UINT;
-typedef _US64 _U_SINT;
-
-#endif
-
-/*-------------------------------------------------------
- * Pointer Support
- *-------------------------------------------------------*/
-
-#if (UNITY_POINTER_WIDTH == 32)
- typedef _UU32 _UP;
-#define UNITY_DISPLAY_STYLE_POINTER UNITY_DISPLAY_STYLE_HEX32
-#elif (UNITY_POINTER_WIDTH == 64)
- typedef _UU64 _UP;
-#define UNITY_DISPLAY_STYLE_POINTER UNITY_DISPLAY_STYLE_HEX64
-#elif (UNITY_POINTER_WIDTH == 16)
- typedef _UU16 _UP;
-#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*
-/* #define UNITY_INTERNAL_PTR UNITY_PTR_ATTRIBUTE const _UU8* */
-#endif
-
-/*-------------------------------------------------------
- * Float Support
- *-------------------------------------------------------*/
-
-#ifdef UNITY_EXCLUDE_FLOAT
-
-/* No Floating Point Support */
-#undef UNITY_INCLUDE_FLOAT
-#undef UNITY_FLOAT_PRECISION
-#undef UNITY_FLOAT_TYPE
-#undef UNITY_FLOAT_VERBOSE
-
-#else
-
-#ifndef UNITY_INCLUDE_FLOAT
-#define UNITY_INCLUDE_FLOAT
-#endif
-
-/* 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 _UF;
-
-#ifndef isinf
-#define isinf(n) (((1.0f / f_zero) == n) ? 1 : 0) || (((-1.0f / f_zero) == n) ? 1 : 0)
-#define UNITY_FLOAT_NEEDS_ZERO
-#endif
-
-#ifndef isnan
-#define isnan(n) ((n != n) ? 1 : 0)
-#endif
-
-#ifndef isneg
-#define isneg(n) ((n < 0.0f) ? 1 : 0)
-#endif
-
-#ifndef ispos
-#define ispos(n) ((n > 0.0f) ? 1 : 0)
-#endif
-
-#endif
-
-/*-------------------------------------------------------
- * Double Float Support
- *-------------------------------------------------------*/
-
-/* unlike FLOAT, we DON'T include by default */
-#ifndef UNITY_EXCLUDE_DOUBLE
-#ifndef UNITY_INCLUDE_DOUBLE
-#define UNITY_EXCLUDE_DOUBLE
-#endif
-#endif
-
-#ifdef UNITY_EXCLUDE_DOUBLE
-
-/* No Floating Point Support */
-#undef UNITY_DOUBLE_PRECISION
-#undef UNITY_DOUBLE_TYPE
-#undef UNITY_DOUBLE_VERBOSE
-
-#ifdef UNITY_INCLUDE_DOUBLE
-#undef UNITY_INCLUDE_DOUBLE
-#endif
-
-#else
-
-/* Double Floating Point Support */
-#ifndef UNITY_DOUBLE_PRECISION
-#define UNITY_DOUBLE_PRECISION (1e-12f)
-#endif
-#ifndef UNITY_DOUBLE_TYPE
-#define UNITY_DOUBLE_TYPE double
-#endif
-typedef UNITY_DOUBLE_TYPE _UD;
-
-#endif
-
-#ifdef UNITY_DOUBLE_VERBOSE
-#ifndef UNITY_FLOAT_VERBOSE
-#define UNITY_FLOAT_VERBOSE
-#endif
-#endif
-
-/*-------------------------------------------------------
- * Output Method: stdout (DEFAULT)
- *-------------------------------------------------------*/
-#ifndef UNITY_OUTPUT_CHAR
-/* Default to using putchar, which is defined in stdio.h */
-#include <stdio.h>
-#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 */
- #ifndef UNITY_OMIT_OUTPUT_CHAR_HEADER_DECLARATION
-extern void UNITY_OUTPUT_CHAR(int);
- #endif
-#endif
-
-#ifndef UNITY_OUTPUT_FLUSH
-/* Default to using putchar, which is defined in stdio.h */
-#include <stdio.h>
-#define UNITY_OUTPUT_FLUSH() (void)fflush(stdout)
-#else
- /* If defined as something else, make sure we declare it here so it's ready for use */
- #ifndef UNITY_OMIT_OUTPUT_FLUSH_HEADER_DECLARATION
-extern void UNITY_OUTPUT_FLUSH(void);
- #endif
-#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
-
-/*-------------------------------------------------------
- * Footprint
- *-------------------------------------------------------*/
-
-#ifndef UNITY_LINE_TYPE
-#define UNITY_LINE_TYPE _U_UINT
-#endif
-
-#ifndef UNITY_COUNTER_TYPE
-#define UNITY_COUNTER_TYPE _U_UINT
-#endif
-
-/*-------------------------------------------------------
- * Language Features Available
- *-------------------------------------------------------*/
-#if !defined(UNITY_WEAK_ATTRIBUTE) && !defined(UNITY_WEAK_PRAGMA)
-# ifdef __GNUC__ /* includes clang */
-# if !(defined(__WIN32__) && defined(__clang__))
-# 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)
-#define UNITY_DISPLAY_RANGE_AUTO (0x80)
-
-typedef enum
-{
-#if (UNITY_INT_WIDTH == 16)
- UNITY_DISPLAY_STYLE_INT = 2 + UNITY_DISPLAY_RANGE_INT + UNITY_DISPLAY_RANGE_AUTO,
-#elif (UNITY_INT_WIDTH == 32)
- UNITY_DISPLAY_STYLE_INT = 4 + UNITY_DISPLAY_RANGE_INT + UNITY_DISPLAY_RANGE_AUTO,
-#elif (UNITY_INT_WIDTH == 64)
- UNITY_DISPLAY_STYLE_INT = 8 + UNITY_DISPLAY_RANGE_INT + UNITY_DISPLAY_RANGE_AUTO,
-#endif
- 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
-
-#if (UNITY_INT_WIDTH == 16)
- UNITY_DISPLAY_STYLE_UINT = 2 + UNITY_DISPLAY_RANGE_UINT + UNITY_DISPLAY_RANGE_AUTO,
-#elif (UNITY_INT_WIDTH == 32)
- UNITY_DISPLAY_STYLE_UINT = 4 + UNITY_DISPLAY_RANGE_UINT + UNITY_DISPLAY_RANGE_AUTO,
-#elif (UNITY_INT_WIDTH == 64)
- UNITY_DISPLAY_STYLE_UINT = 8 + UNITY_DISPLAY_RANGE_UINT + UNITY_DISPLAY_RANGE_AUTO,
-#endif
- 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;
-
-#ifndef UNITY_EXCLUDE_FLOAT
-typedef enum _UNITY_FLOAT_TRAIT_T
-{
- 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
-
-struct _Unity
-{
- 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;
- jmp_buf AbortFrame;
-};
-
-extern struct _Unity 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);
-void UnityPrintMask(const _U_UINT mask, const _U_UINT number);
-void UnityPrintNumberByStyle(const _U_SINT number, const UNITY_DISPLAY_STYLE_T style);
-void UnityPrintNumber(const _U_SINT number);
-void UnityPrintNumberUnsigned(const _U_UINT number);
-void UnityPrintNumberHex(const _U_UINT number, const char nibbles);
-
-#ifdef UNITY_FLOAT_VERBOSE
-void UnityPrintFloat(const _UF number);
-#endif
-
-/*-------------------------------------------------------
- * Test Assertion Fuctions
- *-------------------------------------------------------
- * 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 _U_SINT expected,
- const _U_SINT actual,
- 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 _UU32 num_elements,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber,
- const UNITY_DISPLAY_STYLE_T style);
-
-void UnityAssertBits(const _U_SINT mask,
- const _U_SINT expected,
- const _U_SINT 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 _UU32 length,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber);
-
-void UnityAssertEqualStringArray( const char** expected,
- const char** actual,
- const _UU32 num_elements,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber);
-
-void UnityAssertEqualMemory( UNITY_INTERNAL_PTR expected,
- UNITY_INTERNAL_PTR actual,
- const _UU32 length,
- const _UU32 num_elements,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber);
-
-void UnityAssertNumbersWithin(const _U_UINT delta,
- const _U_SINT expected,
- const _U_SINT actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber,
- const UNITY_DISPLAY_STYLE_T style);
-
-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 _UF delta,
- const _UF expected,
- const _UF actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber);
-
-void UnityAssertEqualFloatArray(UNITY_PTR_ATTRIBUTE const _UF* expected,
- UNITY_PTR_ATTRIBUTE const _UF* actual,
- const _UU32 num_elements,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber);
-
-void UnityAssertFloatSpecial(const _UF actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber,
- const UNITY_FLOAT_TRAIT_T style);
-#endif
-
-#ifndef UNITY_EXCLUDE_DOUBLE
-void UnityAssertDoublesWithin(const _UD delta,
- const _UD expected,
- const _UD actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber);
-
-void UnityAssertEqualDoubleArray(UNITY_PTR_ATTRIBUTE const _UD* expected,
- UNITY_PTR_ATTRIBUTE const _UD* actual,
- const _UU32 num_elements,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber);
-
-void UnityAssertDoubleSpecial(const _UD actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber,
- const UNITY_FLOAT_TRAIT_T style);
-#endif
-
-/*-------------------------------------------------------
- * Error Strings We Might Need
- *-------------------------------------------------------*/
-
-extern const char UnityStrErrFloat[];
-extern const char UnityStrErrDouble[];
-extern const char UnityStrErr64[];
-
-/*-------------------------------------------------------
- * Test Running Macros
- *-------------------------------------------------------*/
-
-#define TEST_PROTECT() (setjmp(Unity.AbortFrame) == 0)
-
-#define TEST_ABORT() {longjmp(Unity.AbortFrame, 1);}
-
-/* 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
-
-#define UNITY_UNUSED(x) (void)(sizeof(x))
-
-/*-------------------------------------------------------
- * 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((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT)
-#define UNITY_TEST_ASSERT_EQUAL_INT8(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(_US8 )(expected), (_U_SINT)(_US8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8)
-#define UNITY_TEST_ASSERT_EQUAL_INT16(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(_US16)(expected), (_U_SINT)(_US16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16)
-#define UNITY_TEST_ASSERT_EQUAL_INT32(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(_US32)(expected), (_U_SINT)(_US32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32)
-#define UNITY_TEST_ASSERT_EQUAL_UINT(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT)
-#define UNITY_TEST_ASSERT_EQUAL_UINT8(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(_UU8 )(expected), (_U_SINT)(_UU8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8)
-#define UNITY_TEST_ASSERT_EQUAL_UINT16(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(_UU16)(expected), (_U_SINT)(_UU16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16)
-#define UNITY_TEST_ASSERT_EQUAL_UINT32(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(_UU32)(expected), (_U_SINT)(_UU32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32)
-#define UNITY_TEST_ASSERT_EQUAL_HEX8(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(_US8 )(expected), (_U_SINT)(_US8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8)
-#define UNITY_TEST_ASSERT_EQUAL_HEX16(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(_US16)(expected), (_U_SINT)(_US16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16)
-#define UNITY_TEST_ASSERT_EQUAL_HEX32(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(_US32)(expected), (_U_SINT)(_US32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32)
-#define UNITY_TEST_ASSERT_BITS(mask, expected, actual, line, message) UnityAssertBits((_U_SINT)(mask), (_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)(line))
-
-#define UNITY_TEST_ASSERT_INT_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((delta), (_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT)
-#define UNITY_TEST_ASSERT_INT8_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((_UU8 )(delta), (_U_SINT)(_US8 )(expected), (_U_SINT)(_US8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8)
-#define UNITY_TEST_ASSERT_INT16_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((_UU16)(delta), (_U_SINT)(_US16)(expected), (_U_SINT)(_US16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16)
-#define UNITY_TEST_ASSERT_INT32_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((_UU32)(delta), (_U_SINT)(_US32)(expected), (_U_SINT)(_US32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32)
-#define UNITY_TEST_ASSERT_UINT_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((delta), (_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT)
-#define UNITY_TEST_ASSERT_UINT8_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((_UU8 )(delta), (_U_SINT)(_U_UINT)(_UU8 )(expected), (_U_SINT)(_U_UINT)(_UU8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8)
-#define UNITY_TEST_ASSERT_UINT16_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((_UU16)(delta), (_U_SINT)(_U_UINT)(_UU16)(expected), (_U_SINT)(_U_UINT)(_UU16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16)
-#define UNITY_TEST_ASSERT_UINT32_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((_UU32)(delta), (_U_SINT)(_U_UINT)(_UU32)(expected), (_U_SINT)(_U_UINT)(_UU32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32)
-#define UNITY_TEST_ASSERT_HEX8_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((_UU8 )(delta), (_U_SINT)(_U_UINT)(_UU8 )(expected), (_U_SINT)(_U_UINT)(_UU8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8)
-#define UNITY_TEST_ASSERT_HEX16_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((_UU16)(delta), (_U_SINT)(_U_UINT)(_UU16)(expected), (_U_SINT)(_U_UINT)(_UU16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16)
-#define UNITY_TEST_ASSERT_HEX32_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((_UU32)(delta), (_U_SINT)(_U_UINT)(_UU32)(expected), (_U_SINT)(_U_UINT)(_UU32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32)
-
-#define UNITY_TEST_ASSERT_EQUAL_PTR(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(_UP)(expected), (_U_SINT)(_UP)(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), (_UU32)(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), (_UU32)(len), 1, (message), (UNITY_LINE_TYPE)(line))
-
-#define UNITY_TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT)
-#define UNITY_TEST_ASSERT_EQUAL_INT8_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8)
-#define UNITY_TEST_ASSERT_EQUAL_INT16_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16)
-#define UNITY_TEST_ASSERT_EQUAL_INT32_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32)
-#define UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT)
-#define UNITY_TEST_ASSERT_EQUAL_UINT8_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8)
-#define UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16)
-#define UNITY_TEST_ASSERT_EQUAL_UINT32_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32)
-#define UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8)
-#define UNITY_TEST_ASSERT_EQUAL_HEX16_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16)
-#define UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32)
-#define UNITY_TEST_ASSERT_EQUAL_PTR_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(_UP*)(expected), (UNITY_INTERNAL_PTR)(_UP*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_POINTER)
-#define UNITY_TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualStringArray((const char**)(expected), (const char**)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line))
-#define UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY(expected, actual, len, num_elements, line, message) UnityAssertEqualMemory((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (_UU32)(len), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line))
-
-#ifdef UNITY_SUPPORT_64
-#define UNITY_TEST_ASSERT_EQUAL_INT64(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64)
-#define UNITY_TEST_ASSERT_EQUAL_UINT64(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64)
-#define UNITY_TEST_ASSERT_EQUAL_HEX64(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(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), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64)
-#define UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64)
-#define UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64)
-#define UNITY_TEST_ASSERT_INT64_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((delta), (_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64)
-#define UNITY_TEST_ASSERT_UINT64_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((delta), (_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64)
-#define UNITY_TEST_ASSERT_HEX64_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((delta), (_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64)
-#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)
-#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_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((_UF)(delta), (_UF)(expected), (_UF)(actual), (message), (UNITY_LINE_TYPE)(line))
-#define UNITY_TEST_ASSERT_EQUAL_FLOAT(expected, actual, line, message) UNITY_TEST_ASSERT_FLOAT_WITHIN((_UF)(expected) * (_UF)UNITY_FLOAT_PRECISION, (_UF)(expected), (_UF)(actual), (UNITY_LINE_TYPE)(line), (message))
-#define UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualFloatArray((_UF*)(expected), (_UF*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line))
-#define UNITY_TEST_ASSERT_FLOAT_IS_INF(actual, line, message) UnityAssertFloatSpecial((_UF)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_INF)
-#define UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF(actual, line, message) UnityAssertFloatSpecial((_UF)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NEG_INF)
-#define UNITY_TEST_ASSERT_FLOAT_IS_NAN(actual, line, message) UnityAssertFloatSpecial((_UF)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NAN)
-#define UNITY_TEST_ASSERT_FLOAT_IS_DETERMINATE(actual, line, message) UnityAssertFloatSpecial((_UF)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_DET)
-#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_INF(actual, line, message) UnityAssertFloatSpecial((_UF)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_INF)
-#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_NEG_INF(actual, line, message) UnityAssertFloatSpecial((_UF)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_NEG_INF)
-#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_NAN(actual, line, message) UnityAssertFloatSpecial((_UF)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_NAN)
-#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(actual, line, message) UnityAssertFloatSpecial((_UF)(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_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((_UD)(delta), (_UD)(expected), (_UD)(actual), (message), (UNITY_LINE_TYPE)line)
-#define UNITY_TEST_ASSERT_EQUAL_DOUBLE(expected, actual, line, message) UNITY_TEST_ASSERT_DOUBLE_WITHIN((_UD)(expected) * (_UD)UNITY_DOUBLE_PRECISION, (_UD)expected, (_UD)actual, (UNITY_LINE_TYPE)(line), message)
-#define UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualDoubleArray((_UD*)(expected), (_UD*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line)
-#define UNITY_TEST_ASSERT_DOUBLE_IS_INF(actual, line, message) UnityAssertDoubleSpecial((_UD)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_INF)
-#define UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF(actual, line, message) UnityAssertDoubleSpecial((_UD)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NEG_INF)
-#define UNITY_TEST_ASSERT_DOUBLE_IS_NAN(actual, line, message) UnityAssertDoubleSpecial((_UD)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NAN)
-#define UNITY_TEST_ASSERT_DOUBLE_IS_DETERMINATE(actual, line, message) UnityAssertDoubleSpecial((_UD)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_DET)
-#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_INF(actual, line, message) UnityAssertDoubleSpecial((_UD)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_INF)
-#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF(actual, line, message) UnityAssertDoubleSpecial((_UD)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_NEG_INF)
-#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NAN(actual, line, message) UnityAssertDoubleSpecial((_UD)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_NAN)
-#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(actual, line, message) UnityAssertDoubleSpecial((_UD)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_DET)
-#endif
-
-/* End of UNITY_INTERNALS_H */
-#endif
+++ /dev/null
-The MIT License (MIT)
-
-Copyright (c) <year> 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.
+++ /dev/null
-/* =========================================================================
- Unity Project - A Test Framework for C
- Copyright (c) 2007-14 Mike Karlesky, Mark VanderVoord, Greg Williams
- [Released under MIT License. Please refer to license.txt for details]
-============================================================================ */
-
-#include "unity.h"
-#include <stddef.h>
-
-/* If omitted from header, declare overrideable prototypes here so they're ready for use */
-#ifdef UNITY_OMIT_OUTPUT_CHAR_HEADER_DECLARATION
-int UNITY_OUTPUT_CHAR(int);
-#endif
-#ifdef UNITY_OMIT_OUTPUT_FLUSH_HEADER_DECLARATION
-int UNITY_OUTPUT_FLUSH(void);
-#endif
-
-/* Helpful macros for us to use here */
-#define UNITY_FAIL_AND_BAIL { Unity.CurrentTestFailed = 1; longjmp(Unity.AbortFrame, 1); }
-#define UNITY_IGNORE_AND_BAIL { Unity.CurrentTestIgnored = 1; longjmp(Unity.AbortFrame, 1); }
-
-/* return prematurely if we are already in failure or ignore state */
-#define UNITY_SKIP_EXECUTION { if ((Unity.CurrentTestFailed != 0) || (Unity.CurrentTestIgnored != 0)) {return;} }
-
-struct _Unity Unity;
-
-static const char UnityStrOk[] = "OK";
-static const char UnityStrPass[] = "PASS";
-static const char UnityStrFail[] = "FAIL";
-static const char UnityStrIgnore[] = "IGNORE";
-static const char UnityStrNull[] = "NULL";
-static const char UnityStrSpacer[] = ". ";
-static const char UnityStrExpected[] = " Expected ";
-static const char UnityStrWas[] = " Was ";
-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";
-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";
-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 " ";
-
-#ifdef UNITY_FLOAT_NEEDS_ZERO
-/* Dividing by these constants produces +/- infinity.
- * The rationale is given in UnityAssertFloatIsInf's body. */
-static const _UF f_zero = 0.0f;
-#endif
-
-/* compiler-generic print formatting masks */
-static const _U_UINT UnitySizeMask[] =
-{
- 255u, /* 0xFF */
- 65535u, /* 0xFFFF */
- 65535u,
- 4294967295u, /* 0xFFFFFFFF */
- 4294967295u,
- 4294967295u,
- 4294967295u
-#ifdef UNITY_SUPPORT_64
- ,0xFFFFFFFFFFFFFFFF
-#endif
-};
-
-/*-----------------------------------------------
- * Pretty Printers & Test Result Output Handlers
- *-----------------------------------------------*/
-
-void UnityPrint(const char* string)
-{
- const char* pch = string;
-
- if (pch != NULL)
- {
- while (*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('\\');
- UnityPrintNumberHex((_U_UINT)*pch, 2);
- }
- pch++;
- }
- }
-}
-
-void UnityPrintLen(const char* string, const _UU32 length);
-void UnityPrintLen(const char* string, const _UU32 length)
-{
- const char* pch = string;
-
- if (pch != NULL)
- {
- while (*pch && (_UU32)(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('\\');
- UnityPrintNumberHex((_U_UINT)*pch, 2);
- }
- pch++;
- }
- }
-}
-
-/*-----------------------------------------------*/
-void UnityPrintNumberByStyle(const _U_SINT 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( (_U_UINT)number & UnitySizeMask[((_U_UINT)style & (_U_UINT)0x0F) - 1] );
- }
- else
- {
- UnityPrintNumberHex((_U_UINT)number, (char)((style & 0x000F) << 1));
- }
-}
-
-/*-----------------------------------------------*/
-void UnityPrintNumber(const _U_SINT number_to_print)
-{
- _U_UINT number = (_U_UINT)number_to_print;
-
- if (number_to_print < 0)
- {
- /* A negative number, including MIN negative */
- UNITY_OUTPUT_CHAR('-');
- number = (_U_UINT)(-number_to_print);
- }
- UnityPrintNumberUnsigned(number);
-}
-
-/*-----------------------------------------------
- * basically do an itoa using as little ram as possible */
-void UnityPrintNumberUnsigned(const _U_UINT number)
-{
- _U_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 _U_UINT number, const char nibbles_to_print)
-{
- _U_UINT nibble;
- char nibbles = nibbles_to_print;
- UNITY_OUTPUT_CHAR('0');
- UNITY_OUTPUT_CHAR('x');
-
- while (nibbles > 0)
- {
- nibble = (number >> (--nibbles << 2)) & 0x0000000F;
- if (nibble <= 9)
- {
- UNITY_OUTPUT_CHAR((char)('0' + nibble));
- }
- else
- {
- UNITY_OUTPUT_CHAR((char)('A' - 10 + nibble));
- }
- }
-}
-
-/*-----------------------------------------------*/
-void UnityPrintMask(const _U_UINT mask, const _U_UINT number)
-{
- _U_UINT current_bit = (_U_UINT)1 << (UNITY_INT_WIDTH - 1);
- _US32 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;
- }
-}
-
-/*-----------------------------------------------*/
-#ifdef UNITY_FLOAT_VERBOSE
-#include <stdio.h>
-
-#ifndef UNITY_VERBOSE_NUMBER_MAX_LENGTH
-# ifdef UNITY_DOUBLE_VERBOSE
-# define UNITY_VERBOSE_NUMBER_MAX_LENGTH 317
-# else
-# define UNITY_VERBOSE_NUMBER_MAX_LENGTH 47
-# endif
-#endif
-
-void UnityPrintFloat(_UF number)
-{
- char TempBuffer[UNITY_VERBOSE_NUMBER_MAX_LENGTH + 1];
- snprintf(TempBuffer, sizeof(TempBuffer), "%.6f", number);
- UnityPrint(TempBuffer);
-}
-#endif
-
-/*-----------------------------------------------*/
-
-void UnityPrintFail(void);
-void UnityPrintFail(void)
-{
- UnityPrint(UnityStrFail);
-}
-
-void UnityPrintOk(void);
-void UnityPrintOk(void)
-{
- UnityPrint(UnityStrOk);
-}
-
-/*-----------------------------------------------*/
-static void UnityTestResultsBegin(const char* file, const UNITY_LINE_TYPE line);
-static void UnityTestResultsBegin(const char* file, const UNITY_LINE_TYPE line)
-{
-#ifndef UNITY_FIXTURES
- UnityPrint(file);
- UNITY_OUTPUT_CHAR(':');
- UnityPrintNumber((_U_SINT)line);
- UNITY_OUTPUT_CHAR(':');
- UnityPrint(Unity.CurrentTestName);
- UNITY_OUTPUT_CHAR(':');
-#else
- UNITY_UNUSED(file);
- UNITY_UNUSED(line);
-#endif
-}
-
-/*-----------------------------------------------*/
-static void UnityTestResultsFailBegin(const UNITY_LINE_TYPE line);
-static void UnityTestResultsFailBegin(const UNITY_LINE_TYPE line)
-{
-#ifndef UNITY_FIXTURES
- UnityTestResultsBegin(Unity.TestFile, line);
-#else
- UNITY_UNUSED(line);
-#endif
- 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_EOL();
- UNITY_OUTPUT_FLUSH();
-}
-
-/*-----------------------------------------------*/
-static void UnityAddMsgIfSpecified(const char* msg);
-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);
-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 _UU32 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 UnityCheckArraysForNull(UNITY_INTERNAL_PTR expected, UNITY_INTERNAL_PTR actual, const UNITY_LINE_TYPE lineNumber, const char* msg)
-{
- /* return true if they are both NULL */
- if ((expected == NULL) && (actual == NULL))
- return 1;
-
- /* throw error if just expected is NULL */
- if (expected == NULL)
- {
- UnityTestResultsFailBegin(lineNumber);
- UnityPrint(UnityStrNullPointerForExpected);
- UnityAddMsgIfSpecified(msg);
- UNITY_OUTPUT_CHAR('\n');
- UNITY_FAIL_AND_BAIL;
- }
-
- /* throw error if just actual is NULL */
- if (actual == NULL)
- {
- UnityTestResultsFailBegin(lineNumber);
- UnityPrint(UnityStrNullPointerForActual);
- UnityAddMsgIfSpecified(msg);
- UNITY_OUTPUT_CHAR('\n');
- UNITY_FAIL_AND_BAIL;
- }
-
- /* return false if neither is NULL */
- return 0;
-}
-
-/*-----------------------------------------------
- * Assertion Functions
- *-----------------------------------------------*/
-
-void UnityAssertBits(const _U_SINT mask,
- const _U_SINT expected,
- const _U_SINT actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber)
-{
- UNITY_SKIP_EXECUTION;
-
- if ((mask & expected) != (mask & actual))
- {
- UnityTestResultsFailBegin(lineNumber);
- UnityPrint(UnityStrExpected);
- UnityPrintMask((_U_UINT)mask, (_U_UINT)expected);
- UnityPrint(UnityStrWas);
- UnityPrintMask((_U_UINT)mask, (_U_UINT)actual);
- UnityAddMsgIfSpecified(msg);
- UNITY_OUTPUT_CHAR('\n');
- UNITY_FAIL_AND_BAIL;
- }
-}
-
-/*-----------------------------------------------*/
-void UnityAssertEqualNumber(const _U_SINT expected,
- const _U_SINT actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber,
- const UNITY_DISPLAY_STYLE_T style)
-{
- UNITY_SKIP_EXECUTION;
-
- if (expected != actual)
- {
- UnityTestResultsFailBegin(lineNumber);
- UnityPrint(UnityStrExpected);
- UnityPrintNumberByStyle(expected, style);
- UnityPrint(UnityStrWas);
- UnityPrintNumberByStyle(actual, style);
- UnityAddMsgIfSpecified(msg);
- UNITY_OUTPUT_CHAR('\n');
- UNITY_FAIL_AND_BAIL;
- }
-}
-
-#define UnityPrintPointlessAndBail() \
-{ \
- UnityTestResultsFailBegin(lineNumber); \
- UnityPrint(UnityStrPointless); \
- UnityAddMsgIfSpecified(msg); \
- UNITY_OUTPUT_CHAR('\n'); \
- UNITY_FAIL_AND_BAIL; }
-
-/*-----------------------------------------------*/
-void UnityAssertEqualIntArray(UNITY_INTERNAL_PTR expected,
- UNITY_INTERNAL_PTR actual,
- const _UU32 num_elements,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber,
- const UNITY_DISPLAY_STYLE_T style)
-{
- _UU32 elements = num_elements;
- UNITY_INTERNAL_PTR ptr_exp = (UNITY_INTERNAL_PTR)expected;
- UNITY_INTERNAL_PTR ptr_act = (UNITY_INTERNAL_PTR)actual;
-
- UNITY_SKIP_EXECUTION;
-
- if (elements == 0)
- {
- UnityPrintPointlessAndBail();
- }
-
- if (UnityCheckArraysForNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg) == 1)
- return;
-
- /* If style is UNITY_DISPLAY_STYLE_INT, we'll fall into the default case rather than the INT16 or INT32 (etc) case
- * as UNITY_DISPLAY_STYLE_INT includes a flag for UNITY_DISPLAY_RANGE_AUTO, which the width-specific
- * variants do not. Therefore remove this flag. */
- switch(style & (UNITY_DISPLAY_STYLE_T)(~UNITY_DISPLAY_RANGE_AUTO))
- {
- case UNITY_DISPLAY_STYLE_HEX8:
- case UNITY_DISPLAY_STYLE_INT8:
- case UNITY_DISPLAY_STYLE_UINT8:
- while (elements--)
- {
- if (*(UNITY_PTR_ATTRIBUTE const _US8*)ptr_exp != *(UNITY_PTR_ATTRIBUTE const _US8*)ptr_act)
- {
- UnityTestResultsFailBegin(lineNumber);
- UnityPrint(UnityStrElement);
- UnityPrintNumberUnsigned(num_elements - elements - 1);
- UnityPrint(UnityStrExpected);
- UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US8*)ptr_exp, style);
- UnityPrint(UnityStrWas);
- UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US8*)ptr_act, style);
- UnityAddMsgIfSpecified(msg);
- UNITY_OUTPUT_CHAR('\n');
- UNITY_FAIL_AND_BAIL;
- }
- ptr_exp = (UNITY_INTERNAL_PTR)((_UP)ptr_exp + 1);
- ptr_act = (UNITY_INTERNAL_PTR)((_UP)ptr_act + 1);
- }
- break;
- case UNITY_DISPLAY_STYLE_HEX16:
- case UNITY_DISPLAY_STYLE_INT16:
- case UNITY_DISPLAY_STYLE_UINT16:
- while (elements--)
- {
- if (*(UNITY_PTR_ATTRIBUTE const _US16*)ptr_exp != *(UNITY_PTR_ATTRIBUTE const _US16*)ptr_act)
- {
- UnityTestResultsFailBegin(lineNumber);
- UnityPrint(UnityStrElement);
- UnityPrintNumberUnsigned(num_elements - elements - 1);
- UnityPrint(UnityStrExpected);
- UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US16*)ptr_exp, style);
- UnityPrint(UnityStrWas);
- UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US16*)ptr_act, style);
- UnityAddMsgIfSpecified(msg);
- UNITY_OUTPUT_CHAR('\n');
- UNITY_FAIL_AND_BAIL;
- }
- ptr_exp = (UNITY_INTERNAL_PTR)((_UP)ptr_exp + 2);
- ptr_act = (UNITY_INTERNAL_PTR)((_UP)ptr_act + 2);
- }
- break;
-#ifdef UNITY_SUPPORT_64
- case UNITY_DISPLAY_STYLE_HEX64:
- case UNITY_DISPLAY_STYLE_INT64:
- case UNITY_DISPLAY_STYLE_UINT64:
- while (elements--)
- {
- if (*(UNITY_PTR_ATTRIBUTE const _US64*)ptr_exp != *(UNITY_PTR_ATTRIBUTE const _US64*)ptr_act)
- {
- UnityTestResultsFailBegin(lineNumber);
- UnityPrint(UnityStrElement);
- UnityPrintNumberUnsigned(num_elements - elements - 1);
- UnityPrint(UnityStrExpected);
- UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US64*)ptr_exp, style);
- UnityPrint(UnityStrWas);
- UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US64*)ptr_act, style);
- UnityAddMsgIfSpecified(msg);
- UNITY_OUTPUT_CHAR('\n');
- UNITY_FAIL_AND_BAIL;
- }
- ptr_exp = (UNITY_INTERNAL_PTR)((_UP)ptr_exp + 8);
- ptr_act = (UNITY_INTERNAL_PTR)((_UP)ptr_act + 8);
- }
- break;
-#endif
- default:
- while (elements--)
- {
- if (*(UNITY_PTR_ATTRIBUTE const _US32*)ptr_exp != *(UNITY_PTR_ATTRIBUTE const _US32*)ptr_act)
- {
- UnityTestResultsFailBegin(lineNumber);
- UnityPrint(UnityStrElement);
- UnityPrintNumberUnsigned(num_elements - elements - 1);
- UnityPrint(UnityStrExpected);
- UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US32*)ptr_exp, style);
- UnityPrint(UnityStrWas);
- UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US32*)ptr_act, style);
- UnityAddMsgIfSpecified(msg);
- UNITY_OUTPUT_CHAR('\n');
- UNITY_FAIL_AND_BAIL;
- }
- ptr_exp = (UNITY_INTERNAL_PTR)((_UP)ptr_exp + 4);
- ptr_act = (UNITY_INTERNAL_PTR)((_UP)ptr_act + 4);
- }
- break;
- }
-}
-
-/*-----------------------------------------------*/
-#ifndef UNITY_EXCLUDE_FLOAT
-void UnityAssertEqualFloatArray(UNITY_PTR_ATTRIBUTE const _UF* expected,
- UNITY_PTR_ATTRIBUTE const _UF* actual,
- const _UU32 num_elements,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber)
-{
- _UU32 elements = num_elements;
- UNITY_PTR_ATTRIBUTE const _UF* ptr_expected = expected;
- UNITY_PTR_ATTRIBUTE const _UF* ptr_actual = actual;
- _UF diff, tol;
-
- UNITY_SKIP_EXECUTION;
-
- if (elements == 0)
- {
- UnityPrintPointlessAndBail();
- }
-
- if (UnityCheckArraysForNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg) == 1)
- return;
-
- while (elements--)
- {
- diff = *ptr_expected - *ptr_actual;
- if (diff < 0.0f)
- diff = 0.0f - diff;
- tol = UNITY_FLOAT_PRECISION * *ptr_expected;
- if (tol < 0.0f)
- tol = 0.0f - tol;
-
- /* This first part of this condition will catch any NaN or Infinite values */
- if (isnan(diff) || isinf(diff) || (diff > tol))
- {
- UnityTestResultsFailBegin(lineNumber);
- UnityPrint(UnityStrElement);
- UnityPrintNumberUnsigned(num_elements - elements - 1);
-#ifdef UNITY_FLOAT_VERBOSE
- UnityPrint(UnityStrExpected);
- UnityPrintFloat(*ptr_expected);
- UnityPrint(UnityStrWas);
- UnityPrintFloat(*ptr_actual);
-#else
- UnityPrint(UnityStrDelta);
-#endif
- UnityAddMsgIfSpecified(msg);
- UNITY_OUTPUT_CHAR('\n');
- UNITY_FAIL_AND_BAIL;
- }
- ptr_expected++;
- ptr_actual++;
- }
-}
-
-/*-----------------------------------------------*/
-void UnityAssertFloatsWithin(const _UF delta,
- const _UF expected,
- const _UF actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber)
-{
- _UF diff = actual - expected;
- _UF pos_delta = delta;
-
- UNITY_SKIP_EXECUTION;
-
- if (diff < 0.0f)
- {
- diff = 0.0f - diff;
- }
- if (pos_delta < 0.0f)
- {
- pos_delta = 0.0f - pos_delta;
- }
-
- /* This first part of this condition will catch any NaN or Infinite values */
- if (isnan(diff) || isinf(diff) || (pos_delta < diff))
- {
- UnityTestResultsFailBegin(lineNumber);
-#ifdef UNITY_FLOAT_VERBOSE
- UnityPrint(UnityStrExpected);
- UnityPrintFloat(expected);
- UnityPrint(UnityStrWas);
- UnityPrintFloat(actual);
-#else
- UnityPrint(UnityStrDelta);
-#endif
- UnityAddMsgIfSpecified(msg);
- UNITY_OUTPUT_CHAR('\n');
- UNITY_FAIL_AND_BAIL;
- }
-}
-
-/*-----------------------------------------------*/
-void UnityAssertFloatSpecial(const _UF actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber,
- const UNITY_FLOAT_TRAIT_T style)
-{
- const char* trait_names[] = { UnityStrInf, UnityStrNegInf, UnityStrNaN, UnityStrDet };
- _U_SINT should_be_trait = ((_U_SINT)style & 1);
- _U_SINT is_trait = !should_be_trait;
- _U_SINT trait_index = (_U_SINT)(style >> 1);
-
- UNITY_SKIP_EXECUTION;
-
- switch(style)
- {
- /* To determine Inf / Neg Inf, we compare to an Inf / Neg Inf value we create on the fly
- * We are using a variable to hold the zero value because some compilers complain about dividing by zero otherwise */
- case UNITY_FLOAT_IS_INF:
- case UNITY_FLOAT_IS_NOT_INF:
- is_trait = isinf(actual) & ispos(actual);
- break;
- case UNITY_FLOAT_IS_NEG_INF:
- case UNITY_FLOAT_IS_NOT_NEG_INF:
- is_trait = isinf(actual) & isneg(actual);
- break;
-
- /* NaN is the only floating point value that does NOT equal itself. Therefore if Actual == Actual, then it is NOT NaN. */
- case UNITY_FLOAT_IS_NAN:
- case UNITY_FLOAT_IS_NOT_NAN:
- is_trait = isnan(actual);
- break;
-
- /* A determinate number is non infinite and not NaN. (therefore the opposite of the two above) */
- case UNITY_FLOAT_IS_DET:
- case UNITY_FLOAT_IS_NOT_DET:
- if (isinf(actual) | isnan(actual))
- is_trait = 0;
- else
- is_trait = 1;
- 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);
-#ifdef UNITY_FLOAT_VERBOSE
- UnityPrintFloat(actual);
-#else
- if (should_be_trait)
- UnityPrint(UnityStrNot);
- UnityPrint(trait_names[trait_index]);
-#endif
- UnityAddMsgIfSpecified(msg);
- UNITY_OUTPUT_CHAR('\n');
- UNITY_FAIL_AND_BAIL;
- }
-}
-
-#endif /* not UNITY_EXCLUDE_FLOAT */
-
-/*-----------------------------------------------*/
-#ifndef UNITY_EXCLUDE_DOUBLE
-void UnityAssertEqualDoubleArray(UNITY_PTR_ATTRIBUTE const _UD* expected,
- UNITY_PTR_ATTRIBUTE const _UD* actual,
- const _UU32 num_elements,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber)
-{
- _UU32 elements = num_elements;
- UNITY_PTR_ATTRIBUTE const _UD* ptr_expected = expected;
- UNITY_PTR_ATTRIBUTE const _UD* ptr_actual = actual;
- _UD diff, tol;
-
- UNITY_SKIP_EXECUTION;
-
- if (elements == 0)
- {
- UnityPrintPointlessAndBail();
- }
-
- if (UnityCheckArraysForNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg) == 1)
- return;
-
- while (elements--)
- {
- diff = *ptr_expected - *ptr_actual;
- if (diff < 0.0)
- diff = 0.0 - diff;
- tol = UNITY_DOUBLE_PRECISION * *ptr_expected;
- if (tol < 0.0)
- tol = 0.0 - tol;
-
- /* This first part of this condition will catch any NaN or Infinite values */
- if (isnan(diff) || isinf(diff) || (diff > tol))
- {
- UnityTestResultsFailBegin(lineNumber);
- UnityPrint(UnityStrElement);
- UnityPrintNumberUnsigned(num_elements - elements - 1);
-#ifdef UNITY_DOUBLE_VERBOSE
- UnityPrint(UnityStrExpected);
- UnityPrintFloat((float)(*ptr_expected));
- UnityPrint(UnityStrWas);
- UnityPrintFloat((float)(*ptr_actual));
-#else
- UnityPrint(UnityStrDelta);
-#endif
- UnityAddMsgIfSpecified(msg);
- UNITY_OUTPUT_CHAR('\n');
- UNITY_FAIL_AND_BAIL;
- }
- ptr_expected++;
- ptr_actual++;
- }
-}
-
-/*-----------------------------------------------*/
-void UnityAssertDoublesWithin(const _UD delta,
- const _UD expected,
- const _UD actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber)
-{
- _UD diff = actual - expected;
- _UD pos_delta = delta;
-
- UNITY_SKIP_EXECUTION;
-
- if (diff < 0.0)
- {
- diff = 0.0 - diff;
- }
- if (pos_delta < 0.0)
- {
- pos_delta = 0.0 - pos_delta;
- }
-
- /* This first part of this condition will catch any NaN or Infinite values */
- if (isnan(diff) || isinf(diff) || (pos_delta < diff))
- {
- UnityTestResultsFailBegin(lineNumber);
-#ifdef UNITY_DOUBLE_VERBOSE
- UnityPrint(UnityStrExpected);
- UnityPrintFloat((float)expected);
- UnityPrint(UnityStrWas);
- UnityPrintFloat((float)actual);
-#else
- UnityPrint(UnityStrDelta);
-#endif
- UnityAddMsgIfSpecified(msg);
- UNITY_OUTPUT_CHAR('\n');
- UNITY_FAIL_AND_BAIL;
- }
-}
-
-/*-----------------------------------------------*/
-
-void UnityAssertDoubleSpecial(const _UD actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber,
- const UNITY_FLOAT_TRAIT_T style)
-{
- const char* trait_names[] = { UnityStrInf, UnityStrNegInf, UnityStrNaN, UnityStrDet };
- _U_SINT should_be_trait = ((_U_SINT)style & 1);
- _U_SINT is_trait = !should_be_trait;
- _U_SINT trait_index = (_U_SINT)(style >> 1);
-
- UNITY_SKIP_EXECUTION;
-
- switch(style)
- {
- /* To determine Inf / Neg Inf, we compare to an Inf / Neg Inf value we create on the fly
- * We are using a variable to hold the zero value because some compilers complain about dividing by zero otherwise */
- case UNITY_FLOAT_IS_INF:
- case UNITY_FLOAT_IS_NOT_INF:
- is_trait = isinf(actual) & ispos(actual);
- break;
- case UNITY_FLOAT_IS_NEG_INF:
- case UNITY_FLOAT_IS_NOT_NEG_INF:
- is_trait = isinf(actual) & isneg(actual);
- break;
-
- /* NaN is the only floating point value that does NOT equal itself. Therefore if Actual == Actual, then it is NOT NaN. */
- case UNITY_FLOAT_IS_NAN:
- case UNITY_FLOAT_IS_NOT_NAN:
- is_trait = isnan(actual);
- break;
-
- /* A determinate number is non infinite and not NaN. (therefore the opposite of the two above) */
- case UNITY_FLOAT_IS_DET:
- case UNITY_FLOAT_IS_NOT_DET:
- if (isinf(actual) | isnan(actual))
- is_trait = 0;
- else
- is_trait = 1;
- 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);
-#ifdef UNITY_DOUBLE_VERBOSE
- UnityPrintFloat(actual);
-#else
- if (should_be_trait)
- UnityPrint(UnityStrNot);
- UnityPrint(trait_names[trait_index]);
-#endif
- UnityAddMsgIfSpecified(msg);
- UNITY_OUTPUT_CHAR('\n');
- UNITY_FAIL_AND_BAIL;
- }
-}
-
-
-#endif /* not UNITY_EXCLUDE_DOUBLE */
-
-/*-----------------------------------------------*/
-void UnityAssertNumbersWithin( const _U_UINT delta,
- const _U_SINT expected,
- const _U_SINT actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber,
- const UNITY_DISPLAY_STYLE_T style)
-{
- UNITY_SKIP_EXECUTION;
-
- if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT)
- {
- if (actual > expected)
- Unity.CurrentTestFailed = ((_U_UINT)(actual - expected) > delta);
- else
- Unity.CurrentTestFailed = ((_U_UINT)(expected - actual) > delta);
- }
- else
- {
- if ((_U_UINT)actual > (_U_UINT)expected)
- Unity.CurrentTestFailed = ((_U_UINT)(actual - expected) > delta);
- else
- Unity.CurrentTestFailed = ((_U_UINT)(expected - actual) > delta);
- }
-
- if (Unity.CurrentTestFailed)
- {
- UnityTestResultsFailBegin(lineNumber);
- UnityPrint(UnityStrDelta);
- UnityPrintNumberByStyle((_U_SINT)delta, style);
- UnityPrint(UnityStrExpected);
- UnityPrintNumberByStyle(expected, style);
- UnityPrint(UnityStrWas);
- UnityPrintNumberByStyle(actual, style);
- UnityAddMsgIfSpecified(msg);
- UNITY_OUTPUT_CHAR('\n');
- UNITY_FAIL_AND_BAIL;
- }
-}
-
-/*-----------------------------------------------*/
-void UnityAssertEqualString(const char* expected,
- const char* actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber)
-{
- _UU32 i;
-
- UNITY_SKIP_EXECUTION;
-
- /* 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_OUTPUT_CHAR('\n');
- UNITY_FAIL_AND_BAIL;
- }
-}
-
-/*-----------------------------------------------*/
-void UnityAssertEqualStringLen(const char* expected,
- const char* actual,
- const _UU32 length,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber)
-{
- _UU32 i;
-
- UNITY_SKIP_EXECUTION;
-
- /* if both pointers not null compare the strings */
- if (expected && actual)
- {
- for (i = 0; (expected[i] || actual[i]) && i < length; 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_OUTPUT_CHAR('\n');
- UNITY_FAIL_AND_BAIL;
- }
-}
-
-
-/*-----------------------------------------------*/
-void UnityAssertEqualStringArray( const char** expected,
- const char** actual,
- const _UU32 num_elements,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber)
-{
- _UU32 i, j = 0;
-
- UNITY_SKIP_EXECUTION;
-
- /* if no elements, it's an error */
- if (num_elements == 0)
- {
- UnityPrintPointlessAndBail();
- }
-
- if (UnityCheckArraysForNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg) == 1)
- return;
-
- do
- {
- /* if both pointers not null compare the strings */
- if (expected[j] && actual[j])
- {
- for (i = 0; expected[j][i] || actual[j][i]; i++)
- {
- if (expected[j][i] != actual[j][i])
- {
- Unity.CurrentTestFailed = 1;
- break;
- }
- }
- }
- else
- { /* handle case of one pointers being null (if both null, test should pass) */
- if (expected[j] != actual[j])
- {
- Unity.CurrentTestFailed = 1;
- }
- }
-
- if (Unity.CurrentTestFailed)
- {
- UnityTestResultsFailBegin(lineNumber);
- if (num_elements > 1)
- {
- UnityPrint(UnityStrElement);
- UnityPrintNumberUnsigned(j);
- }
- UnityPrintExpectedAndActualStrings((const char*)(expected[j]), (const char*)(actual[j]));
- UnityAddMsgIfSpecified(msg);
- UNITY_OUTPUT_CHAR('\n');
- UNITY_FAIL_AND_BAIL;
- }
- } while (++j < num_elements);
-}
-
-/*-----------------------------------------------*/
-void UnityAssertEqualMemory( UNITY_INTERNAL_PTR expected,
- UNITY_INTERNAL_PTR actual,
- const _UU32 length,
- const _UU32 num_elements,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber)
-{
- 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;
- _UU32 elements = num_elements;
- _UU32 bytes;
-
- UNITY_SKIP_EXECUTION;
-
- if ((elements == 0) || (length == 0))
- {
- UnityPrintPointlessAndBail();
- }
-
- if (UnityCheckArraysForNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg) == 1)
- return;
-
- 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_OUTPUT_CHAR('\n');
- UNITY_FAIL_AND_BAIL;
- }
- ptr_exp = (UNITY_INTERNAL_PTR)((_UP)ptr_exp + 1);
- ptr_act = (UNITY_INTERNAL_PTR)((_UP)ptr_act + 1);
- }
- /* /////////////////////////////////// */
-
- }
-}
-
-/*-----------------------------------------------
- * Control Functions
- *-----------------------------------------------*/
-
-void UnityFail(const char* msg, const UNITY_LINE_TYPE line)
-{
- UNITY_SKIP_EXECUTION;
-
- UnityTestResultsBegin(Unity.TestFile, line);
- UnityPrintFail();
- 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_OUTPUT_CHAR('\n');
- UNITY_FAIL_AND_BAIL;
-}
-
-/*-----------------------------------------------*/
-void UnityIgnore(const char* msg, const UNITY_LINE_TYPE line)
-{
- UNITY_SKIP_EXECUTION;
-
- UnityTestResultsBegin(Unity.TestFile, line);
- UnityPrint(UnityStrIgnore);
- if (msg != NULL)
- {
- UNITY_OUTPUT_CHAR(':');
- UNITY_OUTPUT_CHAR(' ');
- UnityPrint(msg);
- }
- UNITY_OUTPUT_CHAR('\n');
- UNITY_IGNORE_AND_BAIL;
-}
-
-/*-----------------------------------------------*/
-#if defined(UNITY_WEAK_ATTRIBUTE)
- UNITY_WEAK_ATTRIBUTE void setUp(void) { }
- UNITY_WEAK_ATTRIBUTE void tearDown(void) { }
-#elif defined(UNITY_WEAK_PRAGMA)
-# pragma weak setUp
- void setUp(void) { }
-# pragma weak tearDown
- void tearDown(void) { }
-#endif
-/*-----------------------------------------------*/
-void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int FuncLineNum)
-{
- Unity.CurrentTestName = FuncName;
- Unity.CurrentTestLineNumber = (UNITY_LINE_TYPE)FuncLineNum;
- Unity.NumberOfTests++;
- UNITY_CLR_DETAILS();
- if (TEST_PROTECT())
- {
- setUp();
- Func();
- }
- if (TEST_PROTECT() && !(Unity.CurrentTestIgnored))
- {
- tearDown();
- }
- 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((_U_SINT)(Unity.NumberOfTests));
- UnityPrint(UnityStrResultsTests);
- UnityPrintNumber((_U_SINT)(Unity.TestFailures));
- UnityPrint(UnityStrResultsFailures);
- UnityPrintNumber((_U_SINT)(Unity.TestIgnores));
- UnityPrint(UnityStrResultsIgnored);
- UNITY_PRINT_EOL();
- if (Unity.TestFailures == 0U)
- {
- UnityPrintOk();
- }
- else
- {
- UnityPrintFail();
-#ifdef UNITY_DIFFERENTIATE_FINAL_FAIL
- UNITY_OUTPUT_CHAR('E'); UNITY_OUTPUT_CHAR('D');
-#endif
- }
- UNITY_PRINT_EOL();
- UNITY_OUTPUT_FLUSH();
- UNITY_OUTPUT_COMPLETE();
- return (int)(Unity.TestFailures);
-}
-
-/*-----------------------------------------------*/
-#include <stdio.h>
-#include "freertos/FreeRTOS.h"
-#include "freertos/task.h"
-#include "unity.h"
-#include "unity_config.h"
-
-void unityTask(void *pvParameters)
-{
- vTaskDelay(2); /* Delay a bit to let the main task be deleted */
- unity_run_menu(); /* Doesn't return */
-}
+#include "test_utils.h"
void app_main()
{
- // Note: if unpinning this task, change the way run times are calculated in
- // unity_platform
- xTaskCreatePinnedToCore(unityTask, "unityTask", UNITY_FREERTOS_STACK_SIZE, NULL,
- UNITY_FREERTOS_PRIORITY, NULL, UNITY_FREERTOS_CPU);
+ test_main();
}
projects / esp-idf / commitdiff