mirror of
https://github.com/espressif/esp-idf.git
synced 2024-10-05 20:47:46 -04:00
feee3a3059
This commit refactors the OS startup functions as follows:
- Moved the OS/app startup functions listed below to "app_startup.c". Their
implementations are now common to all ports (RISC-V and Xtensa) of all
FreeRTOS implementations (IDF and Amazon SMP).
- esp_startup_start_app()
- esp_startup_start_app_other_cores()
- Removed esp_startup_start_app_common() as app startup functions are now
already common to all ports.
- Added extra logs to "main_task" to help with user debugging
Note: Increased startup delay on "unity_task". The "unity_run_menu()" is non
blocking, thus if the main task or other startup tasks have not been freed
by the time "unity_run_menu()" is run, those tasks will be freed the next time
"unity_task" blocks. This could cause some tests to have a memory leak, thus
the "unity_task" startup delay has increased.
138 lines
4.6 KiB
C
138 lines
4.6 KiB
C
/*
|
|
* SPDX-FileCopyrightText: 2015-2021 Espressif Systems (Shanghai) CO LTD
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include "string.h"
|
|
#include "esp_heap_caps.h"
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/task.h"
|
|
#include "unity.h"
|
|
#include "unity_test_runner.h"
|
|
#include "test_utils.h"
|
|
#include "esp_newlib.h"
|
|
#include "memory_checks.h"
|
|
|
|
#ifdef CONFIG_HEAP_TRACING
|
|
#include "esp_heap_trace.h"
|
|
#endif
|
|
|
|
static void unity_task(void *pvParameters)
|
|
{
|
|
// Delay a bit to let the main task and any other startup tasks be deleted
|
|
vTaskDelay(pdMS_TO_TICKS(50));
|
|
// Start running unity (prints test menu and doesn't return)
|
|
unity_run_menu();
|
|
}
|
|
|
|
void test_main(void)
|
|
{
|
|
// 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);
|
|
}
|
|
|
|
/* setUp runs before every test */
|
|
void setUp(void)
|
|
{
|
|
// If heap tracing is enabled in kconfig, leak trace the test
|
|
#ifdef CONFIG_HEAP_TRACING
|
|
setup_heap_record();
|
|
#endif
|
|
|
|
printf("%s", ""); /* sneakily lazy-allocate the reent structure for this test task */
|
|
|
|
#ifdef CONFIG_APP_BUILD_USE_FLASH_SECTIONS
|
|
/* TODO: add sufficient startup code in case of building an ELF file, so that
|
|
* flash cache is initialized and can work in such mode.
|
|
* For now this is disabled to allow running unit tests which don't require
|
|
* flash cache related operations.
|
|
*/
|
|
get_test_data_partition(); /* allocate persistent partition table structures */
|
|
#endif // CONFIG_APP_BUILD_USE_FLASH_SECTIONS
|
|
|
|
#ifdef CONFIG_HEAP_TRACING
|
|
heap_trace_start(HEAP_TRACE_LEAKS);
|
|
#endif
|
|
test_utils_record_free_mem();
|
|
test_utils_set_leak_level(CONFIG_UNITY_CRITICAL_LEAK_LEVEL_GENERAL, ESP_LEAK_TYPE_CRITICAL, ESP_COMP_LEAK_GENERAL);
|
|
test_utils_set_leak_level(CONFIG_UNITY_WARN_LEAK_LEVEL_GENERAL, ESP_LEAK_TYPE_WARNING, ESP_COMP_LEAK_GENERAL);
|
|
}
|
|
|
|
typedef enum {
|
|
NO_LEAK_CHECK,
|
|
DEFAULT_LEAK_CHECK,
|
|
SPECIAL_LEAK_CHECK
|
|
} leak_check_type_t;
|
|
|
|
/**
|
|
* It is possible to specify the maximum allowed memory leak level directly in the test case
|
|
* or disable leak checking for a test case.
|
|
* This function checks if this is the case and return the appropriate return value.
|
|
* If a custom leak level has been specified, that custom threshold is written to the value pointed by threshold.
|
|
*/
|
|
static leak_check_type_t leak_check_required(size_t *threshold)
|
|
{
|
|
if (Unity.CurrentDetail1 != NULL) {
|
|
const char *leaks = "[leaks";
|
|
const int len_leaks = strlen(leaks);
|
|
const char *sub_leaks = strstr(Unity.CurrentDetail1, leaks);
|
|
if (sub_leaks != NULL) {
|
|
if (sub_leaks[len_leaks] == ']') {
|
|
return NO_LEAK_CHECK;
|
|
} else if (sub_leaks[len_leaks] == '=') {
|
|
*threshold = strtol(&sub_leaks[len_leaks + 1], NULL, 10);
|
|
return SPECIAL_LEAK_CHECK;
|
|
}
|
|
}
|
|
}
|
|
return DEFAULT_LEAK_CHECK;
|
|
}
|
|
|
|
/* tearDown runs after every test */
|
|
void tearDown(void)
|
|
{
|
|
/* some FreeRTOS stuff is cleaned up by idle task */
|
|
vTaskDelay(5);
|
|
|
|
/* clean up some of the newlib's lazy allocations */
|
|
esp_reent_cleanup();
|
|
|
|
/* 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 leak_threshold_critical = 0;
|
|
size_t leak_threshold_warning = 0;
|
|
leak_check_type_t check_type = leak_check_required(&leak_threshold_critical);
|
|
|
|
// In the "special case", only one level can be passed directly from the test case.
|
|
// Hence, we set both warning and critical leak levels to that same value here
|
|
leak_threshold_warning = leak_threshold_critical;
|
|
|
|
if (check_type == NO_LEAK_CHECK) {
|
|
// do not check
|
|
} else if (check_type == SPECIAL_LEAK_CHECK) {
|
|
test_utils_finish_and_evaluate_leaks(leak_threshold_warning, leak_threshold_critical);
|
|
} else if (check_type == DEFAULT_LEAK_CHECK) {
|
|
test_utils_finish_and_evaluate_leaks(test_utils_get_leak_level(ESP_LEAK_TYPE_WARNING, ESP_COMP_LEAK_ALL),
|
|
test_utils_get_leak_level(ESP_LEAK_TYPE_CRITICAL, ESP_COMP_LEAK_ALL));
|
|
} else {
|
|
assert(false); // coding error
|
|
}
|
|
|
|
Unity.TestFile = real_testfile; // go back to the real filename
|
|
}
|