diff --git a/components/esp_event/default_event_loop.c b/components/esp_event/default_event_loop.c index af07a57473..3f208ee100 100644 --- a/components/esp_event/default_event_loop.c +++ b/components/esp_event/default_event_loop.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2018-2022 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2018-2024 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -15,14 +15,14 @@ static esp_event_loop_handle_t s_default_loop = NULL; /* ---------------------------- Public API ---------------------------------- */ esp_err_t esp_event_handler_register(esp_event_base_t event_base, int32_t event_id, - esp_event_handler_t event_handler, void* event_handler_arg) + esp_event_handler_t event_handler, void* event_handler_arg) { if (s_default_loop == NULL) { return ESP_ERR_INVALID_STATE; } return esp_event_handler_register_with(s_default_loop, event_base, event_id, - event_handler, event_handler_arg); + event_handler, event_handler_arg); } esp_err_t esp_event_handler_instance_register(esp_event_base_t event_base, @@ -44,14 +44,14 @@ esp_err_t esp_event_handler_instance_register(esp_event_base_t event_base, } esp_err_t esp_event_handler_unregister(esp_event_base_t event_base, int32_t event_id, - esp_event_handler_t event_handler) + esp_event_handler_t event_handler) { if (s_default_loop == NULL) { return ESP_ERR_INVALID_STATE; } return esp_event_handler_unregister_with(s_default_loop, event_base, event_id, - event_handler); + event_handler); } esp_err_t esp_event_handler_instance_unregister(esp_event_base_t event_base, @@ -66,31 +66,29 @@ esp_err_t esp_event_handler_instance_unregister(esp_event_base_t event_base, } esp_err_t esp_event_post(esp_event_base_t event_base, int32_t event_id, - const void* event_data, size_t event_data_size, TickType_t ticks_to_wait) + const void* event_data, size_t event_data_size, TickType_t ticks_to_wait) { if (s_default_loop == NULL) { return ESP_ERR_INVALID_STATE; } return esp_event_post_to(s_default_loop, event_base, event_id, - event_data, event_data_size, ticks_to_wait); + event_data, event_data_size, ticks_to_wait); } - #if CONFIG_ESP_EVENT_POST_FROM_ISR esp_err_t esp_event_isr_post(esp_event_base_t event_base, int32_t event_id, - const void* event_data, size_t event_data_size, BaseType_t* task_unblocked) + const void* event_data, size_t event_data_size, BaseType_t* task_unblocked) { if (s_default_loop == NULL) { return ESP_ERR_INVALID_STATE; } return esp_event_isr_post_to(s_default_loop, event_base, event_id, - event_data, event_data_size, task_unblocked); + event_data, event_data_size, task_unblocked); } #endif - esp_err_t esp_event_loop_create_default(void) { if (s_default_loop) { diff --git a/components/esp_event/esp_event.c b/components/esp_event/esp_event.c index d1b0e7bb4e..0d9be71409 100644 --- a/components/esp_event/esp_event.c +++ b/components/esp_event/esp_event.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2018-2023 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2018-2024 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -24,7 +24,7 @@ #ifdef CONFIG_ESP_EVENT_LOOP_PROFILING // LOOP @ rx: dr: #define LOOP_DUMP_FORMAT "LOOP @%p,%s rx:%" PRIu32 " dr:%" PRIu32 "\n" - // handler @
ev: inv: time: +// handler @
ev: inv: time: #define HANDLER_DUMP_FORMAT " HANDLER @%p ev:%s,%s inv:%" PRIu32 " time:%lld us\n" #define PRINT_DUMP_INFO(dst, sz, ...) do { \ @@ -41,17 +41,15 @@ static const char* esp_event_any_base = "any"; #ifdef CONFIG_ESP_EVENT_LOOP_PROFILING static SLIST_HEAD(esp_event_loop_instance_list_t, esp_event_loop_instance) s_event_loops = - SLIST_HEAD_INITIALIZER(s_event_loops); + SLIST_HEAD_INITIALIZER(s_event_loops); static portMUX_TYPE s_event_loops_spinlock = portMUX_INITIALIZER_UNLOCKED; #endif - /* ------------------------- Static Functions ------------------------------- */ #ifdef CONFIG_ESP_EVENT_LOOP_PROFILING - static int esp_event_dump_prepare(void) { esp_event_loop_instance_t* loop_it; @@ -90,7 +88,7 @@ static int esp_event_dump_prepare(void) // Reserve slightly more memory than computed int allowance = 3; int size = (((loops + allowance) * (sizeof(LOOP_DUMP_FORMAT) + 10 + 20 + 2 * 11)) + - ((handlers + allowance) * (sizeof(HANDLER_DUMP_FORMAT) + 10 + 2 * 20 + 11 + 20))); + ((handlers + allowance) * (sizeof(HANDLER_DUMP_FORMAT) + 10 + 2 * 20 + 11 + 20))); return size; } @@ -103,7 +101,7 @@ static void esp_event_loop_run_task(void* args) ESP_LOGD(TAG, "running task for loop %p", event_loop); - while(1) { + while (1) { err = esp_event_loop_run(event_loop, portMAX_DELAY); if (err != ESP_OK) { break; @@ -151,7 +149,7 @@ static void handler_execute(esp_event_loop_instance_t* loop, esp_event_handler_n esp_event_handler_node_t* handler_node; SLIST_FOREACH(loop_node, &(loop->loop_nodes), next) { SLIST_FOREACH(handler_node, &(loop_node->handlers), next) { - if(handler_node == handler) { + if (handler_node == handler) { handler->invoked++; handler->time += diff; } @@ -166,7 +164,9 @@ static esp_err_t handler_instances_add(esp_event_handler_nodes_t* handlers, esp_ { esp_event_handler_node_t *handler_instance = calloc(1, sizeof(*handler_instance)); - if (!handler_instance) return ESP_ERR_NO_MEM; + if (!handler_instance) { + return ESP_ERR_NO_MEM; + } esp_event_handler_instance_context_t *context = calloc(1, sizeof(*context)); @@ -181,13 +181,12 @@ static esp_err_t handler_instances_add(esp_event_handler_nodes_t* handlers, esp_ if (SLIST_EMPTY(handlers)) { SLIST_INSERT_HEAD(handlers, handler_instance, next); - } - else { + } else { esp_event_handler_node_t *it = NULL, *last = NULL; SLIST_FOREACH(it, handlers, next) { if (legacy) { - if(event_handler == it->handler_ctx->handler) { + if (event_handler == it->handler_ctx->handler) { it->handler_ctx->arg = event_handler_arg; ESP_LOGW(TAG, "handler already registered, overwriting"); free(handler_instance); @@ -211,16 +210,15 @@ static esp_err_t handler_instances_add(esp_event_handler_nodes_t* handlers, esp_ } static esp_err_t base_node_add_handler(esp_event_base_node_t* base_node, - int32_t id, - esp_event_handler_t event_handler, - void *event_handler_arg, - esp_event_handler_instance_context_t **handler_ctx, - bool legacy) + int32_t id, + esp_event_handler_t event_handler, + void *event_handler_arg, + esp_event_handler_instance_context_t **handler_ctx, + bool legacy) { if (id == ESP_EVENT_ANY_ID) { return handler_instances_add(&(base_node->handlers), event_handler, event_handler_arg, handler_ctx, legacy); - } - else { + } else { esp_err_t err = ESP_OK; esp_event_id_node_t *it = NULL, *id_node = NULL, *last_id_node = NULL; @@ -248,8 +246,7 @@ static esp_err_t base_node_add_handler(esp_event_base_node_t* base_node, if (err == ESP_OK) { if (!last_id_node) { SLIST_INSERT_HEAD(&(base_node->id_nodes), id_node, next); - } - else { + } else { SLIST_INSERT_AFTER(last_id_node, id_node, next); } } else { @@ -257,25 +254,23 @@ static esp_err_t base_node_add_handler(esp_event_base_node_t* base_node, } return err; - } - else { + } else { return handler_instances_add(&(id_node->handlers), event_handler, event_handler_arg, handler_ctx, legacy); } } } static esp_err_t loop_node_add_handler(esp_event_loop_node_t* loop_node, - esp_event_base_t base, - int32_t id, - esp_event_handler_t event_handler, - void *event_handler_arg, - esp_event_handler_instance_context_t **handler_ctx, - bool legacy) + esp_event_base_t base, + int32_t id, + esp_event_handler_t event_handler, + void *event_handler_arg, + esp_event_handler_instance_context_t **handler_ctx, + bool legacy) { if (base == esp_event_any_base && id == ESP_EVENT_ANY_ID) { return handler_instances_add(&(loop_node->handlers), event_handler, event_handler_arg, handler_ctx, legacy); - } - else { + } else { esp_err_t err = ESP_OK; esp_event_base_node_t *it = NULL, *base_node = NULL, *last_base_node = NULL; @@ -287,9 +282,9 @@ static esp_err_t loop_node_add_handler(esp_event_loop_node_t* loop_node, } if (!last_base_node || - !base_node || - (base_node && !SLIST_EMPTY(&(base_node->id_nodes)) && id == ESP_EVENT_ANY_ID) || - (last_base_node && last_base_node->base != base && !SLIST_EMPTY(&(last_base_node->id_nodes)) && id == ESP_EVENT_ANY_ID)) { + !base_node || + (base_node && !SLIST_EMPTY(&(base_node->id_nodes)) && id == ESP_EVENT_ANY_ID) || + (last_base_node && last_base_node->base != base && !SLIST_EMPTY(&(last_base_node->id_nodes)) && id == ESP_EVENT_ANY_ID)) { base_node = (esp_event_base_node_t*) calloc(1, sizeof(*base_node)); if (!base_node) { @@ -307,8 +302,7 @@ static esp_err_t loop_node_add_handler(esp_event_loop_node_t* loop_node, if (err == ESP_OK) { if (!last_base_node) { SLIST_INSERT_HEAD(&(loop_node->base_nodes), base_node, next); - } - else { + } else { SLIST_INSERT_AFTER(last_base_node, base_node, next); } } else { @@ -347,13 +341,11 @@ static esp_err_t handler_instances_remove(esp_event_handler_nodes_t* handlers, e return ESP_ERR_NOT_FOUND; } - static esp_err_t base_node_remove_handler(esp_event_base_node_t* base_node, int32_t id, esp_event_handler_instance_context_t* handler_ctx, bool legacy) { if (id == ESP_EVENT_ANY_ID) { return handler_instances_remove(&(base_node->handlers), handler_ctx, legacy); - } - else { + } else { esp_event_id_node_t *it, *temp; SLIST_FOREACH_SAFE(it, &(base_node->id_nodes), next, temp) { if (it->id == id) { @@ -377,8 +369,7 @@ static esp_err_t loop_node_remove_handler(esp_event_loop_node_t* loop_node, esp_ { if (base == esp_event_any_base && id == ESP_EVENT_ANY_ID) { return handler_instances_remove(&(loop_node->handlers), handler_ctx, legacy); - } - else { + } else { esp_event_base_node_t *it, *temp; SLIST_FOREACH_SAFE(it, &(loop_node->base_nodes), next, temp) { if (it->base == base) { @@ -469,7 +460,7 @@ esp_err_t esp_event_loop_create(const esp_event_loop_args_t* event_loop_args, es return err; } - loop->queue = xQueueCreate(event_loop_args->queue_size , sizeof(esp_event_post_instance_t)); + loop->queue = xQueueCreate(event_loop_args->queue_size, sizeof(esp_event_post_instance_t)); if (loop->queue == NULL) { ESP_LOGE(TAG, "create event loop queue failed"); goto on_err; @@ -494,8 +485,8 @@ esp_err_t esp_event_loop_create(const esp_event_loop_args_t* event_loop_args, es // Create the loop task if requested if (event_loop_args->task_name != NULL) { BaseType_t task_created = xTaskCreatePinnedToCore(esp_event_loop_run_task, event_loop_args->task_name, - event_loop_args->task_stack_size, (void*) loop, - event_loop_args->task_priority, &(loop->task), event_loop_args->task_core_id); + event_loop_args->task_stack_size, (void*) loop, + event_loop_args->task_priority, &(loop->task), event_loop_args->task_core_id); if (task_created != pdPASS) { ESP_LOGE(TAG, "create task for loop failed"); @@ -566,7 +557,7 @@ esp_err_t esp_event_loop_run(esp_event_loop_handle_t event_loop, TickType_t tick int64_t remaining_ticks = ticks_to_run; #endif - while(xQueueReceive(loop->queue, &post, ticks_to_run) == pdTRUE) { + while (xQueueReceive(loop->queue, &post, ticks_to_run) == pdTRUE) { // The event has already been unqueued, so ensure it gets executed. xSemaphoreTakeRecursive(loop->mutex, portMAX_DELAY); @@ -674,7 +665,7 @@ esp_err_t esp_event_loop_delete(esp_event_loop_handle_t event_loop) // Drop existing posts on the queue esp_event_post_instance_t post; - while(xQueueReceive(loop->queue, &post, 0) == pdTRUE) { + while (xQueueReceive(loop->queue, &post, 0) == pdTRUE) { post_instance_delete(&post); } @@ -693,8 +684,8 @@ esp_err_t esp_event_loop_delete(esp_event_loop_handle_t event_loop) } esp_err_t esp_event_handler_register_with_internal(esp_event_loop_handle_t event_loop, esp_event_base_t event_base, - int32_t event_id, esp_event_handler_t event_handler, void* event_handler_arg, - esp_event_handler_instance_context_t** handler_ctx_arg, bool legacy) + int32_t event_id, esp_event_handler_t event_handler, void* event_handler_arg, + esp_event_handler_instance_context_t** handler_ctx_arg, bool legacy) { assert(event_loop); assert(event_handler); @@ -723,7 +714,7 @@ esp_err_t esp_event_handler_register_with_internal(esp_event_loop_handle_t event bool is_loop_level_handler = (event_base == esp_event_any_base) && (event_id == ESP_EVENT_ANY_ID); if (!last_loop_node || - (last_loop_node && !SLIST_EMPTY(&(last_loop_node->base_nodes)) && is_loop_level_handler)) { + (last_loop_node && !SLIST_EMPTY(&(last_loop_node->base_nodes)) && is_loop_level_handler)) { loop_node = (esp_event_loop_node_t*) calloc(1, sizeof(*loop_node)); if (!loop_node) { @@ -740,15 +731,13 @@ esp_err_t esp_event_handler_register_with_internal(esp_event_loop_handle_t event if (err == ESP_OK) { if (!last_loop_node) { SLIST_INSERT_HEAD(&(loop->loop_nodes), loop_node, next); - } - else { + } else { SLIST_INSERT_AFTER(last_loop_node, loop_node, next); } } else { free(loop_node); } - } - else { + } else { err = loop_node_add_handler(last_loop_node, event_base, event_id, event_handler, event_handler_arg, handler_ctx_arg, legacy); } @@ -758,20 +747,20 @@ on_err: } esp_err_t esp_event_handler_register_with(esp_event_loop_handle_t event_loop, esp_event_base_t event_base, - int32_t event_id, esp_event_handler_t event_handler, void* event_handler_arg) + int32_t event_id, esp_event_handler_t event_handler, void* event_handler_arg) { return esp_event_handler_register_with_internal(event_loop, event_base, event_id, event_handler, event_handler_arg, NULL, true); } esp_err_t esp_event_handler_instance_register_with(esp_event_loop_handle_t event_loop, esp_event_base_t event_base, - int32_t event_id, esp_event_handler_t event_handler, void* event_handler_arg, - esp_event_handler_instance_t* handler_ctx_arg) + int32_t event_id, esp_event_handler_t event_handler, void* event_handler_arg, + esp_event_handler_instance_t* handler_ctx_arg) { return esp_event_handler_register_with_internal(event_loop, event_base, event_id, event_handler, event_handler_arg, (esp_event_handler_instance_context_t**) handler_ctx_arg, false); } esp_err_t esp_event_handler_unregister_with_internal(esp_event_loop_handle_t event_loop, esp_event_base_t event_base, - int32_t event_id, esp_event_handler_instance_context_t* handler_ctx, bool legacy) + int32_t event_id, esp_event_handler_instance_context_t* handler_ctx, bool legacy) { assert(event_loop); assert(handler_ctx); @@ -817,9 +806,11 @@ esp_err_t esp_event_handler_unregister_with(esp_event_loop_handle_t event_loop, } esp_err_t esp_event_handler_instance_unregister_with(esp_event_loop_handle_t event_loop, esp_event_base_t event_base, - int32_t event_id, esp_event_handler_instance_t handler_ctx_arg) + int32_t event_id, esp_event_handler_instance_t handler_ctx_arg) { - if (!handler_ctx_arg) return ESP_ERR_INVALID_ARG; + if (!handler_ctx_arg) { + return ESP_ERR_INVALID_ARG; + } return esp_event_handler_unregister_with_internal(event_loop, event_base, event_id, (esp_event_handler_instance_context_t*) handler_ctx_arg, false); } @@ -902,7 +893,7 @@ esp_err_t esp_event_post_to(esp_event_loop_handle_t event_loop, esp_event_base_t #if CONFIG_ESP_EVENT_POST_FROM_ISR esp_err_t esp_event_isr_post_to(esp_event_loop_handle_t event_loop, esp_event_base_t event_base, int32_t event_id, - const void* event_data, size_t event_data_size, BaseType_t* task_unblocked) + const void* event_data, size_t event_data_size, BaseType_t* task_unblocked) { assert(event_loop); @@ -976,7 +967,7 @@ esp_err_t esp_event_dump(FILE* file) events_recieved = atomic_load(&loop_it->events_recieved); events_dropped = atomic_load(&loop_it->events_dropped); - PRINT_DUMP_INFO(dst, sz, LOOP_DUMP_FORMAT, loop_it, loop_it->task != NULL ? loop_it->name : "none" , + PRINT_DUMP_INFO(dst, sz, LOOP_DUMP_FORMAT, loop_it, loop_it->task != NULL ? loop_it->name : "none", events_recieved, events_dropped); int sz_bak = sz; @@ -989,7 +980,7 @@ esp_err_t esp_event_dump(FILE* file) SLIST_FOREACH(base_node_it, &(loop_node_it->base_nodes), next) { SLIST_FOREACH(handler_it, &(base_node_it->handlers), next) { - PRINT_DUMP_INFO(dst, sz, HANDLER_DUMP_FORMAT, handler_it->handler_ctx->handler, base_node_it->base , + PRINT_DUMP_INFO(dst, sz, HANDLER_DUMP_FORMAT, handler_it->handler_ctx->handler, base_node_it->base, "ESP_EVENT_ANY_ID", handler_it->invoked, handler_it->time); } @@ -998,7 +989,7 @@ esp_err_t esp_event_dump(FILE* file) memset(id_str_buf, 0, sizeof(id_str_buf)); snprintf(id_str_buf, sizeof(id_str_buf), "%" PRIi32, id_node_it->id); - PRINT_DUMP_INFO(dst, sz, HANDLER_DUMP_FORMAT, handler_it->handler_ctx->handler, base_node_it->base , + PRINT_DUMP_INFO(dst, sz, HANDLER_DUMP_FORMAT, handler_it->handler_ctx->handler, base_node_it->base, id_str_buf, handler_it->invoked, handler_it->time); } } diff --git a/components/esp_event/esp_event_private.c b/components/esp_event/esp_event_private.c index 612f37e1ae..773909bc42 100644 --- a/components/esp_event/esp_event_private.c +++ b/components/esp_event/esp_event_private.c @@ -22,8 +22,7 @@ bool esp_event_is_handler_registered(esp_event_loop_handle_t event_loop, esp_eve SLIST_FOREACH(loop_node, &(loop->loop_nodes), next) { SLIST_FOREACH(handler, &(loop_node->handlers), next) { - if(event_base == ESP_EVENT_ANY_BASE && event_id == ESP_EVENT_ANY_ID && handler->handler_ctx->handler == event_handler) - { + if (event_base == ESP_EVENT_ANY_BASE && event_id == ESP_EVENT_ANY_ID && handler->handler_ctx->handler == event_handler) { result = true; goto out; } @@ -32,18 +31,16 @@ bool esp_event_is_handler_registered(esp_event_loop_handle_t event_loop, esp_eve SLIST_FOREACH(base_node, &(loop_node->base_nodes), next) { if (base_node->base == event_base) { SLIST_FOREACH(handler, &(base_node->handlers), next) { - if(event_id == ESP_EVENT_ANY_ID && handler->handler_ctx->handler == event_handler) - { + if (event_id == ESP_EVENT_ANY_ID && handler->handler_ctx->handler == event_handler) { result = true; goto out; } } SLIST_FOREACH(id_node, &(base_node->id_nodes), next) { - if(id_node->id == event_id) { + if (id_node->id == event_id) { SLIST_FOREACH(handler, &(id_node->handlers), next) { - if(handler->handler_ctx->handler == event_handler) - { + if (handler->handler_ctx->handler == event_handler) { result = true; goto out; } diff --git a/components/esp_event/host_test/esp_event_unit_test/main/esp_event_test.cpp b/components/esp_event/host_test/esp_event_unit_test/main/esp_event_test.cpp index 524a3e5e46..692edd0850 100644 --- a/components/esp_event/host_test/esp_event_unit_test/main/esp_event_test.cpp +++ b/components/esp_event/host_test/esp_event_unit_test/main/esp_event_test.cpp @@ -7,7 +7,6 @@ CONDITIONS OF ANY KIND, either express or implied. */ - #include #include "esp_event.h" @@ -20,7 +19,6 @@ extern "C" { #include "Mockqueue.h" } - namespace { const uint32_t QUEUE_SIZE = 32; @@ -45,7 +43,8 @@ void dummy_handler(void* event_handler_arg, esp_event_base_t event_base, int32_t } // TODO: IDF-2693, function definition just to satisfy linker, implement esp_common instead -const char *esp_err_to_name(esp_err_t code) { +const char *esp_err_to_name(esp_err_t code) +{ return "test"; } @@ -141,11 +140,12 @@ TEST_CASE("test esp_event_loop_create with_task(void)") xQueueGiveMutexRecursive_StopIgnore(); } -TEST_CASE("registering with ANY_BASE but specific ID fails") { +TEST_CASE("registering with ANY_BASE but specific ID fails") +{ esp_event_loop_handle_t loop = reinterpret_cast(1); CHECK(esp_event_handler_register_with(loop, - ESP_EVENT_ANY_BASE, - 47, - dummy_handler, - nullptr) == ESP_ERR_INVALID_ARG); + ESP_EVENT_ANY_BASE, + 47, + dummy_handler, + nullptr) == ESP_ERR_INVALID_ARG); } diff --git a/components/esp_event/include/esp_event.h b/components/esp_event/include/esp_event.h index ebef99ae56..3194319011 100644 --- a/components/esp_event/include/esp_event.h +++ b/components/esp_event/include/esp_event.h @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2018-2021 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2018-2024 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -208,11 +208,11 @@ esp_err_t esp_event_handler_register_with(esp_event_loop_handle_t event_loop, * - Others: Fail */ esp_err_t esp_event_handler_instance_register_with(esp_event_loop_handle_t event_loop, - esp_event_base_t event_base, - int32_t event_id, - esp_event_handler_t event_handler, - void *event_handler_arg, - esp_event_handler_instance_t *instance); + esp_event_base_t event_base, + int32_t event_id, + esp_event_handler_t event_handler, + void *event_handler_arg, + esp_event_handler_instance_t *instance); /** * @brief Register an instance of event handler to the default loop. @@ -243,10 +243,10 @@ esp_err_t esp_event_handler_instance_register_with(esp_event_loop_handle_t event * - Others: Fail */ esp_err_t esp_event_handler_instance_register(esp_event_base_t event_base, - int32_t event_id, - esp_event_handler_t event_handler, - void *event_handler_arg, - esp_event_handler_instance_t *instance); + int32_t event_id, + esp_event_handler_t event_handler, + void *event_handler_arg, + esp_event_handler_instance_t *instance); /** * @brief Unregister a handler with the system event loop (legacy). diff --git a/components/esp_event/include/esp_event_base.h b/components/esp_event/include/esp_event_base.h index 6eb3f31e94..2dbdd71df8 100644 --- a/components/esp_event/include/esp_event_base.h +++ b/components/esp_event/include/esp_event_base.h @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2018-2023 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2018-2024 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -19,10 +19,10 @@ extern "C" { // Event loop library types typedef const char* esp_event_base_t; /**< unique pointer to a subsystem that exposes events */ typedef void* esp_event_loop_handle_t; /**< a number that identifies an event with respect to a base */ -typedef void (*esp_event_handler_t)(void* event_handler_arg, - esp_event_base_t event_base, - int32_t event_id, - void* event_data); /**< function called when an event is posted to the queue */ +typedef void (*esp_event_handler_t)(void* event_handler_arg, + esp_event_base_t event_base, + int32_t event_id, + void* event_data); /**< function called when an event is posted to the queue */ typedef void* esp_event_handler_instance_t; /**< context identifying an instance of a registered event handler */ // Defines for registering/unregistering event handlers diff --git a/components/esp_event/test_apps/main/test_event_common.cpp b/components/esp_event/test_apps/main/test_event_common.cpp index 0daa3844ef..bbac3490f1 100644 --- a/components/esp_event/test_apps/main/test_event_common.cpp +++ b/components/esp_event/test_apps/main/test_event_common.cpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2023-2024 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Unlicense OR CC0-1.0 */ @@ -48,14 +48,16 @@ static esp_event_loop_args_t test_event_get_default_loop_args(void) struct EV_LoopFix { public: - EV_LoopFix(size_t queue_size = CONFIG_ESP_SYSTEM_EVENT_QUEUE_SIZE, const char *task_name = NULL) { + EV_LoopFix(size_t queue_size = CONFIG_ESP_SYSTEM_EVENT_QUEUE_SIZE, const char *task_name = NULL) + { esp_event_loop_args_t loop_args = test_event_get_default_loop_args(); loop_args.task_name = task_name; loop_args.queue_size = queue_size; TEST_ESP_OK(esp_event_loop_create(&loop_args, &loop)); } - ~EV_LoopFix() { + ~EV_LoopFix() + { esp_event_loop_delete(loop); } @@ -86,17 +88,17 @@ TEST_CASE("can post events up to loop's max queue size", "[event][linux]") EV_LoopFix loop_fix(2); TEST_ASSERT_EQUAL(ESP_OK, esp_event_post_to(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - NULL, - 0, - pdMS_TO_TICKS(10))); + s_test_base1, + TEST_EVENT_BASE1_EV1, + NULL, + 0, + pdMS_TO_TICKS(10))); TEST_ASSERT_EQUAL(ESP_OK, esp_event_post_to(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - NULL, - 0, - pdMS_TO_TICKS(10))); + s_test_base1, + TEST_EVENT_BASE1_EV1, + NULL, + 0, + pdMS_TO_TICKS(10))); } TEST_CASE("posting to full event loop times out", "[event][linux]") @@ -104,11 +106,11 @@ TEST_CASE("posting to full event loop times out", "[event][linux]") EV_LoopFix loop_fix(1); TEST_ASSERT_EQUAL(ESP_OK, - esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, pdMS_TO_TICKS(0))); + esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, pdMS_TO_TICKS(0))); TEST_ASSERT_EQUAL(ESP_ERR_TIMEOUT, - esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, pdMS_TO_TICKS(0))); + esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, pdMS_TO_TICKS(0))); TEST_ASSERT_EQUAL(ESP_ERR_TIMEOUT, - esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, pdMS_TO_TICKS(10))); + esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, pdMS_TO_TICKS(10))); } TEST_CASE("can post to loop and run loop without registration", "[event][linux]") @@ -116,7 +118,7 @@ TEST_CASE("can post to loop and run loop without registration", "[event][linux]" EV_LoopFix loop_fix; TEST_ASSERT_EQUAL(ESP_OK, - esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, pdMS_TO_TICKS(10))); + esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, pdMS_TO_TICKS(10))); TEST_ESP_OK(esp_event_loop_run(loop_fix.loop, ZERO_DELAY)); } @@ -126,16 +128,17 @@ static void test_handler_inc(void* event_handler_arg, esp_event_base_t event_bas (*target)++; } -TEST_CASE("registering event handler instance without instance context works", "[event][linux]") { +TEST_CASE("registering event handler instance without instance context works", "[event][linux]") +{ EV_LoopFix loop_fix; int count = 0; TEST_ESP_OK(esp_event_handler_instance_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - test_handler_inc, - &count, - NULL)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + test_handler_inc, + &count, + NULL)); TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); TEST_ESP_OK(esp_event_loop_run(loop_fix.loop, ZERO_DELAY)); @@ -148,17 +151,18 @@ TEST_CASE("registering event handler instance without instance context works", " * This aims to verify: 1) Handler's argument to be updated * 2) Registration not to leak memory */ -TEST_CASE("registering event twice with same handler yields updated handler arg", "[event][linux]") { +TEST_CASE("registering event twice with same handler yields updated handler arg", "[event][linux]") +{ EV_LoopFix loop_fix; int count_first = 0; int count_second = 0; TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - ESP_EVENT_ANY_BASE, - ESP_EVENT_ANY_ID, - test_handler_inc, - &count_first)); + ESP_EVENT_ANY_BASE, + ESP_EVENT_ANY_ID, + test_handler_inc, + &count_first)); TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); TEST_ESP_OK(esp_event_loop_run(loop_fix.loop, ZERO_DELAY)); @@ -167,10 +171,10 @@ TEST_CASE("registering event twice with same handler yields updated handler arg" // overriding the former registration of the same event TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - ESP_EVENT_ANY_BASE, - ESP_EVENT_ANY_ID, - test_handler_inc, - &count_second)); + ESP_EVENT_ANY_BASE, + ESP_EVENT_ANY_ID, + test_handler_inc, + &count_second)); TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); TEST_ESP_OK(esp_event_loop_run(loop_fix.loop, ZERO_DELAY)); @@ -179,7 +183,8 @@ TEST_CASE("registering event twice with same handler yields updated handler arg" TEST_ASSERT_EQUAL(1, count_second); } -TEST_CASE("registering event handler instance twice works", "[event][linux]") { +TEST_CASE("registering event handler instance twice works", "[event][linux]") +{ EV_LoopFix loop_fix; int count_1 = 0; int count_2 = 0; @@ -187,17 +192,17 @@ TEST_CASE("registering event handler instance twice works", "[event][linux]") { esp_event_handler_instance_t ctx_2; TEST_ESP_OK(esp_event_handler_instance_register_with(loop_fix.loop, - ESP_EVENT_ANY_BASE, - ESP_EVENT_ANY_ID, - test_handler_inc, - &count_1, - &ctx_1)); + ESP_EVENT_ANY_BASE, + ESP_EVENT_ANY_ID, + test_handler_inc, + &count_1, + &ctx_1)); TEST_ESP_OK(esp_event_handler_instance_register_with(loop_fix.loop, - ESP_EVENT_ANY_BASE, - ESP_EVENT_ANY_ID, - test_handler_inc, - &count_2, - &ctx_2)); + ESP_EVENT_ANY_BASE, + ESP_EVENT_ANY_ID, + test_handler_inc, + &count_2, + &ctx_2)); TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, pdMS_TO_TICKS(10))); TEST_ESP_OK(esp_event_loop_run(loop_fix.loop, ZERO_DELAY)); @@ -207,23 +212,24 @@ TEST_CASE("registering event handler instance twice works", "[event][linux]") { TEST_ASSERT_EQUAL(1, count_2); } -TEST_CASE("registering with ANY_BASE but specific ID fails", "[event][linux]") { +TEST_CASE("registering with ANY_BASE but specific ID fails", "[event][linux]") +{ EV_LoopFix loop_fix; int count = 0; int count_instance = 0; esp_event_handler_instance_t ctx; TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, esp_event_handler_register_with(loop_fix.loop, - ESP_EVENT_ANY_BASE, - TEST_EVENT_BASE1_EV1, - test_handler_inc, - &count)); + ESP_EVENT_ANY_BASE, + TEST_EVENT_BASE1_EV1, + test_handler_inc, + &count)); TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, esp_event_handler_instance_register_with(loop_fix.loop, - ESP_EVENT_ANY_BASE, - TEST_EVENT_BASE1_EV1, - test_handler_inc, - &count_instance, - &ctx)); + ESP_EVENT_ANY_BASE, + TEST_EVENT_BASE1_EV1, + test_handler_inc, + &count_instance, + &ctx)); TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); TEST_ESP_OK(esp_event_loop_run(loop_fix.loop, ZERO_DELAY)); @@ -232,23 +238,24 @@ TEST_CASE("registering with ANY_BASE but specific ID fails", "[event][linux]") { TEST_ASSERT_EQUAL(0, count_instance); } -TEST_CASE("registration of ANY_BASE and ANY_ID always called", "[event][linux]") { +TEST_CASE("registration of ANY_BASE and ANY_ID always called", "[event][linux]") +{ EV_LoopFix loop_fix; int count = 0; int count_instance = 0; esp_event_handler_instance_t ctx; TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - ESP_EVENT_ANY_BASE, - ESP_EVENT_ANY_ID, - test_handler_inc, - &count)); + ESP_EVENT_ANY_BASE, + ESP_EVENT_ANY_ID, + test_handler_inc, + &count)); TEST_ESP_OK(esp_event_handler_instance_register_with(loop_fix.loop, - ESP_EVENT_ANY_BASE, - ESP_EVENT_ANY_ID, - test_handler_inc, - &count_instance, - &ctx)); + ESP_EVENT_ANY_BASE, + ESP_EVENT_ANY_ID, + test_handler_inc, + &count_instance, + &ctx)); // handlers should always be triggered TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); @@ -263,23 +270,24 @@ TEST_CASE("registration of ANY_BASE and ANY_ID always called", "[event][linux]") TEST_ASSERT_EQUAL(4, count_instance); } -TEST_CASE("registration of ANY_ID not called from wrong base", "[event][linux]") { +TEST_CASE("registration of ANY_ID not called from wrong base", "[event][linux]") +{ EV_LoopFix loop_fix; int count = 0; int count_instance = 0; esp_event_handler_instance_t ctx; TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - ESP_EVENT_ANY_ID, - test_handler_inc, - &count)); + s_test_base1, + ESP_EVENT_ANY_ID, + test_handler_inc, + &count)); TEST_ESP_OK(esp_event_handler_instance_register_with(loop_fix.loop, - s_test_base1, - ESP_EVENT_ANY_ID, - test_handler_inc, - &count_instance, - &ctx)); + s_test_base1, + ESP_EVENT_ANY_ID, + test_handler_inc, + &count_instance, + &ctx)); // handlers shouldn't be triggered with different base TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base2, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); @@ -291,23 +299,24 @@ TEST_CASE("registration of ANY_ID not called from wrong base", "[event][linux]") TEST_ASSERT_EQUAL(0, count_instance); } -TEST_CASE("registration of ANY_ID called from correct base", "[event][linux]") { +TEST_CASE("registration of ANY_ID called from correct base", "[event][linux]") +{ EV_LoopFix loop_fix; int count = 0; int count_instance = 0; esp_event_handler_instance_t ctx; TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - ESP_EVENT_ANY_ID, - test_handler_inc, - &count)); + s_test_base1, + ESP_EVENT_ANY_ID, + test_handler_inc, + &count)); TEST_ESP_OK(esp_event_handler_instance_register_with(loop_fix.loop, - s_test_base1, - ESP_EVENT_ANY_ID, - test_handler_inc, - &count_instance, - &ctx)); + s_test_base1, + ESP_EVENT_ANY_ID, + test_handler_inc, + &count_instance, + &ctx)); // for all events with correct base, it should be triggered TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); @@ -319,23 +328,24 @@ TEST_CASE("registration of ANY_ID called from correct base", "[event][linux]") { TEST_ASSERT_EQUAL(2, count_instance); } -TEST_CASE("registering specific event posting different base and different event ID", "[event][linux]") { +TEST_CASE("registering specific event posting different base and different event ID", "[event][linux]") +{ EV_LoopFix loop_fix; int count = 0; int count_instance = 0; esp_event_handler_instance_t ctx; TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - test_handler_inc, - &count)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + test_handler_inc, + &count)); TEST_ESP_OK(esp_event_handler_instance_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - test_handler_inc, - &count_instance, - &ctx)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + test_handler_inc, + &count_instance, + &ctx)); // handlers should not be triggered with different base and different ID TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base2, TEST_EVENT_BASE1_EV2, NULL, 0, portMAX_DELAY)); @@ -345,23 +355,24 @@ TEST_CASE("registering specific event posting different base and different event TEST_ASSERT_EQUAL(0, count_instance); } -TEST_CASE("registering specific event posting different base", "[event][linux]") { +TEST_CASE("registering specific event posting different base", "[event][linux]") +{ EV_LoopFix loop_fix; int count = 0; int count_instance = 0; esp_event_handler_instance_t ctx; TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - test_handler_inc, - &count)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + test_handler_inc, + &count)); TEST_ESP_OK(esp_event_handler_instance_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - test_handler_inc, - &count_instance, - &ctx)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + test_handler_inc, + &count_instance, + &ctx)); // handlers should not be triggered with different base TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base2, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); @@ -373,23 +384,24 @@ TEST_CASE("registering specific event posting different base", "[event][linux]") TEST_ASSERT_EQUAL(0, count_instance); } -TEST_CASE("registering specific event posting incorrect event ID", "[event][linux]") { +TEST_CASE("registering specific event posting incorrect event ID", "[event][linux]") +{ EV_LoopFix loop_fix; int count = 0; int count_instance = 0; esp_event_handler_instance_t ctx; TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - test_handler_inc, - &count)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + test_handler_inc, + &count)); TEST_ESP_OK(esp_event_handler_instance_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - test_handler_inc, - &count_instance, - &ctx)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + test_handler_inc, + &count_instance, + &ctx)); // for incorrect id, it should not be triggered with different ID TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV2, NULL, 0, portMAX_DELAY)); @@ -399,23 +411,24 @@ TEST_CASE("registering specific event posting incorrect event ID", "[event][linu TEST_ASSERT_EQUAL(0, count_instance); } -TEST_CASE("registering specific event posting correct event and base", "[event][linux]") { +TEST_CASE("registering specific event posting correct event and base", "[event][linux]") +{ EV_LoopFix loop_fix; int count = 0; int count_instance = 0; esp_event_handler_instance_t ctx; TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - test_handler_inc, - &count)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + test_handler_inc, + &count)); TEST_ESP_OK(esp_event_handler_instance_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - test_handler_inc, - &count_instance, - &ctx)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + test_handler_inc, + &count_instance, + &ctx)); // for correct event and base, it should be triggered TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); @@ -425,49 +438,51 @@ TEST_CASE("registering specific event posting correct event and base", "[event][ TEST_ASSERT_EQUAL(1, count_instance); } -TEST_CASE("posting ANY_EVENT or ANY_ID fails", "[event][linux]") { +TEST_CASE("posting ANY_EVENT or ANY_ID fails", "[event][linux]") +{ EV_LoopFix loop_fix; int count = 0; int count_instance = 0; esp_event_handler_instance_t ctx; TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - ESP_EVENT_ANY_BASE, - ESP_EVENT_ANY_ID, - test_handler_inc, - &count)); + ESP_EVENT_ANY_BASE, + ESP_EVENT_ANY_ID, + test_handler_inc, + &count)); TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - ESP_EVENT_ANY_ID, - test_handler_inc, - &count)); + s_test_base1, + ESP_EVENT_ANY_ID, + test_handler_inc, + &count)); TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - test_handler_inc, - &count)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + test_handler_inc, + &count)); // normal and "instance" registration are decently close to each other, don't exercise all cases here TEST_ESP_OK(esp_event_handler_instance_register_with(loop_fix.loop, - ESP_EVENT_ANY_BASE, - ESP_EVENT_ANY_ID, - test_handler_inc, - &count_instance, - &ctx)); + ESP_EVENT_ANY_BASE, + ESP_EVENT_ANY_ID, + test_handler_inc, + &count_instance, + &ctx)); TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, - esp_event_post_to(loop_fix.loop, ESP_EVENT_ANY_BASE, ESP_EVENT_ANY_ID, NULL, 0, portMAX_DELAY)); + esp_event_post_to(loop_fix.loop, ESP_EVENT_ANY_BASE, ESP_EVENT_ANY_ID, NULL, 0, portMAX_DELAY)); TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, - esp_event_post_to(loop_fix.loop, s_test_base1, ESP_EVENT_ANY_ID, NULL, 0, portMAX_DELAY)); + esp_event_post_to(loop_fix.loop, s_test_base1, ESP_EVENT_ANY_ID, NULL, 0, portMAX_DELAY)); TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, - esp_event_post_to(loop_fix.loop, ESP_EVENT_ANY_BASE, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); + esp_event_post_to(loop_fix.loop, ESP_EVENT_ANY_BASE, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); TEST_ESP_OK(esp_event_loop_run(loop_fix.loop, ZERO_DELAY)); TEST_ASSERT_EQUAL(0, count); TEST_ASSERT_EQUAL(0, count_instance); } -TEST_CASE("posting to loop with multiple registrations at every level", "[event][linux]") { +TEST_CASE("posting to loop with multiple registrations at every level", "[event][linux]") +{ EV_LoopFix loop_fix; int count_loop = 0; int count_loop_inst = 0; @@ -482,45 +497,45 @@ TEST_CASE("posting to loop with multiple registrations at every level", "[event] esp_event_handler_instance_t id_ctx_2; TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - ESP_EVENT_ANY_BASE, - ESP_EVENT_ANY_ID, - test_handler_inc, - &count_loop)); + ESP_EVENT_ANY_BASE, + ESP_EVENT_ANY_ID, + test_handler_inc, + &count_loop)); TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - ESP_EVENT_ANY_ID, - test_handler_inc, - &count_base)); + s_test_base1, + ESP_EVENT_ANY_ID, + test_handler_inc, + &count_base)); TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - test_handler_inc, - &count_id)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + test_handler_inc, + &count_id)); TEST_ESP_OK(esp_event_handler_instance_register_with(loop_fix.loop, - ESP_EVENT_ANY_BASE, - ESP_EVENT_ANY_ID, - test_handler_inc, - &count_loop_inst, - &loop_ctx)); + ESP_EVENT_ANY_BASE, + ESP_EVENT_ANY_ID, + test_handler_inc, + &count_loop_inst, + &loop_ctx)); TEST_ESP_OK(esp_event_handler_instance_register_with(loop_fix.loop, - s_test_base1, - ESP_EVENT_ANY_ID, - test_handler_inc, - &count_base_inst, - &base_ctx)); + s_test_base1, + ESP_EVENT_ANY_ID, + test_handler_inc, + &count_base_inst, + &base_ctx)); TEST_ESP_OK(esp_event_handler_instance_register_with(loop_fix.loop, - ESP_EVENT_ANY_BASE, - ESP_EVENT_ANY_ID, - test_handler_inc, - &count_id_inst_1, - &id_ctx_1)); + ESP_EVENT_ANY_BASE, + ESP_EVENT_ANY_ID, + test_handler_inc, + &count_id_inst_1, + &id_ctx_1)); TEST_ESP_OK(esp_event_handler_instance_register_with(loop_fix.loop, - ESP_EVENT_ANY_BASE, - ESP_EVENT_ANY_ID, - test_handler_inc, - &count_id_inst_2, - &id_ctx_2)); + ESP_EVENT_ANY_BASE, + ESP_EVENT_ANY_ID, + test_handler_inc, + &count_id_inst_2, + &id_ctx_2)); TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); TEST_ESP_OK(esp_event_loop_run(loop_fix.loop, ZERO_DELAY)); @@ -540,13 +555,13 @@ TEST_CASE("unregistering ANY_BASE and specific ID fails", "[event][linux]") esp_event_handler_instance_t handler_inst = (esp_event_handler_instance_t) 1; // avoid triggering NULL check TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, esp_event_handler_unregister_with(loop_fix.loop, - ESP_EVENT_ANY_BASE, - TEST_EVENT_BASE1_EV1, - test_handler_inc)); + ESP_EVENT_ANY_BASE, + TEST_EVENT_BASE1_EV1, + test_handler_inc)); TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, esp_event_handler_instance_unregister_with(loop_fix.loop, - ESP_EVENT_ANY_BASE, - TEST_EVENT_BASE1_EV1, - handler_inst)); + ESP_EVENT_ANY_BASE, + TEST_EVENT_BASE1_EV1, + handler_inst)); } TEST_CASE("unregistering NULL instance fails", "[event][linux]") @@ -555,9 +570,9 @@ TEST_CASE("unregistering NULL instance fails", "[event][linux]") esp_event_handler_instance_t handler_inst = NULL; TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, esp_event_handler_instance_unregister_with(loop_fix.loop, - ESP_EVENT_ANY_BASE, - ESP_EVENT_ANY_ID, - handler_inst)); + ESP_EVENT_ANY_BASE, + ESP_EVENT_ANY_ID, + handler_inst)); } TEST_CASE("unregistered handler is not executed", "[event][linux]") @@ -568,20 +583,20 @@ TEST_CASE("unregistered handler is not executed", "[event][linux]") int id_count = 0; TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - ESP_EVENT_ANY_BASE, - ESP_EVENT_ANY_ID, - test_handler_inc, - &loop_count)); + ESP_EVENT_ANY_BASE, + ESP_EVENT_ANY_ID, + test_handler_inc, + &loop_count)); TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - ESP_EVENT_ANY_ID, - test_handler_inc, - &base_count)); + s_test_base1, + ESP_EVENT_ANY_ID, + test_handler_inc, + &base_count)); TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - test_handler_inc, - &id_count)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + test_handler_inc, + &id_count)); TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); TEST_ESP_OK(esp_event_loop_run(loop_fix.loop, ZERO_DELAY)); @@ -591,17 +606,17 @@ TEST_CASE("unregistered handler is not executed", "[event][linux]") TEST_ASSERT_EQUAL(id_count, 1); TEST_ESP_OK(esp_event_handler_unregister_with(loop_fix.loop, - ESP_EVENT_ANY_BASE, - ESP_EVENT_ANY_ID, - test_handler_inc)); + ESP_EVENT_ANY_BASE, + ESP_EVENT_ANY_ID, + test_handler_inc)); TEST_ESP_OK(esp_event_handler_unregister_with(loop_fix.loop, - s_test_base1, - ESP_EVENT_ANY_ID, - test_handler_inc)); + s_test_base1, + ESP_EVENT_ANY_ID, + test_handler_inc)); TEST_ESP_OK(esp_event_handler_unregister_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - test_handler_inc)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + test_handler_inc)); TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); TEST_ESP_OK(esp_event_loop_run(loop_fix.loop, ZERO_DELAY)); @@ -621,23 +636,23 @@ TEST_CASE("unregistered handler instance is not executed", "[event][linux]") esp_event_handler_instance_t id_handler_inst; TEST_ESP_OK(esp_event_handler_instance_register_with(loop_fix.loop, - ESP_EVENT_ANY_BASE, - ESP_EVENT_ANY_ID, - test_handler_inc, - &loop_count, - &loop_handler_inst)); + ESP_EVENT_ANY_BASE, + ESP_EVENT_ANY_ID, + test_handler_inc, + &loop_count, + &loop_handler_inst)); TEST_ESP_OK(esp_event_handler_instance_register_with(loop_fix.loop, - s_test_base1, - ESP_EVENT_ANY_ID, - test_handler_inc, - &base_count, - &base_handler_inst)); + s_test_base1, + ESP_EVENT_ANY_ID, + test_handler_inc, + &base_count, + &base_handler_inst)); TEST_ESP_OK(esp_event_handler_instance_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - test_handler_inc, - &id_count, - &id_handler_inst)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + test_handler_inc, + &id_count, + &id_handler_inst)); TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); TEST_ESP_OK(esp_event_loop_run(loop_fix.loop, ZERO_DELAY)); @@ -647,17 +662,17 @@ TEST_CASE("unregistered handler instance is not executed", "[event][linux]") TEST_ASSERT_EQUAL(id_count, 1); TEST_ESP_OK(esp_event_handler_instance_unregister_with(loop_fix.loop, - ESP_EVENT_ANY_BASE, - ESP_EVENT_ANY_ID, - loop_handler_inst)); + ESP_EVENT_ANY_BASE, + ESP_EVENT_ANY_ID, + loop_handler_inst)); TEST_ESP_OK(esp_event_handler_instance_unregister_with(loop_fix.loop, - s_test_base1, - ESP_EVENT_ANY_ID, - base_handler_inst)); + s_test_base1, + ESP_EVENT_ANY_ID, + base_handler_inst)); TEST_ESP_OK(esp_event_handler_instance_unregister_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - id_handler_inst)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + id_handler_inst)); TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); TEST_ESP_OK(esp_event_loop_run(loop_fix.loop, ZERO_DELAY)); @@ -674,20 +689,20 @@ TEST_CASE("unregistering handler does not influence other handlers", "[event][li int different_base_count = 0; TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - test_handler_inc, - &unregister_count)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + test_handler_inc, + &unregister_count)); TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base2, - TEST_EVENT_BASE1_EV1, - test_handler_inc, - &different_id_count)); + s_test_base2, + TEST_EVENT_BASE1_EV1, + test_handler_inc, + &different_id_count)); TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV2, - test_handler_inc, - &different_base_count)); + s_test_base1, + TEST_EVENT_BASE1_EV2, + test_handler_inc, + &different_base_count)); TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base2, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); @@ -701,9 +716,9 @@ TEST_CASE("unregistering handler does not influence other handlers", "[event][li TEST_ASSERT_EQUAL(different_base_count, 1); TEST_ESP_OK(esp_event_handler_unregister_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - test_handler_inc)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + test_handler_inc)); TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base2, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV2, NULL, 0, portMAX_DELAY)); @@ -723,15 +738,15 @@ TEST_CASE("unregistering ESP_EVENT_ANY_ID does not affect other handlers with sa int specific_id_count = 0; TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - ESP_EVENT_ANY_ID, - test_handler_inc, - &any_id_count)); + s_test_base1, + ESP_EVENT_ANY_ID, + test_handler_inc, + &any_id_count)); TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - test_handler_inc, - &specific_id_count)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + test_handler_inc, + &specific_id_count)); TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); TEST_ESP_OK(esp_event_loop_run(loop_fix.loop, ZERO_DELAY)); @@ -755,15 +770,15 @@ TEST_CASE("unregistering ESP_EVENT_ANY_BASE does not affect handlers with specif int any_id_count = 0; TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - ESP_EVENT_ANY_BASE, - ESP_EVENT_ANY_ID, - test_handler_inc, - &any_base_count)); + ESP_EVENT_ANY_BASE, + ESP_EVENT_ANY_ID, + test_handler_inc, + &any_base_count)); TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - ESP_EVENT_ANY_ID, - test_handler_inc, - &any_id_count)); + s_test_base1, + ESP_EVENT_ANY_ID, + test_handler_inc, + &any_id_count)); TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); TEST_ESP_OK(esp_event_loop_run(loop_fix.loop, ZERO_DELAY)); @@ -772,9 +787,9 @@ TEST_CASE("unregistering ESP_EVENT_ANY_BASE does not affect handlers with specif TEST_ASSERT_EQUAL(any_id_count, 1); TEST_ESP_OK(esp_event_handler_unregister_with(loop_fix.loop, - ESP_EVENT_ANY_BASE, - ESP_EVENT_ANY_ID, - test_handler_inc)); + ESP_EVENT_ANY_BASE, + ESP_EVENT_ANY_ID, + test_handler_inc)); TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); TEST_ESP_OK(esp_event_loop_run(loop_fix.loop, ZERO_DELAY)); @@ -790,9 +805,9 @@ typedef struct { } unregister_test_data_t; static void test_handler_unregister_itself(void* event_handler_arg, - esp_event_base_t event_base, - int32_t event_id, - void* event_data) + esp_event_base_t event_base, + int32_t event_id, + void* event_data) { unregister_test_data_t *test_data = (unregister_test_data_t*) event_handler_arg; @@ -800,9 +815,9 @@ static void test_handler_unregister_itself(void* event_handler_arg, // Unregister this handler for this event TEST_ESP_OK(esp_event_handler_unregister_with(test_data->loop, - event_base, - event_id, - test_handler_unregister_itself)); + event_base, + event_id, + test_handler_unregister_itself)); } TEST_CASE("handler can unregister itself", "[event][linux]") @@ -816,9 +831,9 @@ TEST_CASE("handler can unregister itself", "[event][linux]") }; TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - test_handler_unregister_itself, &test_data)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + test_handler_unregister_itself, &test_data)); TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); TEST_ESP_OK(esp_event_loop_run(loop_fix.loop, ZERO_DELAY)); @@ -826,20 +841,20 @@ TEST_CASE("handler can unregister itself", "[event][linux]") TEST_ASSERT_EQUAL(1, test_data.count); TEST_ESP_OK(esp_event_post_to(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - &loop_fix.loop, - sizeof(&loop_fix.loop), - portMAX_DELAY)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + &loop_fix.loop, + sizeof(&loop_fix.loop), + portMAX_DELAY)); TEST_ESP_OK(esp_event_loop_run(loop_fix.loop, pdMS_TO_TICKS(10))); TEST_ASSERT_EQUAL(1, test_data.count); } static void test_handler_instance_unregister_itself(void* event_handler_arg, - esp_event_base_t event_base, - int32_t event_id, - void* event_data) + esp_event_base_t event_base, + int32_t event_id, + void* event_data) { unregister_test_data_t *test_data = (unregister_test_data_t*) event_handler_arg; @@ -860,11 +875,11 @@ TEST_CASE("handler instance can unregister itself", "[event][linux]") }; TEST_ESP_OK(esp_event_handler_instance_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - test_handler_instance_unregister_itself, - &test_data, - &(test_data.context))); + s_test_base1, + TEST_EVENT_BASE1_EV1, + test_handler_instance_unregister_itself, + &test_data, + &(test_data.context))); TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); TEST_ESP_OK(esp_event_loop_run(loop_fix.loop, ZERO_DELAY)); @@ -872,11 +887,11 @@ TEST_CASE("handler instance can unregister itself", "[event][linux]") TEST_ASSERT_EQUAL(1, test_data.count); TEST_ESP_OK(esp_event_post_to(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - &loop_fix.loop, - sizeof(&loop_fix.loop), - portMAX_DELAY)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + &loop_fix.loop, + sizeof(&loop_fix.loop), + portMAX_DELAY)); TEST_ESP_OK(esp_event_loop_run(loop_fix.loop, ZERO_DELAY)); TEST_ASSERT_EQUAL(1, test_data.count); @@ -888,10 +903,10 @@ typedef struct { } ordered_dispatch_test_data_t; static void test_event_ordered_dispatch(void* event_handler_arg, - esp_event_base_t event_base, - int32_t event_id, - void* event_data, - size_t handler_index) + esp_event_base_t event_base, + int32_t event_id, + void* event_data, + size_t handler_index) { ordered_dispatch_test_data_t *test_data = (ordered_dispatch_test_data_t*) event_handler_arg; test_data->test_data[handler_index] = test_data->counter; @@ -899,33 +914,33 @@ static void test_event_ordered_dispatch(void* event_handler_arg, } static void test_event_ordered_dispatch_0(void* event_handler_arg, - esp_event_base_t event_base, - int32_t event_id, - void* event_data) + esp_event_base_t event_base, + int32_t event_id, + void* event_data) { test_event_ordered_dispatch(event_handler_arg, event_base, event_id, event_data, 0); } static void test_event_ordered_dispatch_1(void* event_handler_arg, - esp_event_base_t event_base, - int32_t event_id, - void* event_data) + esp_event_base_t event_base, + int32_t event_id, + void* event_data) { test_event_ordered_dispatch(event_handler_arg, event_base, event_id, event_data, 1); } static void test_event_ordered_dispatch_2(void* event_handler_arg, - esp_event_base_t event_base, - int32_t event_id, - void* event_data) + esp_event_base_t event_base, + int32_t event_id, + void* event_data) { test_event_ordered_dispatch(event_handler_arg, event_base, event_id, event_data, 2); } static void test_event_ordered_dispatch_3(void* event_handler_arg, - esp_event_base_t event_base, - int32_t event_id, - void* event_data) + esp_event_base_t event_base, + int32_t event_id, + void* event_data) { test_event_ordered_dispatch(event_handler_arg, event_base, event_id, event_data, 3); } @@ -940,25 +955,25 @@ TEST_CASE("events handlers for specific ID are dispatched in the order they are }; TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - test_event_ordered_dispatch_0, - &test_data)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + test_event_ordered_dispatch_0, + &test_data)); TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - test_event_ordered_dispatch_1, - &test_data)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + test_event_ordered_dispatch_1, + &test_data)); TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - test_event_ordered_dispatch_2, - &test_data)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + test_event_ordered_dispatch_2, + &test_data)); TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - test_event_ordered_dispatch_3, - &test_data)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + test_event_ordered_dispatch_3, + &test_data)); esp_event_dump(stdout); @@ -984,25 +999,25 @@ TEST_CASE("events handlers for specific base are dispatched in the order they ar }; TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - ESP_EVENT_ANY_ID, - test_event_ordered_dispatch_0, - &test_data)); + s_test_base1, + ESP_EVENT_ANY_ID, + test_event_ordered_dispatch_0, + &test_data)); TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - ESP_EVENT_ANY_ID, - test_event_ordered_dispatch_1, - &test_data)); + s_test_base1, + ESP_EVENT_ANY_ID, + test_event_ordered_dispatch_1, + &test_data)); TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - ESP_EVENT_ANY_ID, - test_event_ordered_dispatch_2, - &test_data)); + s_test_base1, + ESP_EVENT_ANY_ID, + test_event_ordered_dispatch_2, + &test_data)); TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - ESP_EVENT_ANY_ID, - test_event_ordered_dispatch_3, - &test_data)); + s_test_base1, + ESP_EVENT_ANY_ID, + test_event_ordered_dispatch_3, + &test_data)); esp_event_dump(stdout); @@ -1028,25 +1043,25 @@ TEST_CASE("events handlers for any base are dispatched in the order they are reg }; TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - ESP_EVENT_ANY_BASE, - ESP_EVENT_ANY_ID, - test_event_ordered_dispatch_0, - &test_data)); + ESP_EVENT_ANY_BASE, + ESP_EVENT_ANY_ID, + test_event_ordered_dispatch_0, + &test_data)); TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - ESP_EVENT_ANY_BASE, - ESP_EVENT_ANY_ID, - test_event_ordered_dispatch_1, - &test_data)); + ESP_EVENT_ANY_BASE, + ESP_EVENT_ANY_ID, + test_event_ordered_dispatch_1, + &test_data)); TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - ESP_EVENT_ANY_BASE, - ESP_EVENT_ANY_ID, - test_event_ordered_dispatch_2, - &test_data)); + ESP_EVENT_ANY_BASE, + ESP_EVENT_ANY_ID, + test_event_ordered_dispatch_2, + &test_data)); TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - ESP_EVENT_ANY_BASE, - ESP_EVENT_ANY_ID, - test_event_ordered_dispatch_3, - &test_data)); + ESP_EVENT_ANY_BASE, + ESP_EVENT_ANY_ID, + test_event_ordered_dispatch_3, + &test_data)); esp_event_dump(stdout); @@ -1079,15 +1094,15 @@ TEST_CASE("can create and delete loop from handler", "[event][linux]") esp_event_loop_handle_t test_loop; TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - test_create_loop_handler, - &test_loop)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + test_create_loop_handler, + &test_loop)); TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV2, - test_create_loop_handler, - &test_loop)); + s_test_base1, + TEST_EVENT_BASE1_EV2, + test_create_loop_handler, + &test_loop)); TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); TEST_ESP_OK(esp_event_loop_run(loop_fix.loop, ZERO_DELAY)); @@ -1119,15 +1134,15 @@ TEST_CASE("can post to loop from handler", "[event][linux]") int secondary_handler_count = 0; TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - test_handler_post, - &arg)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + test_handler_post, + &arg)); TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV2, - test_handler_inc, - &secondary_handler_count)); + s_test_base1, + TEST_EVENT_BASE1_EV2, + test_handler_inc, + &secondary_handler_count)); // Test that a handler can post to a different loop while there is still slots on the queue TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); @@ -1150,16 +1165,16 @@ TEST_CASE("can post to loop from handler instance", "[event][linux]") int secondary_handler_count = 0; TEST_ESP_OK(esp_event_handler_instance_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - test_handler_post, - &arg, - &ctx)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + test_handler_post, + &arg, + &ctx)); TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV2, - test_handler_inc, - &secondary_handler_count)); + s_test_base1, + TEST_EVENT_BASE1_EV2, + test_handler_inc, + &secondary_handler_count)); // Test that a handler can post to a different loop while there is still slots on the queue TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); @@ -1175,11 +1190,11 @@ static void test_handler_post_timeout(void* handler_arg, esp_event_base_t base, posting_handler_data_t* data = (posting_handler_data_t*) handler_arg; TEST_ESP_OK(esp_event_post_to(data->loop, s_test_base1, TEST_EVENT_BASE1_EV2, NULL, 0, portMAX_DELAY)); TEST_ASSERT_EQUAL(ESP_ERR_TIMEOUT, esp_event_post_to(data->loop, - s_test_base1, - TEST_EVENT_BASE1_EV2, - NULL, - 0, - 1)); + s_test_base1, + TEST_EVENT_BASE1_EV2, + NULL, + 0, + 1)); data->count++; } @@ -1194,15 +1209,15 @@ TEST_CASE("posting to loop from handler times out", "[event][linux]") int secondary_handler_count = 0; TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - test_handler_post_timeout, - &arg)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + test_handler_post_timeout, + &arg)); TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV2, - test_handler_inc, - &secondary_handler_count)); + s_test_base1, + TEST_EVENT_BASE1_EV2, + test_handler_inc, + &secondary_handler_count)); // Test that a handler can post to a different loop while there is still slots on the queue TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); @@ -1227,7 +1242,8 @@ static void test_handler_give_sem(void* handler_arg, esp_event_base_t base, int3 const TickType_t ONE_TICK = 1; -static void wait_taken(SemaphoreHandle_t sem, TickType_t delay_ticks_if_not_taken) { +static void wait_taken(SemaphoreHandle_t sem, TickType_t delay_ticks_if_not_taken) +{ while (xSemaphoreTake(sem, ONE_TICK) == pdTRUE) { xSemaphoreGive(sem); vTaskDelay(delay_ticks_if_not_taken); @@ -1244,15 +1260,15 @@ TEST_CASE("can post while handler is executing - dedicated task", "[event][linux TEST_ASSERT(ev2_sem); TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - test_handler_take_sem, - ev1_sem)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + test_handler_take_sem, + ev1_sem)); TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV2, - test_handler_give_sem, - ev2_sem)); + s_test_base1, + TEST_EVENT_BASE1_EV2, + test_handler_give_sem, + ev2_sem)); // Trigger waiting by sending first event TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); @@ -1265,11 +1281,11 @@ TEST_CASE("can post while handler is executing - dedicated task", "[event][linux // Now the event queue has to be full, expect timeout TEST_ASSERT_EQUAL(ESP_ERR_TIMEOUT, esp_event_post_to(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV2, - NULL, - 0, - 1)); + s_test_base1, + TEST_EVENT_BASE1_EV2, + NULL, + 0, + 1)); // Run all events xSemaphoreGive(ev1_sem); @@ -1303,27 +1319,27 @@ TEST_CASE("can not post while handler is executing - no dedicated task", "[event TaskHandle_t mtask; xTaskCreate(test_post_from_handler_loop_task, - "task", - 2584, - (void*) loop_fix.loop, - uxTaskPriorityGet(NULL) + 1, - &mtask); + "task", + 2584, + (void*) loop_fix.loop, + uxTaskPriorityGet(NULL) + 1, + &mtask); TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - test_handler_take_sem, - sem)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + test_handler_take_sem, + sem)); TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV2, - never_run, - NULL)); + s_test_base1, + TEST_EVENT_BASE1_EV2, + never_run, + NULL)); TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base2, - TEST_EVENT_BASE1_EV1, - test_handler_give_sem, - wait_done_sem)); + s_test_base2, + TEST_EVENT_BASE1_EV1, + test_handler_give_sem, + wait_done_sem)); // Trigger waiting by sending first event TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); @@ -1333,11 +1349,11 @@ TEST_CASE("can not post while handler is executing - no dedicated task", "[event // For loop without tasks, posting is more restrictive. Posting should wait until execution of handler finishes TEST_ASSERT_EQUAL(ESP_ERR_TIMEOUT, esp_event_post_to(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV2, - NULL, - 0, - 1)); + s_test_base1, + TEST_EVENT_BASE1_EV2, + NULL, + 0, + 1)); // Being running all events xSemaphoreGive(sem); @@ -1375,10 +1391,10 @@ TEST_CASE("event data null", "[event][linux]") EventData saved_ev_data(0); TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - save_ev_data, - &saved_ev_data)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + save_ev_data, + &saved_ev_data)); TEST_ESP_OK(esp_event_post_to(loop_fix.loop, s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); TEST_ESP_OK(esp_event_loop_run(loop_fix.loop, ZERO_DELAY)); @@ -1393,17 +1409,17 @@ TEST_CASE("event data one nonzero byte", "[event][linux]") EventData saved_ev_data(1); TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - save_ev_data, - &saved_ev_data)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + save_ev_data, + &saved_ev_data)); TEST_ESP_OK(esp_event_post_to(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - &ev_data, - sizeof(ev_data), - portMAX_DELAY)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + &ev_data, + sizeof(ev_data), + portMAX_DELAY)); TEST_ESP_OK(esp_event_loop_run(loop_fix.loop, ZERO_DELAY)); TEST_ASSERT_NOT_EQUAL(NULL, saved_ev_data.event_arg); @@ -1420,18 +1436,18 @@ TEST_CASE("event data one zero byte", "[event][linux]") esp_event_handler_instance_t ctx; TEST_ESP_OK(esp_event_handler_instance_register_with(loop_fix.loop, - s_test_base2, - TEST_EVENT_BASE1_EV1, - save_ev_data, - &saved_ev_data, - &ctx)); + s_test_base2, + TEST_EVENT_BASE1_EV1, + save_ev_data, + &saved_ev_data, + &ctx)); TEST_ESP_OK(esp_event_post_to(loop_fix.loop, - s_test_base2, - TEST_EVENT_BASE1_EV1, - &ev_data, - sizeof(ev_data), - portMAX_DELAY)); + s_test_base2, + TEST_EVENT_BASE1_EV1, + &ev_data, + sizeof(ev_data), + portMAX_DELAY)); TEST_ESP_OK(esp_event_loop_run(loop_fix.loop, ZERO_DELAY)); TEST_ASSERT_NOT_EQUAL(NULL, saved_ev_data.event_arg); @@ -1445,17 +1461,17 @@ TEST_CASE("event data many bytes", "[event][linux]") EventData saved_ev_data(16); TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - save_ev_data, - &saved_ev_data)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + save_ev_data, + &saved_ev_data)); TEST_ESP_OK(esp_event_post_to(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - &ev_data, - sizeof(ev_data), - portMAX_DELAY)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + &ev_data, + sizeof(ev_data), + portMAX_DELAY)); TEST_ESP_OK(esp_event_loop_run(loop_fix.loop, ZERO_DELAY)); TEST_ASSERT_NOT_EQUAL(NULL, saved_ev_data.event_arg); @@ -1471,18 +1487,18 @@ TEST_CASE("event data one byte is copied on post", "[event][linux]") esp_event_handler_instance_t ctx; TEST_ESP_OK(esp_event_handler_instance_register_with(loop_fix.loop, - s_test_base2, - TEST_EVENT_BASE1_EV1, - save_ev_data, - &saved_ev_data, - &ctx)); + s_test_base2, + TEST_EVENT_BASE1_EV1, + save_ev_data, + &saved_ev_data, + &ctx)); TEST_ESP_OK(esp_event_post_to(loop_fix.loop, - s_test_base2, - TEST_EVENT_BASE1_EV1, - &ev_data, - sizeof(ev_data), - portMAX_DELAY)); + s_test_base2, + TEST_EVENT_BASE1_EV1, + &ev_data, + sizeof(ev_data), + portMAX_DELAY)); ev_data = 42; TEST_ESP_OK(esp_event_loop_run(loop_fix.loop, ZERO_DELAY)); @@ -1498,17 +1514,17 @@ TEST_CASE("event data many bytes are copied on post", "[event][linux]") EventData saved_ev_data(16); TEST_ESP_OK(esp_event_handler_register_with(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - save_ev_data, - &saved_ev_data)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + save_ev_data, + &saved_ev_data)); TEST_ESP_OK(esp_event_post_to(loop_fix.loop, - s_test_base1, - TEST_EVENT_BASE1_EV1, - &ev_data, - sizeof(ev_data), - portMAX_DELAY)); + s_test_base1, + TEST_EVENT_BASE1_EV1, + &ev_data, + sizeof(ev_data), + portMAX_DELAY)); memset(ev_data, 0, sizeof(ev_data)); TEST_ESP_OK(esp_event_loop_run(loop_fix.loop, ZERO_DELAY)); @@ -1520,10 +1536,10 @@ TEST_CASE("default loop: registering fails on uninitialized default loop", "[eve { esp_event_handler_instance_t instance; TEST_ASSERT_EQUAL(ESP_ERR_INVALID_STATE, esp_event_handler_instance_register(s_test_base1, - TEST_EVENT_BASE1_EV1, - never_run, - NULL, - &instance)); + TEST_EVENT_BASE1_EV1, + never_run, + NULL, + &instance)); } TEST_CASE("default loop: can create and delete loop", "[event][default][linux]") @@ -1542,18 +1558,18 @@ TEST_CASE("default loop: registering/unregistering event works", "[event][defaul esp_event_handler_instance_t instance = NULL; TEST_ESP_OK(esp_event_handler_instance_register(s_test_base1, - TEST_EVENT_BASE1_EV1, - test_handler_give_sem, - waiter, - &instance)); + TEST_EVENT_BASE1_EV1, + test_handler_give_sem, + waiter, + &instance)); TEST_ASSERT(instance); TEST_ESP_OK(esp_event_post(s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); TEST_ASSERT_EQUAL(pdTRUE, xSemaphoreTake(waiter, pdMS_TO_TICKS(50))); TEST_ESP_OK(esp_event_handler_instance_unregister(s_test_base1, - TEST_EVENT_BASE1_EV1, - instance)); + TEST_EVENT_BASE1_EV1, + instance)); TEST_ESP_OK(esp_event_post(s_test_base1, TEST_EVENT_BASE1_EV1, NULL, 0, portMAX_DELAY)); TEST_ASSERT_EQUAL(pdFALSE, xSemaphoreTake(waiter, pdMS_TO_TICKS(50))); @@ -1564,7 +1580,8 @@ TEST_CASE("default loop: registering/unregistering event works", "[event][defaul TEST_ESP_OK(esp_event_loop_delete_default()); } -TEST_CASE("default event loop: registering event handler instance without instance context works", "[event][default][linux]") { +TEST_CASE("default event loop: registering event handler instance without instance context works", "[event][default][linux]") +{ TEST_ESP_OK(esp_event_loop_create_default()); if (TEST_PROTECT()) { diff --git a/components/esp_event/test_apps/main/test_event_target.c b/components/esp_event/test_apps/main/test_event_target.c index bd9264119f..0ab1a54088 100644 --- a/components/esp_event/test_apps/main/test_event_target.c +++ b/components/esp_event/test_apps/main/test_event_target.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Unlicense OR CC0-1.0 */ @@ -30,7 +30,6 @@ #include "test_utils.h" - static const char* TAG = "test_event"; static const TickType_t ZERO_DELAY = 0; @@ -154,7 +153,7 @@ static void test_event_simple_handler_registration_task(void* args) xSemaphoreTake(arg->start, portMAX_DELAY); - for(int i = 0; i < data->num; i++) { + for (int i = 0; i < data->num; i++) { if (data->is_registration) { TEST_ESP_OK(esp_event_handler_register_with(data->loop, data->base, data->id, data->handles[i], NULL)); } else { @@ -261,7 +260,7 @@ TEST_CASE("can register/unregister handlers simultaneously", "[event]") registration_data[i].is_registration = true; for (int j = 0; j < TEST_CONFIG_ITEMS_TO_REGISTER; j++) { - registration_data[i].handles[j] = (void*) (i * TEST_CONFIG_ITEMS_TO_REGISTER) + (j + TEST_CONFIG_ITEMS_TO_REGISTER); + registration_data[i].handles[j] = (void*)(i * TEST_CONFIG_ITEMS_TO_REGISTER) + (j + TEST_CONFIG_ITEMS_TO_REGISTER); } registration_arg[i].start = xSemaphoreCreateBinary(); @@ -381,8 +380,7 @@ TEST_CASE("can post and run events simultaneously", "[event]") post_event_data_t* post_event_data = calloc(TEST_CONFIG_TASKS_TO_SPAWN, sizeof(*post_event_data)); task_arg_t* post_event_arg = calloc(TEST_CONFIG_TASKS_TO_SPAWN, sizeof(*post_event_arg)); - for (int i = 0; i < TEST_CONFIG_TASKS_TO_SPAWN; i++) - { + for (int i = 0; i < TEST_CONFIG_TASKS_TO_SPAWN; i++) { post_event_data[i].base = s_test_base1; post_event_data[i].id = TEST_EVENT_BASE1_EV1; post_event_data[i].loop = loop; @@ -459,8 +457,7 @@ TEST_CASE("can post and run events simultaneously with instances", "[event]") post_event_data_t* post_event_data = calloc(TEST_CONFIG_TASKS_TO_SPAWN, sizeof(*post_event_data)); task_arg_t* post_event_arg = calloc(TEST_CONFIG_TASKS_TO_SPAWN, sizeof(*post_event_arg)); - for (int i = 0; i < TEST_CONFIG_TASKS_TO_SPAWN; i++) - { + for (int i = 0; i < TEST_CONFIG_TASKS_TO_SPAWN; i++) { post_event_data[i].base = s_test_base1; post_event_data[i].id = TEST_EVENT_BASE1_EV1; post_event_data[i].loop = loop; @@ -514,7 +511,7 @@ static void loop_run_task(void* args) { esp_event_loop_handle_t event_loop = (esp_event_loop_handle_t) args; - while(1) { + while (1) { esp_event_loop_run(event_loop, portMAX_DELAY); } } @@ -527,8 +524,8 @@ static void performance_test(bool dedicated_task) const char test_base[] = "qwertyuiopasdfghjklzxvbnmmnbvcxz"; - #define TEST_CONFIG_BASES (sizeof(test_base) - 1) - #define TEST_CONFIG_IDS (TEST_CONFIG_BASES / 2) +#define TEST_CONFIG_BASES (sizeof(test_base) - 1) +#define TEST_CONFIG_IDS (TEST_CONFIG_BASES / 2) // Create loop esp_event_loop_args_t loop_args = test_event_get_default_loop_args(); @@ -583,7 +580,7 @@ static void performance_test(bool dedicated_task) int rand_b = rand() % bases; int temp = post_bases[rand_a]; - post_bases[rand_a]= post_bases[rand_b]; + post_bases[rand_a] = post_bases[rand_b]; post_bases[rand_b] = temp; } @@ -592,7 +589,7 @@ static void performance_test(bool dedicated_task) int rand_b = rand() % ids; int temp = post_ids[rand_a]; - post_ids[rand_a]= post_ids[rand_b]; + post_ids[rand_a] = post_ids[rand_b]; post_ids[rand_b] = temp; } @@ -617,7 +614,7 @@ static void performance_test(bool dedicated_task) } } - int average = (int) (running_sum / (running_count)); + int average = (int)(running_sum / (running_count)); if (!dedicated_task) { ((esp_event_loop_instance_t*) loop)->task = mtask; @@ -700,7 +697,7 @@ static void test_handler_post_from_isr(void* event_handler_arg, esp_event_base_t SemaphoreHandle_t *sem = (SemaphoreHandle_t*) event_handler_arg; // Event data is just the address value (maybe have been truncated due to casting). int *data = (int*) event_data; - TEST_ASSERT_EQUAL(*data, (int) (*sem)); + TEST_ASSERT_EQUAL(*data, (int)(*sem)); xSemaphoreGive(*sem); } diff --git a/tools/ci/astyle-rules.yml b/tools/ci/astyle-rules.yml index 21b758a283..d3989639ff 100644 --- a/tools/ci/astyle-rules.yml +++ b/tools/ci/astyle-rules.yml @@ -54,7 +54,6 @@ components_not_formatted_temporary: - "/components/efuse/" - "/components/esp_coex/" - "/components/esp_eth/" - - "/components/esp_event/" - "/components/esp_gdbstub/" - "/components/esp_hid/" - "/components/esp_http_client/"