change(test_utils): moved test_utils component to tools/test_apps/components/

tools/test_apps/components/test_utils/include/test_utils.h

@@ -0,0 +1,240 @@
+/*
+ * SPDX-FileCopyrightText: 2015-2021 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+// Utilities for esp-idf unit tests
+
+#include <stdint.h>
+#include <esp_partition.h>
+#include "sdkconfig.h"
+#include "unity.h"
+#include "soc/soc_caps.h"
+/* include performance pass standards header file */
+#include "idf_performance.h"
+#include "idf_performance_target.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* 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.
+ */
+
+//macros call this to expand an argument instead of directly converting into str
+#define PERFORMANCE_STR(s)   #s
+//macros call this to contact strings after expanding them
+#define PERFORMANCE_CON(a, b) _PERFORMANCE_CON(a, b)
+#define _PERFORMANCE_CON(a, b) a##b
+
+#if !CONFIG_UNITY_IGNORE_PERFORMANCE_TESTS
+#define _TEST_PERFORMANCE_ASSERT TEST_ASSERT
+#else
+#define _TEST_PERFORMANCE_ASSERT(ARG) printf("Ignoring performance test [%s]\n", PERFORMANCE_STR(ARG))
+#endif
+
+#define TEST_PERFORMANCE_LESS_THAN(name, value_fmt, value, ...)  do { \
+    IDF_LOG_PERFORMANCE(#name, value_fmt, value, ##__VA_ARGS__); \
+    _TEST_PERFORMANCE_ASSERT(value < PERFORMANCE_CON(IDF_PERFORMANCE_MAX_, name)); \
+} while(0)
+
+#define TEST_PERFORMANCE_GREATER_THAN(name, value_fmt, value, ...)  do { \
+    IDF_LOG_PERFORMANCE(#name, value_fmt, value, ##__VA_ARGS__); \
+    _TEST_PERFORMANCE_ASSERT(value > PERFORMANCE_CON(IDF_PERFORMANCE_MIN_, name)); \
+} while(0)
+
+/* Macros to be used when performance is calculated using the cache compensated timer
+   will not assert if ccomp not supported */
+#if SOC_CCOMP_TIMER_SUPPORTED
+#define TEST_PERFORMANCE_CCOMP_GREATER_THAN(name, value_fmt, value, ...) \
+    TEST_PERFORMANCE_GREATER_THAN(name, value_fmt, value, ##__VA_ARGS__)
+#define TEST_PERFORMANCE_CCOMP_LESS_THAN(name, value_fmt, value, ...) \
+    TEST_PERFORMANCE_LESS_THAN(name, value_fmt, value, ##__VA_ARGS__)
+#else
+#define TEST_PERFORMANCE_CCOMP_GREATER_THAN(name, value_fmt, value, ...) \
+    IDF_LOG_PERFORMANCE(#name, value_fmt, value, ##__VA_ARGS__)
+#define TEST_PERFORMANCE_CCOMP_LESS_THAN(name, value_fmt, value, ...) \
+    IDF_LOG_PERFORMANCE(#name, value_fmt, value, ##__VA_ARGS__)
+#endif //SOC_CCOMP_TIMER_SUPPORTED
+
+
+/* @brief macro to print IDF performance
+ * @param item :        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, ##__VA_ARGS__)
+
+
+/* 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.
+*/
+const esp_partition_t *get_test_data_partition(void);
+
+/**
+ * @brief Initialize reference clock
+ *
+ * Reference clock provides timestamps at constant 1 MHz frequency, even when
+ * the APB frequency is changing.
+ */
+void ref_clock_init(void);
+
+/**
+ * @brief Deinitialize reference clock
+ */
+void ref_clock_deinit(void);
+
+
+/**
+ * @brief Get reference clock timestamp
+ * @return number of microseconds since the reference clock was initialized
+ */
+uint64_t ref_clock_get(void);
+
+/**
+ * @brief Entry point of the test application
+ *
+ * Starts Unity test runner in a separate task and returns.
+ */
+void test_main(void);
+
+void unity_reset_leak_checks(void);
+
+
+/**
+ * @brief Call this function from a test case which requires TCP/IP or
+ * LWIP functionality.
+ *
+ * @note This should be the first function the test case calls, as it will
+ * allocate memory on first use (and also reset the test case leak checker).
+ */
+void test_case_uses_tcpip(void);
+
+/**
+ * @brief wait for signals with parameters.
+ *
+ * for multiple devices test cases, DUT might need to wait for other DUTs before continue testing.
+ * As all DUTs are independent, need user (or test script) interaction to make test synchronized.
+ *
+ * Here we provide signal functions for this.
+ * For example, we're testing GPIO, DUT1 has one pin connect to with DUT2.
+ * DUT2 will output high level and then DUT1 will read input.
+ * DUT1 should call `unity_wait_for_signal("output high level");` before it reads input.
+ * DUT2 should call `unity_send_signal("output high level");` after it finished setting output high level.
+ * According to the console logs:
+ *
+ * DUT1 console:
+ *
+ * ```
+ *     Waiting for signal: [output high level]!
+ *     Please press "Enter" key to once any board send this signal.
+ * ```
+ *
+ * DUT2 console:
+ *
+ * ```
+ *     Send signal: [output high level]!
+ * ```
+ *
+ * Then we press Enter key on DUT1's console, DUT1 starts to read input and then test success.
+ *
+ * Another example, we have 2 DUTs in multiple devices test, and DUT1 need to get DUT2's mac address to perform BT connection.
+ * DUT1 should call `unity_wait_for_signal_param("dut2 mac address", mac, 19);` to wait for DUT2's mac address.
+ * DUT2 should call `unity_send_signal_param("dut2 mac address", "10:20:30:40:50:60");` to send to DUT1 its mac address.
+ * According to the console logs:
+ *
+ * DUT1 console:
+ *
+ * ```
+ *     Waiting for signal: [dut2 mac address]!
+ *     Please input parameter value from any board send this signal and press "Enter" key.
+ * ```
+ *
+ * DUT2 console:
+ *
+ * ```
+ *     Send signal: [dut2 mac address][10:20:30:40:50:60]!
+ * ```
+ *
+ * @param signal_name signal name which DUT expected to wait before proceed testing
+ * @param parameter_buf buffer to receive parameter
+ * @param buf_len length of parameter_buf.
+ *                Currently we have a limitation that it will write 1 extra byte at the end of string.
+ *                We need to use a buffer with 2 bytes longer than actual string length.
+ */
+void unity_wait_for_signal_param(const char* signal_name, char *parameter_buf, uint8_t buf_len);
+
+/**
+ * @brief wait for signals.
+ *
+ * @param signal_name signal name which DUT expected to wait before proceed testing
+ */
+static inline void unity_wait_for_signal(const char* signal_name)
+{
+    unity_wait_for_signal_param(signal_name, NULL, 0);
+}
+
+/**
+ * @brief DUT send signal and pass parameter to other devices.
+ *
+ * @param signal_name signal name which DUT send once it finished preparing.
+ * @param parameter a string to let remote device to receive.
+ */
+void unity_send_signal_param(const char* signal_name, const char *parameter);
+
+/**
+ * @brief DUT send signal with parameter.
+ *
+ * @param signal_name signal name which DUT send once it finished preparing.
+ */
+static inline void unity_send_signal(const char* signal_name)
+{
+    unity_send_signal_param(signal_name, NULL);
+}
+
+/**
+ * @brief convert mac string to mac address
+ *
+ * @param mac_str MAC address string with format "xx:xx:xx:xx:xx:xx"
+ * @param[out] mac_addr store converted MAC address
+ */
+bool unity_util_convert_mac_from_string(const char* mac_str, uint8_t *mac_addr);
+
+typedef struct test_utils_exhaust_memory_record_s *test_utils_exhaust_memory_rec;
+
+/**
+ * Limit the largest free block of memory with a particular capability set to
+ * 'limit' bytes (meaning an allocation of 'limit' should succeed at least once,
+ * but any allocation of more bytes will fail.)
+ *
+ * Returns a record pointer which needs to be passed back in to test_utils_free_exhausted_memory
+ * before the test completes, to avoid a major memory leak.
+ *
+ * @param caps Capabilities of memory to exhause
+ * @param limit The size to limit largest free block to
+ * @return Record pointer to pass to test_utils_free_exhausted_memory() once done
+ */
+test_utils_exhaust_memory_rec test_utils_exhaust_memory(uint32_t caps, size_t limit);
+
+
+/**
+ * Call to free memory which was taken up by test_utils_exhaust_memory() call
+ *
+ * @param rec Result previously returned from test_utils_exhaust_memory()
+ */
+void test_utils_free_exhausted_memory(test_utils_exhaust_memory_rec rec);
+
+#ifdef __cplusplus
+}
+#endif