Merge branch 'feature/unit_test_example' into 'master'

Move Unity into components, add unit test example See merge request idf/esp-idf!3562
2018-11-19 18:35:54 +08:00 · 2018-11-19 18:35:54 +08:00 · a46b884a14
parent 6709d26863 a5adfd0169
commit a46b884a14
93 changed files with 1212 additions and 2936 deletions
--- a/.gitmodules
+++ b/.gitmodules
@ -61,3 +61,6 @@
 [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
--- a/components/app_update/test/CMakeLists.txt
+++ b/components/app_update/test/CMakeLists.txt
@ -1,6 +1,6 @@
 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()
--- a/components/driver/test/CMakeLists.txt
+++ b/components/driver/test/CMakeLists.txt
@ -1,6 +1,6 @@
 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()
--- a/components/driver/test/test_spi_master.c
+++ b/components/driver/test/test_spi_master.c
@ -23,7 +23,7 @@
 #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";

@ -1595,4 +1595,4 @@ TEST_CASE("spi poll tasks","[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
+//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
--- a/components/esp32/include/esp_clk.h
+++ b/components/esp32/include/esp_clk.h
@ -13,6 +13,7 @@
 // limitations under the License.

 #pragma once
+#include <stdint.h>

 /**
 * @file esp_clk.h
--- a/components/esp32/include/rom/uart.h
+++ b/components/esp32/include/rom/uart.h
@ -36,7 +36,7 @@ extern "C" {
 #define RX_BUFF_SIZE                     0x100
 #define TX_BUFF_SIZE                     100

-//uart int enalbe register ctrl bits
+//uart int enable register ctrl bits
 #define UART_RCV_INTEN                   BIT0
 #define UART_TRX_INTEN                   BIT1
 #define UART_LINE_STATUS_INTEN           BIT2
@ -301,14 +301,14 @@ char uart_rx_one_char_block(void);
  *
  * @param  uint8_t *pString : the pointer to store the string.
  *
-  * @param  uint8_t MaxStrlen : the max string length, incude '\0'.
+  * @param  uint8_t MaxStrlen : the max string length, include '\0'.
  *
  * @return OK.
  */
 STATUS UartRxString(uint8_t *pString, uint8_t MaxStrlen);

 /**
-  * @brief Process uart recevied information in the interrupt handler.
+  * @brief Process uart received information in the interrupt handler.
  *        Please do not call this function in SDK.
  *
  * @param  void *para : the message receive buffer.
--- a/components/esp32/test/CMakeLists.txt
+++ b/components/esp32/test/CMakeLists.txt
@ -1,7 +1,7 @@
 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()

--- a/components/esp32/test/test_aes_sha_rsa.c
+++ b/components/esp32/test/test_aes_sha_rsa.c
@ -10,6 +10,7 @@
 #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"
--- a/components/esp32/test/test_dport.c
+++ b/components/esp32/test/test_dport.c
@ -9,10 +9,12 @@
 #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;
--- a/components/esp32/test/test_sleep.c
+++ b/components/esp32/test/test_sleep.c
@ -16,6 +16,7 @@
 #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
--- a/components/esp_event/test/CMakeLists.txt
+++ b/components/esp_event/test/CMakeLists.txt
@ -1,5 +1,5 @@
 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()
--- a/components/esp_event/test/test_event.c
+++ b/components/esp_event/test/test_event.c
@ -18,7 +18,7 @@
 #include "sdkconfig.h"
 #include "unity.h"

-#include "idf_performance.h"
+#include "test_utils.h"

 static const char* TAG = "test_event";

--- a/components/esp_http_server/test/CMakeLists.txt
+++ b/components/esp_http_server/test/CMakeLists.txt
@ -1,6 +1,6 @@
 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()
--- a/components/esp_ringbuf/test/CMakeLists.txt
+++ b/components/esp_ringbuf/test/CMakeLists.txt
@ -1,6 +1,6 @@
 set(COMPONENT_SRCDIRS ".")
 set(COMPONENT_ADD_INCLUDEDIRS ".")

-set(COMPONENT_REQUIRES unity)
+set(COMPONENT_REQUIRES unity test_utils)

 register_component()
--- a/components/esp_ringbuf/test/test_ringbuf.c
+++ b/components/esp_ringbuf/test/test_ringbuf.c
@ -8,6 +8,7 @@
 #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
--- a/components/fatfs/test/CMakeLists.txt
+++ b/components/fatfs/test/CMakeLists.txt
@ -1,7 +1,7 @@
 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)

--- a/components/freertos/test/CMakeLists.txt
+++ b/components/freertos/test/CMakeLists.txt
@ -1,6 +1,6 @@
 set(COMPONENT_SRCDIRS ".")
 set(COMPONENT_ADD_INCLUDEDIRS ".")

-set(COMPONENT_REQUIRES unity)
+set(COMPONENT_REQUIRES unity test_utils)

 register_component()
--- a/components/freertos/test/test_freertos_backported_functions.c
+++ b/components/freertos/test/test_freertos_backported_functions.c
@ -27,6 +27,7 @@
 #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()
--- a/components/freertos/test/test_freertos_debug_functions.c
+++ b/components/freertos/test/test_freertos_debug_functions.c
@ -12,6 +12,7 @@
 #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
--- a/components/freertos/test/test_freertos_get_state.c
+++ b/components/freertos/test/test_freertos_get_state.c
@ -4,6 +4,7 @@
 #include "freertos/task.h"
 #include "freertos/semphr.h"
 #include "unity.h"
+#include "test_utils.h"

 #define TSK_PRIORITY    (UNITY_FREERTOS_PRIORITY + 1)

--- a/components/freertos/test/test_freertos_task_delete.c
+++ b/components/freertos/test/test_freertos_task_delete.c
@ -20,6 +20,7 @@
 #include "rom/ets_sys.h"

 #include "unity.h"
+#include "test_utils.h"

 #define NO_OF_TSKS  3
 #define DELAY_TICKS 2
--- a/components/freertos/test/test_freertos_task_notify.c
+++ b/components/freertos/test/test_freertos_task_notify.c
@ -13,6 +13,7 @@
 #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
--- a/components/freertos/test/test_freertos_trace_utilities.c
+++ b/components/freertos/test/test_freertos_trace_utilities.c
@ -15,6 +15,7 @@
 #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)
--- a/components/freertos/test/test_preemption.c
+++ b/components/freertos/test/test_preemption.c
@ -13,6 +13,7 @@
 #include "freertos/xtensa_api.h"
 #include "unity.h"
 #include "soc/cpu.h"
+#include "test_utils.h"

 static volatile bool trigger;
 static volatile bool flag;
--- a/components/freertos/test/test_spinlocks.c
+++ b/components/freertos/test/test_spinlocks.c
@ -17,7 +17,7 @@
 #include "soc/io_mux_reg.h"
 #include "soc/cpu.h"

-#include "idf_performance.h"
+#include "test_utils.h"

 #define REPEAT_OPS 10000

--- a/components/freertos/test/test_suspend_scheduler.c
+++ b/components/freertos/test/test_suspend_scheduler.c
@ -8,6 +8,7 @@
 #include "freertos/xtensa_api.h"
 #include "unity.h"
 #include "soc/cpu.h"
+#include "test_utils.h"

 #include "driver/timer.h"

--- a/components/freertos/test/test_task_priorities.c
+++ b/components/freertos/test/test_task_priorities.c
@ -9,6 +9,7 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "unity.h"
+#include "test_utils.h"


 static void counter_task(void *param)
--- a/components/freertos/test/test_task_suspend_resume.c
+++ b/components/freertos/test/test_task_suspend_resume.c
@ -8,6 +8,7 @@
 #include "freertos/xtensa_api.h"
 #include "unity.h"
 #include "soc/cpu.h"
+#include "test_utils.h"

 #include "driver/timer.h"

--- a/components/freertos/test/test_thread_local.c
+++ b/components/freertos/test/test_thread_local.c
@ -8,6 +8,7 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "unity.h"
+#include "test_utils.h"
 #include "sdkconfig.h"

 static __thread int tl_test_var1;
--- a/components/heap/test/CMakeLists.txt
+++ b/components/heap/test/CMakeLists.txt
@ -1,6 +1,6 @@
 set(COMPONENT_SRCDIRS ".")
 set(COMPONENT_ADD_INCLUDEDIRS ".")

-set(COMPONENT_REQUIRES unity)
+set(COMPONENT_REQUIRES unity test_utils)

 register_component()
--- a/components/idf_test/include/idf_performance.h
+++ b/components/idf_test/include/idf_performance.h
@ -1,12 +1,4 @@
-
-/* @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
--- a/components/mbedtls/test/CMakeLists.txt
+++ b/components/mbedtls/test/CMakeLists.txt
@ -1,6 +1,6 @@
 set(COMPONENT_SRCDIRS ".")
 set(COMPONENT_ADD_INCLUDEDIRS ".")

-set(COMPONENT_REQUIRES unity mbedtls)
+set(COMPONENT_REQUIRES unity test_utils mbedtls)

 register_component()
--- a/components/mbedtls/test/test_apb_dport_access.c
+++ b/components/mbedtls/test/test_apb_dport_access.c
@ -8,6 +8,7 @@
 #include "freertos/task.h"
 #include "soc/uart_reg.h"
 #include "test_apb_dport_access.h"
+#include "test_utils.h"

 #ifndef CONFIG_FREERTOS_UNICORE

--- a/components/newlib/test/CMakeLists.txt
+++ b/components/newlib/test/CMakeLists.txt
@ -1,6 +1,6 @@
 set(COMPONENT_SRCDIRS ".")
 set(COMPONENT_ADD_INCLUDEDIRS ".")

-set(COMPONENT_REQUIRES unity)
+set(COMPONENT_REQUIRES unity test_utils)

 register_component()
--- a/components/newlib/test/test_time.c
+++ b/components/newlib/test/test_time.c
@ -12,6 +12,7 @@
 #include "soc/rtc.h"
 #include "esp_clk.h"
 #include "esp_system.h"
+#include "test_utils.h"

 #if portNUM_PROCESSORS == 2

--- a/components/nvs_flash/test/CMakeLists.txt
+++ b/components/nvs_flash/test/CMakeLists.txt
@ -1,6 +1,6 @@
 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()
--- a/components/partition_table/test/CMakeLists.txt
+++ b/components/partition_table/test/CMakeLists.txt
@ -1,6 +1,6 @@
 set(COMPONENT_SRCDIRS ".")
 set(COMPONENT_ADD_INCLUDEDIRS ".")

-set(COMPONENT_REQUIRES unity)
+set(COMPONENT_REQUIRES unity test_utils)

 register_component()
--- a/components/pthread/test/CMakeLists.txt
+++ b/components/pthread/test/CMakeLists.txt
@ -1,6 +1,6 @@
 set(COMPONENT_SRCDIRS ".")
 set(COMPONENT_ADD_INCLUDEDIRS ".")

-set(COMPONENT_REQUIRES unity pthread)
+set(COMPONENT_REQUIRES unity test_utils pthread)

 register_component()
--- a/components/pthread/test/test_pthread_local_storage.c
+++ b/components/pthread/test/test_pthread_local_storage.c
@ -3,6 +3,7 @@
 #include "unity.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
+#include "test_utils.h"

 TEST_CASE("pthread local storage basics", "[pthread]")
 {
--- a/components/soc/test/CMakeLists.txt
+++ b/components/soc/test/CMakeLists.txt
@ -3,7 +3,7 @@ if(EXISTS "../${SOC_NAME}/test")
    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()
--- a/components/spi_flash/test/CMakeLists.txt
+++ b/components/spi_flash/test/CMakeLists.txt
@ -1,6 +1,6 @@
 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()
--- a/components/spi_flash/test/test_spi_flash.c
+++ b/components/spi_flash/test/test_spi_flash.c
@ -8,6 +8,7 @@
 #include <esp_attr.h>
 #include "driver/timer.h"
 #include "esp_intr_alloc.h"
+#include "test_utils.h"

 struct flash_test_ctx {
    uint32_t offset;
--- a/components/spiffs/test/CMakeLists.txt
+++ b/components/spiffs/test/CMakeLists.txt
@ -1,6 +1,6 @@
 set(COMPONENT_SRCDIRS ".")
 set(COMPONENT_ADD_INCLUDEDIRS ".")

-set(COMPONENT_REQUIRES unity spiffs)
+set(COMPONENT_REQUIRES unity test_utils spiffs)

 register_component()
--- a/components/unity/CMakeLists.txt
+++ b/components/unity/CMakeLists.txt
@ -0,0 +1,23 @@
+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()
--- a/components/unity/Kconfig
+++ b/components/unity/Kconfig
@ -0,0 +1,45 @@
+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"
--- a/components/unity/Makefile.projbuild
+++ b/components/unity/Makefile.projbuild
@ -0,0 +1 @@
+CPPFLAGS += -DUNITY_INCLUDE_CONFIG_H
--- a/components/unity/component.mk
+++ b/components/unity/component.mk
@ -0,0 +1,21 @@
+#
+# 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
--- a/components/unity/include/unity_config.h
+++ b/components/unity/include/unity_config.h
@ -0,0 +1,53 @@
+#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_IDF_TEST_RUNNER
+
+#include "unity_test_runner.h"
+
+#endif //CONFIG_UNITY_ENABLE_IDF_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
--- a/tools/unit-test-app/components/unity/include/unity_config.h
+++ b/tools/unit-test-app/components/unity/include/unity_config.h
@ -1,26 +1,25 @@
-#ifndef UNITY_CONFIG_H
-#define UNITY_CONFIG_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

-// This file gets included from unity.h via unity_internals.h
+#include <stdint.h>
+#include <stdbool.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)
@ -56,7 +55,7 @@

 typedef void (* test_func)(void);

-struct test_desc_t
+typedef struct test_desc_t
 {
    const char* name;
    const char* desc;
@ -66,26 +65,21 @@ struct test_desc_t
    uint8_t test_fn_count;
    const char ** test_fn_name;
    struct test_desc_t* next;
-};
+} test_desc_t;

-void unity_testcase_register(struct test_desc_t* desc);
+void unity_testcase_register(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_) \
@ -93,7 +87,7 @@ void unity_run_all_tests();
    static void __attribute__((constructor)) UNITY_TEST_UID(test_reg_helper_) () \
    { \
        static test_func test_fn_[] = {&UNITY_TEST_UID(test_func_)}; \
-        static struct test_desc_t UNITY_TEST_UID(test_desc_) = { \
+        static test_desc_t UNITY_TEST_UID(test_desc_) = { \
            .name = name_, \
            .desc = desc_, \
            .fn = test_fn_, \
@ -123,7 +117,7 @@ void unity_run_all_tests();
    UNITY_TEST_FN_SET(__VA_ARGS__); \
    static void __attribute__((constructor)) UNITY_TEST_UID(test_reg_helper_) () \
    { \
-        static struct test_desc_t UNITY_TEST_UID(test_desc_) = { \
+        static test_desc_t UNITY_TEST_UID(test_desc_) = { \
            .name = name_, \
            .desc = desc_"[multi_stage]", \
            .fn = UNITY_TEST_UID(test_functions), \
@ -148,7 +142,7 @@ void unity_run_all_tests();
    UNITY_TEST_FN_SET(__VA_ARGS__); \
    static void __attribute__((constructor)) UNITY_TEST_UID(test_reg_helper_) () \
    { \
-        static struct test_desc_t UNITY_TEST_UID(test_desc_) = { \
+        static test_desc_t UNITY_TEST_UID(test_desc_) = { \
            .name = name_, \
            .desc = desc_"[multi_device]", \
            .fn = UNITY_TEST_UID(test_functions), \
@ -170,9 +164,11 @@ void unity_run_all_tests();
 * 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)
+void unity_run_test_by_name(const char *name);

+void unity_run_tests_by_tag(const char *tag, bool invert);
+
+void unity_run_all_tests();
+
+void unity_run_menu();

-#endif //UNITY_CONFIG_H
--- a/components/unity/unity
+++ b/components/unity/unity
@ -0,0 +1 @@
+Subproject commit 7d2bf62b7e6afaf38153041a9d53c21aeeca9a25
--- a/components/unity/unity_port_esp32.c
+++ b/components/unity/unity_port_esp32.c
@ -0,0 +1,66 @@
+// 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);
+}
--- a/components/unity/unity_runner.c
+++ b/components/unity/unity_runner.c
@ -0,0 +1,279 @@
+// 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 <stdbool.h>
+#include <ctype.h>
+#include <stdio.h>
+#include "unity.h"
+
+/* similar to UNITY_PRINT_EOL */
+#define UNITY_PRINT_TAB() UNITY_OUTPUT_CHAR('\t')
+
+// Pointers to the head and tail of linked list of test description structs:
+static test_desc_t *s_unity_tests_first = NULL;
+static test_desc_t *s_unity_tests_last = NULL;
+
+void unity_testcase_register(test_desc_t *desc)
+{
+    if (!s_unity_tests_first) {
+        s_unity_tests_first = desc;
+        s_unity_tests_last = desc;
+    } else {
+        test_desc_t *temp = s_unity_tests_first;
+        s_unity_tests_first = desc;
+        s_unity_tests_first->next = temp;
+    }
+}
+
+/* print the multiple function case name and its sub-menu
+ * e.g:
+ * (1) spi master/slave case
+ *       (1)master case
+ *       (2)slave case
+ * */
+static void print_multiple_function_test_menu(const test_desc_t *test_ms)
+{
+    UnityPrint(test_ms->name);
+    UNITY_PRINT_EOL();
+    for (int i = 0; i < test_ms->test_fn_count; i++) {
+        UNITY_PRINT_TAB();
+        UnityPrint("(");
+        UnityPrintNumberUnsigned(i + 1);
+        UnityPrint(")");
+        UNITY_PRINT_TAB();
+        UnityPrint("\"");
+        UnityPrint(test_ms->test_fn_name[i]);
+        UnityPrint("\"");
+        UNITY_PRINT_EOL();
+    }
+}
+
+static void multiple_function_option(const test_desc_t *test_ms)
+{
+    int selection;
+    char cmdline[256] = {0};
+
+    print_multiple_function_test_menu(test_ms);
+    while (strlen(cmdline) == 0) {
+        unity_gets(cmdline, sizeof(cmdline));
+        if (strlen(cmdline) == 0) {
+            /* if input was newline, print a new menu */
+            print_multiple_function_test_menu(test_ms);
+        }
+    }
+    selection = atoi((const char *) cmdline) - 1;
+    if (selection >= 0 && selection < test_ms->test_fn_count) {
+        UnityDefaultTestRun(test_ms->fn[selection], test_ms->name, test_ms->line);
+    } else {
+        UnityPrint("Invalid selection, your should input number 1-");
+        UnityPrintNumber(test_ms->test_fn_count);
+        UNITY_PRINT_EOL();
+    }
+}
+
+static void unity_run_single_test(const test_desc_t *test)
+{
+    UnityPrint("Running ");
+    UnityPrint(test->name);
+    UnityPrint("...");
+    UNITY_PRINT_EOL();
+    // Unit test runner expects to see test name before the test starts
+    UNITY_OUTPUT_FLUSH();
+
+    Unity.TestFile = test->file;
+    Unity.CurrentDetail1 = test->desc;
+    if (test->test_fn_count == 1) {
+        UnityDefaultTestRun(test->fn[0], test->name, test->line);
+    } else {
+        multiple_function_option(test);
+    }
+}
+
+static void unity_run_single_test_by_index(int index)
+{
+    const test_desc_t *test;
+    for (test = s_unity_tests_first; test != NULL && index != 0; test = test->next, --index) {
+        ;
+    }
+    if (test != NULL) {
+        unity_run_single_test(test);
+    }
+}
+
+static void unity_run_single_test_by_index_parse(const char *filter, int index_max)
+{
+    int test_index = strtol(filter, NULL, 10);
+    if (test_index >= 1 && test_index <= index_max) {
+        UNITY_EXEC_TIME_START();
+        unity_run_single_test_by_index(test_index - 1);
+        UNITY_EXEC_TIME_STOP();
+        UnityPrint("Test ran in ");
+        UnityPrintNumberUnsigned(UNITY_EXEC_TIME_MS());
+        UnityPrint("ms");
+        UNITY_PRINT_EOL();
+        UNITY_OUTPUT_FLUSH();
+    }
+}
+
+void unity_run_test_by_name(const char *name)
+{
+    for (const test_desc_t *test = s_unity_tests_first; test != NULL; test = test->next) {
+        if (strcmp(test->name, name) == 0) {
+            unity_run_single_test(test);
+        }
+    }
+}
+
+void unity_run_all_tests()
+{
+    for (const test_desc_t *test = s_unity_tests_first; test != NULL; test = test->next) {
+        unity_run_single_test(test);
+    }
+}
+
+void unity_run_tests_by_tag(const char *tag, bool invert)
+{
+    UnityPrint("Running tests ");
+    if (invert) {
+        UnityPrint("NOT ");
+    }
+    UnityPrint("matching '");
+    UnityPrint(tag);
+    UnityPrint("'...");
+    UNITY_PRINT_EOL();
+
+    for (const test_desc_t *test = s_unity_tests_first; test != NULL; test = test->next) {
+        if ((strstr(test->desc, tag) != NULL) == !invert) {
+            unity_run_single_test(test);
+        }
+    }
+}
+
+static void trim_trailing_space(char *str)
+{
+    char *end = str + strlen(str) - 1;
+    while (end >= str && isspace((int) *end)) {
+        *end = 0;
+        --end;
+    }
+}
+
+static int print_test_menu(void)
+{
+    int test_counter = 0;
+    UNITY_PRINT_EOL();
+    UNITY_PRINT_EOL();
+    UnityPrint("Here's the test menu, pick your combo:");
+    UNITY_PRINT_EOL();
+    for (const test_desc_t *test = s_unity_tests_first;
+            test != NULL;
+            test = test->next, ++test_counter) {
+
+        UnityPrint("(");
+        UnityPrintNumber(test_counter + 1);
+        UnityPrint(")");
+        UNITY_PRINT_TAB();
+        UnityPrint("\"");
+        UnityPrint(test->name);
+        UnityPrint("\" ");
+        UnityPrint(test->desc);
+        UNITY_PRINT_EOL();
+
+        if (test->test_fn_count > 1) {
+            for (int i = 0; i < test->test_fn_count; i++) {
+                UNITY_PRINT_TAB();
+                UnityPrint("(");
+                UnityPrintNumber(i + 1);
+                UnityPrint(")");
+                UNITY_PRINT_TAB();
+                UnityPrint("\"");
+                UnityPrint(test->test_fn_name[i]);
+                UnityPrint("\"");
+                UNITY_PRINT_EOL();
+            }
+        }
+    }
+    UNITY_PRINT_EOL();
+    UnityPrint("Enter test for running."); /* unit_test.py needs it for finding the end of test menu */
+    UNITY_PRINT_EOL();
+    UNITY_OUTPUT_FLUSH();
+    return test_counter;
+}
+
+static int get_test_count(void)
+{
+    int test_counter = 0;
+    for (const test_desc_t *test = s_unity_tests_first;
+            test != NULL;
+            test = test->next) {
+        ++test_counter;
+    }
+    return test_counter;
+}
+
+void unity_run_menu()
+{
+    UNITY_PRINT_EOL();
+    UNITY_PRINT_EOL();
+    UnityPrint("Press ENTER to see the list of tests.");
+    UNITY_PRINT_EOL();
+    int test_count = get_test_count();
+    while (true) {
+        char cmdline[256] = { 0 };
+        while (strlen(cmdline) == 0) {
+            unity_gets(cmdline, sizeof(cmdline));
+            trim_trailing_space(cmdline);
+            if (strlen(cmdline) == 0) {
+                /* if input was newline, print a new menu */
+                print_test_menu();
+            }
+        }
+        /*use '-' to show test history. Need to do it before UNITY_BEGIN cleanup history */
+        if (cmdline[0] == '-') {
+            UNITY_END();
+            continue;
+        }
+
+        UNITY_BEGIN();
+
+        size_t idx = 0;
+        bool invert = false;
+        if (cmdline[idx] == '!') {
+            invert = true;
+            ++idx;
+        }
+
+        if (cmdline[idx] == '*') {
+            unity_run_all_tests();
+        } else if (cmdline[idx] == '[') {
+            unity_run_tests_by_tag(cmdline + idx, invert);
+        } else if (cmdline[idx] == '"') {
+            char* end = strrchr(cmdline, '"');
+            if (end > &cmdline[idx]) {
+                *end = 0;
+                unity_run_test_by_name(cmdline + idx + 1);
+            }
+        } else if (isdigit((unsigned char)cmdline[idx])) {
+            unity_run_single_test_by_index_parse(cmdline + idx, test_count);
+        }
+
+        UNITY_END();
+
+        UnityPrint("Enter next test, or 'enter' to see menu");
+        UNITY_PRINT_EOL();
+        UNITY_OUTPUT_FLUSH();
+    }
+}
--- a/components/vfs/test/CMakeLists.txt
+++ b/components/vfs/test/CMakeLists.txt
@ -1,6 +1,6 @@
 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()
--- a/components/vfs/test/test_vfs_fd.c
+++ b/components/vfs/test/test_vfs_fd.c
@ -23,6 +23,7 @@
 #include "esp_vfs.h"
 #include "unity.h"
 #include "esp_log.h"
+#include "test_utils.h"

 #define VFS_PREF1       "/vfs1"
 #define VFS_PREF2       "/vfs2"
--- a/components/vfs/vfs_uart.c
+++ b/components/vfs/vfs_uart.c
@ -26,6 +26,7 @@
 #include "driver/uart.h"
 #include "sdkconfig.h"
 #include "driver/uart_select.h"
+#include "rom/uart.h"

 // TODO: make the number of UARTs chip dependent
 #define UART_NUM 3
@ -304,6 +305,15 @@ static int uart_access(const char *path, int amode)
    return ret;
 }

+static int uart_fsync(int fd)
+{
+    assert(fd >= 0 && fd < 3);
+    _lock_acquire_recursive(&s_uart_write_locks[fd]);
+    uart_tx_wait_idle((uint8_t) fd);
+    _lock_release_recursive(&s_uart_write_locks[fd]);
+    return 0;
+}
+
 static void select_notif_callback(uart_port_t uart_num, uart_select_notif_t uart_select_notif, BaseType_t *task_woken)
 {
    switch (uart_select_notif) {
@ -883,6 +893,7 @@ void esp_vfs_dev_uart_register()
        .close = &uart_close,
        .read = &uart_read,
        .fcntl = &uart_fcntl,
+        .fsync = &uart_fsync,
        .access = &uart_access,
        .start_select = &uart_start_select,
        .end_select = &uart_end_select,
--- a/components/wear_levelling/test/CMakeLists.txt
+++ b/components/wear_levelling/test/CMakeLists.txt
@ -1,7 +1,7 @@
 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)

--- a/examples/system/unit_test/CMakeLists.txt
+++ b/examples/system/unit_test/CMakeLists.txt
@ -0,0 +1,5 @@
+# This is the project CMakeLists.txt file for the test subproject 
+cmake_minimum_required(VERSION 3.5)
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+project(unit_test)
--- a/examples/system/unit_test/Makefile
+++ b/examples/system/unit_test/Makefile
@ -0,0 +1,8 @@
+#
+# This is a project Makefile for the example project.
+# See 'test' subdirectory for the test subproject.
+#
+
+PROJECT_NAME := unit_test
+
+include $(IDF_PATH)/make/project.mk
--- a/examples/system/unit_test/README.md
+++ b/examples/system/unit_test/README.md
@ -0,0 +1,178 @@
+# Unit Testing
+
+(See the README.md file in the upper level 'examples' directory for more information about examples.)
+
+This example demonstrates how to use [Unity](https://github.com/ThrowTheSwitch/Unity) library to add unit tests to custom components. Two features of the Unity library are used in this example:
+
+* _Assertions_ (`TEST_ASSERT` and similar) are used when writing the test cases. See [the reference](https://github.com/ThrowTheSwitch/Unity/blob/master/docs/UnityAssertionsReference.md) for more information about assertions.
+
+* `UNITY_BEGIN()` and `UNITY_END()` macros allow Unity to count the number of tests which have passed or failed, and display the summary.
+
+In addition to features of Unity, this example demonstrates _test registration_ feature of ESP-IDF. This feature works when unit test functions are declared using `TEST_CASE` macro. Such functions from all the object files in the program are automatically collected into a list, and run-time facilities are provided to run functions from this list. The example demonstrates usage of `TEST_CASE` macro and of the functions which execute registered tests.
+
+_Note: It is also possible to use built-in Unity facility, unity_fixture.h, to declare and execute the tests. However this is out scope of the current example. Refer to [Unity example_2](https://github.com/ThrowTheSwitch/Unity/tree/master/examples/example_2) for details._
+
+## Project layout
+
+```
+unit_test                      — Application project directory
+  - components                 — Components of the application project
+    + testable
+  + main                       - Main source files of the application project
+  + test                       — Test project directory
+  Makefile / CMakeLists.txt    - Makefiles of the application project
+```
+
+The layout of this example resembles a layout of a real project which has custom components in its `components/` directory. In this case this is the component called `testable`. In addition to `components/`, `main/` and `Makefile` / `CMakeLists.txt`, this project includes a *test project* in its *test* subdirectory.
+
+The purpose of two projects is to implement different application behavior when running normally, and when running the unit tests. Top level project is the actual application being developed. Test project included within is a simple application which only runs the unit tests.
+
+## Unit tests for a component
+
+Inside the `testable` component, unit tests are added into `test` directory. `test` directory contains source files of the tests and the component makefile (component.mk / CMakeLists.txt).
+
+```
+unit_test
+  - components                              - Components of the application project
+    - testable
+      - include
+      - test                                - Test directory of the component
+        * component.mk / CMakeLists.txt     - Component makefile of tests
+        * test_mean.c                       - Test source file
+      * component.mk / CMakeLists.txt       - Component makefile
+      * mean.c                              - Component source file
+```
+
+When the main application project is compiled, tests are not included. Test project includes the tests by setting `TEST_COMPONENTS` variable in the project makefile.
+
+## How to use example
+
+### Hardware required
+
+This example doesn't require any special hardware, and can run on any ESP32 development board.
+
+### Configure the project
+
+As explained above, this example contains two projects: application project and test project.
+
+When using Make based build system, run `make menuconfig` and set serial port under Serial Flasher Options, in each of these projects.
+
+For the test project, you can explore a few options related to Unity under Component Config, Unity unit testing library.
+
+### Build and flash
+
+As explained above, this example contains two projects: application project and test project.
+
+1. Application project calls an API defined in the component, and displays the results. It is not of much value to run. Application project is provided mainly to illustrate the layout of all the files. If you decide to run this project, the procedure is:
+
+    * Run `make -j4 flash monitor` in the current directory (`unit_test`), or `idf.py -p PORT flash monitor` if you are using CMake build system.
+    * Observe the output: a list of random numbers and their mean value.
+
+2. Test project is responsible for running the tests.
+
+	* Enter `test` directory (`unit_test/test`), and run `make -j4 flash monitor`, or `idf.py -p PORT flash monitor` if you are using CMake build system.
+	* Observe the output: results of test case execution.
+
+
+To exit the serial monitor, type ``Ctrl-]``.
+
+See the Getting Started Guide for full steps to configure and use ESP-IDF to build projects.
+
+
+## Example output
+
+### Application project output
+
+```
+In main application. Collecting 32 random numbers from 1 to 100:
+   5   66   86   98   62   66   40   42    7   62 
+  33   77   40   54    8   75   39   82   73    4 
+  22    5   72   78   53    1    6   48   23    1 
+  84   55 
+Mean: 45
+```
+
+### Test project output
+
+```
+#### Executing one test by its name #####
+
+Running Mean of an empty array is zero...
+/Users/ivan/e/esp-idf/examples/system/unit_test/components/testable/test/test_mean.c:16:Mean of an empty array is zero:PASS
+
+-----------------------
+1 Tests 0 Failures 0 Ignored 
+OK
+
+#### Running tests with [mean] tag #####
+
+Running tests matching '[mean]'...
+Running Mean of an empty array is zero...
+/Users/ivan/e/esp-idf/examples/system/unit_test/components/testable/test/test_mean.c:16:Mean of an empty array is zero:PASS
+Running Mean of a test vector...
+/Users/ivan/e/esp-idf/examples/system/unit_test/components/testable/test/test_mean.c:22:Mean of a test vector:PASS
+Running Another test case which fails...
+/Users/ivan/e/esp-idf/examples/system/unit_test/components/testable/test/test_mean.c:35:Another test case which fails:FAIL: Expected 2147483647 Was -1
+
+-----------------------
+3 Tests 1 Failures 0 Ignored 
+FAIL
+
+#### Running tests without [fails] tag #####
+
+Running tests NOT matching '[fails]'...
+Running Mean of an empty array is zero...
+/Users/ivan/e/esp-idf/examples/system/unit_test/components/testable/test/test_mean.c:16:Mean of an empty array is zero:PASS
+Running Mean of a test vector...
+/Users/ivan/e/esp-idf/examples/system/unit_test/components/testable/test/test_mean.c:22:Mean of a test vector:PASS
+
+-----------------------
+2 Tests 0 Failures 0 Ignored 
+OK
+
+#### Running all the registered tests #####
+
+Running Mean of an empty array is zero...
+/Users/ivan/e/esp-idf/examples/system/unit_test/components/testable/test/test_mean.c:16:Mean of an empty array is zero:PASS
+Running Mean of a test vector...
+/Users/ivan/e/esp-idf/examples/system/unit_test/components/testable/test/test_mean.c:22:Mean of a test vector:PASS
+Running Another test case which fails...
+/Users/ivan/e/esp-idf/examples/system/unit_test/components/testable/test/test_mean.c:35:Another test case which fails:FAIL: Expected 2147483647 Was -1
+
+-----------------------
+3 Tests 1 Failures 0 Ignored 
+FAIL
+```
+
+This is the initial example output. At this point, press ENTER key to get the list of tests:
+
+```
+Here's the test menu, pick your combo:
+(1)	"Mean of an empty array is zero" [mean]
+(2)	"Mean of some test vectors" [mean]
+
+Enter test for running.
+```
+
+This is the test menu, which is launched by `unity_run_menu` function in the test project. It allows running the tests in a few ways:
+
+* Run specific test by its index: type the number and press ENTER.
+* Run a group of tests with a certain tag: type the tag, including square brackets, and press ENTER.
+* Run all tests except the ones with a certain tag: press `!`, then type the tag, including the square brackets, then press ENTER.
+* Run test with a specific name: type the name of the test, including quotes, and press ENTER.
+* Run all the tests: press `*` and then ENTER.
+
+Note that the test menu prompt does not echo back the characters typed.
+
+For example, the output when typing `1` and then `ENTER` will be:
+
+```
+Running Mean of an empty array is zero...
+/home/user/esp/esp-idf/examples/system/unit_test/components/testable/test/test_mean.c:15:Mean of an empty array is zero:PASS
+Test ran in 16ms
+
+-----------------------
+1 Tests 0 Failures 0 Ignored 
+OK
+Enter next test, or 'enter' to see menu
+```
--- a/examples/system/unit_test/components/testable/CMakeLists.txt
+++ b/examples/system/unit_test/components/testable/CMakeLists.txt
@ -0,0 +1,4 @@
+set(COMPONENT_SRCS "mean.c")
+set(COMPONENT_ADD_INCLUDEDIRS "include")
+
+register_component()
--- a/examples/system/unit_test/components/testable/component.mk
+++ b/examples/system/unit_test/components/testable/component.mk
--- a/examples/system/unit_test/components/testable/include/testable.h
+++ b/examples/system/unit_test/components/testable/include/testable.h
@ -0,0 +1,18 @@
+/* testable.h: Implementation of a testable component.
+
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+*/
+
+#pragma once
+
+/**
+ * @brief Calculate arithmetic mean of integer values
+ * @param values  array of values
+ * @param count   number of elements in the array
+ * @return arithmetic mean of values, or zero count is zero
+ */
+int testable_mean(const int* values, int count);
--- a/examples/system/unit_test/components/testable/mean.c
+++ b/examples/system/unit_test/components/testable/mean.c
@ -0,0 +1,24 @@
+/* mean.c: Implementation of a mean function of testable component.
+   See test/test_mean.c for the associated unit test.
+
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+*/
+
+#include "testable.h"
+
+
+int testable_mean(const int* values, int count)
+{
+    if (count == 0) {
+        return 0;
+    }
+    int sum = 0;
+    for (int i = 0; i < count; ++i) {
+        sum += values[i];
+    }
+    return sum / count;
+}
--- a/examples/system/unit_test/components/testable/test/CMakeLists.txt
+++ b/examples/system/unit_test/components/testable/test/CMakeLists.txt
@ -0,0 +1,6 @@
+set(COMPONENT_SRCDIRS ".")
+set(COMPONENT_ADD_INCLUDEDIRS ".")
+
+set(COMPONENT_REQUIRES unity testable)
+
+register_component()
--- a/examples/system/unit_test/components/testable/test/component.mk
+++ b/examples/system/unit_test/components/testable/test/component.mk
@ -0,0 +1,7 @@
+# This is the minimal test component makefile.
+#
+# The following line is needed to force the linker to include all the object
+# files into the application, even if the functions in these object files
+# are not referenced from outside (which is usually the case for unit tests).
+# 
+COMPONENT_ADD_LDFLAGS = -Wl,--whole-archive -l$(COMPONENT_NAME) -Wl,--no-whole-archive
--- a/examples/system/unit_test/components/testable/test/test_mean.c
+++ b/examples/system/unit_test/components/testable/test/test_mean.c
@ -0,0 +1,36 @@
+/* test_mean.c: Implementation of a testable component.
+
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+*/
+
+#include <limits.h>
+#include "unity.h"
+#include "testable.h"
+
+#define countof(x) (sizeof(x)/sizeof(x[0]))
+
+TEST_CASE("Mean of an empty array is zero", "[mean]")
+{
+    const int values[] = { 0 };
+    TEST_ASSERT_EQUAL(0, testable_mean(values, 0));
+}
+
+TEST_CASE("Mean of a test vector", "[mean]")
+{
+    const int v[] = {1, 3, 5, 7, 9};
+    TEST_ASSERT_EQUAL(5, testable_mean(v, countof(v)));
+}
+
+/* This test case currently fails, and developer has added a tag to indicate this.
+ * For the test runner, "[fails]" string does not carry any special meaning.
+ * However it can be used to filter out tests when running.
+ */
+TEST_CASE("Another test case which fails", "[mean][fails]")
+{
+    const int v1[] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
+    TEST_ASSERT_EQUAL(INT_MAX, testable_mean(v1, countof(v1)));
+}
--- a/examples/system/unit_test/main/CMakeLists.txt
+++ b/examples/system/unit_test/main/CMakeLists.txt
@ -0,0 +1,4 @@
+set(COMPONENT_SRCS "example_unit_test_main.c")
+set(COMPONENT_ADD_INCLUDEDIRS ".")
+
+register_component()
--- a/examples/system/unit_test/main/component.mk
+++ b/examples/system/unit_test/main/component.mk
--- a/examples/system/unit_test/main/example_unit_test_main.c
+++ b/examples/system/unit_test/main/example_unit_test_main.c
@ -0,0 +1,40 @@
+/* Example application which uses testable component.
+
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+*/
+
+#include <stdio.h>
+#include "esp_system.h"
+#include "testable.h"
+
+/* This application has a test subproject in 'test' directory, all the
+ * interesting things happen there. See ../test/main/example_idf_test_runner_test.c
+ * and the makefiles in ../test/ directory.
+ *
+ * This specific app_main function is provided only to illustrate the layout
+ * of a project.
+ */
+
+void app_main(void)
+{
+    const int count = 32;
+    const int max = 100;
+
+    printf("In main application. Collecting %d random numbers from 1 to %d:\n", count, max);
+    int *numbers = calloc(count, sizeof(numbers[0]));
+    for (int i = 0; i < count; ++i) {
+        numbers[i] = 1 + esp_random() % (max - 1);
+        printf("%4d ", numbers[i]);
+        if ((i + 1) % 10 == 0) {
+            printf("\n");
+        }
+    }
+
+    int mean = testable_mean(numbers, count);
+    printf("\nMean: %d\n", mean);
+    free(numbers);
+}
--- a/examples/system/unit_test/test/CMakeLists.txt
+++ b/examples/system/unit_test/test/CMakeLists.txt
@ -0,0 +1,16 @@
+# This is the project CMakeLists.txt file for the test subproject 
+cmake_minimum_required(VERSION 3.5)
+
+# Include the components directory of the main application:
+#
+set(EXTRA_COMPONENT_DIRS "../components")
+
+# Set the components to include the tests for.
+# This can be overriden from CMake cache:
+# - when invoking CMake directly: cmake -D TEST_COMPONENTS="xxxxx" ..
+# - when using idf.py: idf.py build -T xxxxx
+#
+set(TEST_COMPONENTS "testable" CACHE STRING "List of components to test")
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+project(unit_test_test)
--- a/examples/system/unit_test/test/Makefile
+++ b/examples/system/unit_test/test/Makefile
@ -0,0 +1,17 @@
+#
+# This is a project Makefile for the test subproject.
+#
+
+PROJECT_NAME := unit_test_test
+
+# Include the components directory of the main application:
+#
+EXTRA_COMPONENT_DIRS := $(realpath ../components)
+
+# Set the components to include the tests for.
+# This can be overriden from the command line
+# (e.g. 'make TEST_COMPONENTS=xxxx flash monitor')
+#
+TEST_COMPONENTS ?= testable
+
+include $(IDF_PATH)/make/project.mk
--- a/examples/system/unit_test/test/main/CMakeLists.txt
+++ b/examples/system/unit_test/test/main/CMakeLists.txt
@ -0,0 +1,4 @@
+set(COMPONENT_SRCS "example_unit_test_test.c")
+set(COMPONENT_ADD_INCLUDEDIRS ".")
+
+register_component()
--- a/examples/system/unit_test/test/main/component.mk
+++ b/examples/system/unit_test/test/main/component.mk
--- a/examples/system/unit_test/test/main/example_unit_test_test.c
+++ b/examples/system/unit_test/test/main/example_unit_test_test.c
@ -0,0 +1,55 @@
+/* Example test application for testable component.
+
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+*/
+
+#include <stdio.h>
+#include <string.h>
+#include "unity.h"
+
+static void print_banner(const char* text);
+
+void app_main()
+{
+    /* These are the different ways of running registered tests.
+     * In practice, only one of them is usually needed.
+     *
+     * UNITY_BEGIN() and UNITY_END() calls tell Unity to print a summary
+     * (number of tests executed/failed/ignored) of tests executed between these calls.
+     */
+    print_banner("Executing one test by its name");
+    UNITY_BEGIN();
+    unity_run_test_by_name("Mean of an empty array is zero");
+    UNITY_END();
+
+    print_banner("Running tests with [mean] tag");
+    UNITY_BEGIN();
+    unity_run_tests_by_tag("[mean]", false);
+    UNITY_END();
+
+    print_banner("Running tests without [fails] tag");
+    UNITY_BEGIN();
+    unity_run_tests_by_tag("[fails]", true);
+    UNITY_END();
+
+    print_banner("Running all the registered tests");
+    UNITY_BEGIN();
+    unity_run_all_tests();
+    UNITY_END();
+
+    print_banner("Starting interactive test menu");
+    /* This function will not return, and will be busy waiting for UART input.
+     * Make sure that task watchdog is disabled if you use this function.
+     */
+    unity_run_menu();
+}
+
+static void print_banner(const char* text)
+{
+    printf("\n#### %s #####\n\n", text);
+}
+
--- a/examples/system/unit_test/test/sdkconfig.defaults
+++ b/examples/system/unit_test/test/sdkconfig.defaults
@ -0,0 +1 @@
+CONFIG_TASK_WDT=
--- a/tools/ci/build_example_dirs.txt
+++ b/tools/ci/build_example_dirs.txt
@ -0,0 +1,5 @@
+# Each line specifies the location of project makefile, and the corresponding
+# directory which should be used as example root directory when copying the
+# example for building it out of tree.
+#
+examples/system/unit_test/test/Makefile	examples/system/unit_test
--- a/tools/ci/build_examples.sh
+++ b/tools/ci/build_examples.sh
@ -108,11 +108,24 @@ build_example () {

    local EXAMPLE_DIR=$(dirname "${MAKE_FILE}")
    local EXAMPLE_NAME=$(basename "${EXAMPLE_DIR}")
+    
+    # Check if the example needs a different base directory.
+    # Path of the Makefile relative to $IDF_PATH
+    local MAKE_FILE_REL=${MAKE_FILE#"${IDF_PATH}/"}
+    # Look for it in build_example_dirs.txt:
+    local COPY_ROOT_REL=$(sed -n -E "s|${MAKE_FILE_REL}[[:space:]]+(.*)|\1|p" < ${IDF_PATH}/tools/ci/build_example_dirs.txt)
+    if [[ -n "${COPY_ROOT_REL}" && -d "${IDF_PATH}/${COPY_ROOT_REL}/" ]]; then
+        local COPY_ROOT=${IDF_PATH}/${COPY_ROOT_REL}
+    else
+        local COPY_ROOT=${EXAMPLE_DIR}
+    fi

    echo "Building ${EXAMPLE_NAME} as ${ID}..."
    mkdir -p "example_builds/${ID}"
-    cp -r "${EXAMPLE_DIR}" "example_builds/${ID}"
-    pushd "example_builds/${ID}/${EXAMPLE_NAME}"
+    cp -r "${COPY_ROOT}" "example_builds/${ID}"
+    local COPY_ROOT_PARENT=$(dirname ${COPY_ROOT})
+    local EXAMPLE_DIR_REL=${EXAMPLE_DIR#"${COPY_ROOT_PARENT}"}
+    pushd "example_builds/${ID}/${EXAMPLE_DIR_REL}"
        # be stricter in the CI build than the default IDF settings
        export EXTRA_CFLAGS="-Werror -Werror=deprecated-declarations"
        export EXTRA_CXXFLAGS=${EXTRA_CFLAGS}
@ -142,7 +155,7 @@ build_example () {

 EXAMPLE_NUM=0

-find ${IDF_PATH}/examples/ -type f -name Makefile | sort | \
+find ${IDF_PATH}/examples -type f -name Makefile | sort | \
 while read FN
 do
    if [[ $EXAMPLE_NUM -lt $START_NUM || $EXAMPLE_NUM -ge $END_NUM ]]
--- a/tools/ci/mirror-list.txt
+++ b/tools/ci/mirror-list.txt
@ -16,3 +16,4 @@ third-party/mruby                                   @GENERAL_MIRROR_SERVER@/idf/
 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
--- a/tools/unit-test-app/components/test_utils/CMakeLists.txt
+++ b/tools/unit-test-app/components/test_utils/CMakeLists.txt
@ -0,0 +1,9 @@
+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()
+
--- a/tools/unit-test-app/components/test_utils/Kconfig
+++ b/tools/unit-test-app/components/test_utils/Kconfig
@ -1,4 +1,4 @@
-menu "Unity test framework"
+menu "IDF unit test"

 config UNITY_FREERTOS_PRIORITY
 	int "Priority of Unity test task"
--- a/tools/unit-test-app/components/test_utils/component.mk
+++ b/tools/unit-test-app/components/test_utils/component.mk
--- a/tools/unit-test-app/components/test_utils/include/test_utils.h
+++ b/tools/unit-test-app/components/test_utils/include/test_utils.h
@ -1,4 +1,4 @@
-// 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.
@ -17,6 +17,39 @@

 #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.
@ -43,6 +76,12 @@ void ref_clock_deinit();
 */
 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.
--- a/tools/unit-test-app/components/test_utils/ref_clock.c
+++ b/tools/unit-test-app/components/test_utils/ref_clock.c
--- a/tools/unit-test-app/components/test_utils/test_runner.c
+++ b/tools/unit-test-app/components/test_utils/test_runner.c
@ -0,0 +1,126 @@
+// 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
+}
+
--- a/tools/unit-test-app/components/test_utils/test_utils.c
+++ b/tools/unit-test-app/components/test_utils/test_utils.c
--- a/tools/unit-test-app/components/unity/CMakeLists.txt
+++ b/tools/unit-test-app/components/unity/CMakeLists.txt
@ -1,10 +0,0 @@
-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()
--- a/tools/unit-test-app/components/unity/component.mk
+++ b/tools/unit-test-app/components/unity/component.mk
@ -1,7 +0,0 @@
-#
-# Component Makefile
-#
-
-ifeq ($(GCC_NOT_5_2_0), 1)
-unity.o: CFLAGS += -Wno-unused-const-variable
-endif
--- a/tools/unit-test-app/components/unity/include/unity.h
+++ b/tools/unit-test-app/components/unity/include/unity.h
@ -1,309 +0,0 @@
-/* ==========================================
-    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
--- a/tools/unit-test-app/components/unity/include/unity_internals.h
+++ b/tools/unit-test-app/components/unity/include/unity_internals.h
@ -1,772 +0,0 @@
-/* ==========================================
-    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
--- a/tools/unit-test-app/components/unity/license.txt
+++ b/tools/unit-test-app/components/unity/license.txt
@ -1,21 +0,0 @@
-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.
--- a/tools/unit-test-app/components/unity/unity.c
+++ b/tools/unit-test-app/components/unity/unity.c
--- a/tools/unit-test-app/components/unity/unity_platform.c
+++ b/tools/unit-test-app/components/unity/unity_platform.c
@ -1,394 +0,0 @@
-#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"
-
-#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;
-static struct test_desc_t* s_unity_tests_last = 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)
-    {
-        s_unity_tests_first = desc;
-        s_unity_tests_last = desc;
-    }
-    else
-    {
-        struct test_desc_t* temp = s_unity_tests_first;
-        s_unity_tests_first = desc;
-        s_unity_tests_first->next = temp;
-    }
-}
-
-/* print the multiple function case name and its sub-menu
- * e.g:
- * (1) spi master/slave case
- *       (1)master case
- *       (2)slave case
- * */
-static void print_multiple_function_test_menu(const struct test_desc_t* test_ms)
- {
-    printf("%s\n", test_ms->name);
-    for (int i = 0; i < test_ms->test_fn_count; i++)
-    {
-        printf("\t(%d)\t\"%s\"\n", i+1, test_ms->test_fn_name[i]);
-    }
- }
-
-void multiple_function_option(const struct test_desc_t* test_ms)
-{
-    int selection;
-    char cmdline[256] = {0};
-
-    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);
-        if(strlen(cmdline) == 0) {
-            /* if input was newline, print a new menu */
-            print_multiple_function_test_menu(test_ms);
-        }
-    }
-    selection = atoi((const char *) cmdline) - 1;
-    if(selection >= 0 && selection < test_ms->test_fn_count) {
-        UnityDefaultTestRun(test_ms->fn[selection], test_ms->name, test_ms->line);
-    } else {
-        printf("Invalid selection, your should input number 1-%d!", test_ms->test_fn_count);
-    }
-}
-
-static void unity_run_single_test(const struct test_desc_t* test)
-{
-    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.TestFile = test->file;
-    Unity.CurrentDetail1 = test->desc;
-    if(test->test_fn_count == 1) {
-        UnityDefaultTestRun(test->fn[0], test->name, test->line);
-    } else {
-        multiple_function_option(test);
-    }
-}
-
-static void unity_run_single_test_by_index(int index)
-{
-    const struct test_desc_t* test;
-    for (test = s_unity_tests_first; test != NULL && index != 0; test = test->next, --index)
-    {
-
-    }
-    if (test != NULL)
-    {
-        unity_run_single_test(test);
-    }
-}
-
-static void unity_run_single_test_by_index_parse(const char* filter, int index_max)
-{
-    if (s_invert)
-    {
-        printf("Inverse is not supported for that kind of filter\n");
-        return;
-    }
-    int test_index = strtol(filter, NULL, 10);
-    if (test_index >= 1 && test_index <= index_max)
-    {
-        uint32_t start;
-        RSR(CCOUNT, start);
-        unity_run_single_test_by_index(test_index - 1);
-        uint32_t end;
-        RSR(CCOUNT, end);
-        uint32_t ms = (end - start) / (esp_clk_cpu_freq() / 1000);
-        printf("Test ran in %dms\n", ms);
-    }
-}
-
-static void unity_run_single_test_by_name(const char* filter)
-{
-    if (s_invert)
-    {
-        printf("Inverse is not supported for that kind of filter\n");
-        return;
-    }
-    char tmp[256];
-    strncpy(tmp, filter + 1, sizeof(tmp) - 1);
-    tmp[strlen(filter) - 2] = 0;
-    for (const struct test_desc_t* test = s_unity_tests_first; test != NULL; test = test->next)
-    {
-        if (strcmp(test->name, tmp) == 0)
-        {
-            unity_run_single_test(test);
-        }
-    }
-}
-
-void unity_run_all_tests()
-{
-    if (s_invert)
-    {
-        printf("Inverse is not supported for that kind of filter\n");
-        return;
-    }
-    for (const struct test_desc_t* test = s_unity_tests_first; test != NULL; test = test->next)
-    {
-        unity_run_single_test(test);
-    }
-}
-
-void unity_run_tests_with_filter(const char* filter)
-{
-    if (s_invert)
-    {
-        ++filter;
-    }
-    printf("Running tests %smatching '%s'...\n", s_invert ? "NOT " : "", filter);
-
-    for (const struct test_desc_t* test = s_unity_tests_first; test != NULL; test = test->next)
-    {
-        if ((strstr(test->desc, filter) != NULL) == !s_invert)
-        {
-            unity_run_single_test(test);
-        }
-    }
-}
-
-static void trim_trailing_space(char* str)
-{
-    char* end = str + strlen(str) - 1;
-    while (end >= str && isspace((int) *end))
-    {
-        *end = 0;
-        --end;
-    }
-}
-
-static int print_test_menu(void)
-{
-    int test_counter = 0;
-    printf("\n\nHere's the test menu, pick your combo:\n");
-    for (const struct test_desc_t* test = s_unity_tests_first;
-         test != NULL;
-         test = test->next, ++test_counter)
-    {
-        printf("(%d)\t\"%s\" %s\n", test_counter + 1, test->name, test->desc);
-        if(test->test_fn_count > 1)
-        {
-            for (int i = 0; i < test->test_fn_count; i++)
-            {
-                printf("\t(%d)\t\"%s\"\n", i+1, test->test_fn_name[i]);
-            }
-         }
-     }
-     printf("\nEnter test for running.\n"); /* unit_test.py needs it for finding the end of test menu */
-     return test_counter;
-}
-
-static int get_test_count(void)
-{
-    int test_counter = 0;
-    for (const struct test_desc_t* test = s_unity_tests_first;
-         test != NULL;
-         test = test->next)
-    {
-        ++test_counter;
-    }
-    return test_counter;
-}
-
-void unity_run_menu()
-{
-    printf("\n\nPress ENTER to see the list of tests.\n");
-    int test_count = get_test_count();
-    while (true)
-    {
-        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);
-            trim_trailing_space(cmdline);
-            if(strlen(cmdline) == 0) {
-                /* if input was newline, print a new menu */
-                print_test_menu();
-            }
-        }
-        /*use '-' to show test history. Need to do it before UNITY_BEGIN cleanup history */
-        if (cmdline[0] == '-')
-        {
-            UNITY_END();
-            continue;
-        }
-
-        UNITY_BEGIN();
-
-        size_t idx = 0;
-        if (cmdline[idx] == '!')
-        {
-            s_invert = true;
-            ++idx;
-        }
-        else
-        {
-            s_invert = false;
-        }
-
-        if (cmdline[idx] == '*')
-        {
-            unity_run_all_tests();
-        }
-        else if (cmdline[idx] =='[')
-        {
-            unity_run_tests_with_filter(cmdline + idx);
-        }
-        else if (cmdline[idx] =='"')
-        {
-            unity_run_single_test_by_name(cmdline + idx);
-        }
-        else if (isdigit((unsigned char)cmdline[idx]))
-        {
-            unity_run_single_test_by_index_parse(cmdline + idx, test_count);
-        }
-
-        UNITY_END();
-
-        printf("Enter next test, or 'enter' to see menu\n");
-    }
-}
--- a/tools/unit-test-app/main/app_main.c
+++ b/tools/unit-test-app/main/app_main.c
@ -1,19 +1,6 @@
-#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();
 }
				`@ -0,0 +1 @@`
				`Subproject commit 7d2bf62b7e6afaf38153041a9d53c21aeeca9a25`