/* * SPDX-FileCopyrightText: 2015-2024 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ #include "sdkconfig.h" #include #include #include "freertos/FreeRTOS.h" #include "freertos/task.h" #include "freertos/queue.h" #include "freertos/semphr.h" #include "freertos/ringbuf.h" #include "driver/gptimer.h" #include "esp_private/spi_flash_os.h" #include "esp_memory_utils.h" #include "esp_heap_caps.h" #include "spi_flash_mmap.h" #include "unity.h" #include "esp_rom_sys.h" //Definitions used in multiple test cases #define TIMEOUT_TICKS 10 #define NO_OF_RB_TYPES 3 #define ITEM_HDR_SIZE 8 #define SMALL_ITEM_SIZE 8 #define MEDIUM_ITEM_SIZE ((3 * SMALL_ITEM_SIZE) >> 1) //12 bytes #define LARGE_ITEM_SIZE (2 * SMALL_ITEM_SIZE) //16 bytes #define BUFFER_SIZE 160 //4Byte aligned size static const uint8_t small_item[SMALL_ITEM_SIZE] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07}; static const uint8_t large_item[LARGE_ITEM_SIZE] = { 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17 }; static RingbufHandle_t buffer_handles[NO_OF_RB_TYPES]; static SemaphoreHandle_t done_sem; static void send_item_and_check(RingbufHandle_t handle, const uint8_t *item, size_t item_size, TickType_t ticks_to_wait, bool in_isr) { BaseType_t ret; if (in_isr) { ret = xRingbufferSendFromISR(handle, (void *)item, item_size, NULL); } else { ret = xRingbufferSend(handle, (void *)item, item_size, ticks_to_wait); } TEST_ASSERT_MESSAGE(ret == pdTRUE, "Failed to send item"); } static void send_item_and_check_failure(RingbufHandle_t handle, const uint8_t *item, size_t item_size, TickType_t ticks_to_wait, bool in_isr) { BaseType_t ret; if (in_isr) { ret = xRingbufferSendFromISR(handle, (void *)item, item_size, NULL); } else { ret = xRingbufferSend(handle, (void *)item, item_size, ticks_to_wait); } TEST_ASSERT_MESSAGE(ret == pdFALSE, "Sent an item to a full buffer"); } static void receive_check_and_return_item_no_split(RingbufHandle_t handle, const uint8_t *expected_data, size_t expected_size, TickType_t ticks_to_wait, bool in_isr) { //Receive item from no-split buffer size_t item_size; uint8_t *item; if (in_isr) { item = (uint8_t *)xRingbufferReceiveFromISR(handle, &item_size); } else { item = (uint8_t *)xRingbufferReceive(handle, &item_size, ticks_to_wait); } TEST_ASSERT_MESSAGE(item != NULL, "Failed to receive item"); TEST_ASSERT_MESSAGE(item_size == expected_size, "Item size is incorrect"); //Check data of received item for (int i = 0; i < item_size; i++) { TEST_ASSERT_MESSAGE(item[i] == expected_data[i], "Item data is invalid"); } //Return item if (in_isr) { vRingbufferReturnItemFromISR(handle, (void *)item, NULL); } else { vRingbufferReturnItem(handle, (void *)item); } } static void receive_check_and_return_item_allow_split(RingbufHandle_t handle, const uint8_t *expected_data, size_t expected_size, TickType_t ticks_to_wait, bool in_isr) { //Receive item size_t item_size1, item_size2; uint8_t *item1, *item2; BaseType_t ret; if (in_isr) { ret = xRingbufferReceiveSplitFromISR(handle, (void **)&item1, (void **)&item2, &item_size1, &item_size2); } else { ret = xRingbufferReceiveSplit(handle, (void **)&item1, (void **)&item2, &item_size1, &item_size2, ticks_to_wait); } TEST_ASSERT_MESSAGE(ret == pdTRUE, "Failed to receive item"); TEST_ASSERT_MESSAGE(item1 != NULL, "Failed to receive item"); //Check data of received item(s) and return them if (item2 == NULL) { TEST_ASSERT_MESSAGE(item_size1 == expected_size, "Item size is incorrect"); for (int i = 0; i < item_size1; i++) { TEST_ASSERT_MESSAGE(item1[i] == expected_data[i], "Item data is invalid"); } //Return item if (in_isr) { vRingbufferReturnItemFromISR(handle, (void *)item1, NULL); } else { vRingbufferReturnItem(handle, (void *)item1); } } else { //Item was split TEST_ASSERT_MESSAGE(item_size1 + item_size2 == expected_size, "Total item size is incorrect"); for (int i = 0; i < item_size1; i++) { TEST_ASSERT_MESSAGE(item1[i] == expected_data[i], "Head item data is invalid"); } for (int i = 0; i < item_size2; i++) { TEST_ASSERT_MESSAGE(item2[i] == expected_data[item_size1 + i], "Head item data is invalid"); } //Return Items if (in_isr) { vRingbufferReturnItemFromISR(handle, (void *)item1, NULL); vRingbufferReturnItemFromISR(handle, (void *)item2, NULL); } else { vRingbufferReturnItem(handle, (void *)item1); vRingbufferReturnItem(handle, (void *)item2); } } } static void receive_check_and_return_item_byte_buffer(RingbufHandle_t handle, const uint8_t *expected_data, size_t expected_size, TickType_t ticks_to_wait, bool in_isr) { //Receive item size_t item_size; uint8_t *item; if (in_isr) { item = (uint8_t *)xRingbufferReceiveUpToFromISR(handle, &item_size, expected_size); } else { item = (uint8_t *)xRingbufferReceiveUpTo(handle, &item_size, ticks_to_wait, expected_size); //Limit amount of bytes returned to the size of one item } TEST_ASSERT_MESSAGE(item != NULL, "Failed to receive item"); //Check data of received item for (int i = 0; i < item_size; i++) { TEST_ASSERT_MESSAGE(item[i] == expected_data[i], "Item data is invalid"); } //Return item if (in_isr) { vRingbufferReturnItemFromISR(handle, (void *)item, NULL); } else { vRingbufferReturnItem(handle, (void *)item); } //Check if item wrapped around if (item_size < expected_size) { //Item is wrapped, receive second portion size_t item_size2; uint8_t *item2; if (in_isr) { item2 = (uint8_t *)xRingbufferReceiveUpToFromISR(handle, &item_size2, expected_size - item_size); } else { item2 = (uint8_t *)xRingbufferReceiveUpTo(handle, &item_size2, ticks_to_wait, expected_size - item_size); } //= (uint8_t *)xRingbufferReceiveUpTo(handle, &item_size2, ticks_to_wait, expected_size - item_size); TEST_ASSERT_MESSAGE(item2 != NULL, "Failed to receive item"); TEST_ASSERT_MESSAGE(item_size + item_size2 == expected_size, "Total item size is incorrect"); for (int i = 0; i < item_size2; i++) { TEST_ASSERT_MESSAGE(item2[i] == expected_data[item_size + i], "Item data is invalid"); } if (in_isr) { vRingbufferReturnItemFromISR(handle, (void *)item2, NULL); } else { vRingbufferReturnItem(handle, (void *)item2); } } else { TEST_ASSERT_MESSAGE(item_size == expected_size, "Item size is incorrect"); } } /* ----------------- Basic ring buffer behavior tests cases -------------------- * The following set of test cases will test basic send, receive, wrap around and buffer full * behavior of each type of ring buffer. * Test Case 1: * 1) Send multiple items (nearly fill the buffer) * 2) Receive and check the sent items (also prepares the buffer for a wrap around) * 3) Send a final item that causes a wrap around * 4) Receive and check the wrapped item * * Test Case 2: * 1) Send multiple items (completely fill the buffer) * 2) Send another item and verify that send failure occurs * 3) Receive one item and verify that space is freed up in the buffer * 4) Receive and check the remaining sent items * * Test Case 3: * 1) Send multiple items (nearly fill the buffer) * 2) Send another small sized item to fill the buffer without causing a wrap around (not needed in case of byte buffer) * 2) Send another item and verify that send failure occurs * 4) Receive and check the sent items */ TEST_CASE("TC#1: No-Split", "[esp_ringbuf]") { //Create buffer RingbufHandle_t buffer_handle = xRingbufferCreate(BUFFER_SIZE, RINGBUF_TYPE_NOSPLIT); TEST_ASSERT_MESSAGE(buffer_handle != NULL, "Failed to create ring buffer"); //Check buffer free size and max item size upon buffer creation. Should be BUFFER_SIZE/2 - ITEM_HDR_SIZE. TEST_ASSERT_MESSAGE(xRingbufferGetCurFreeSize(buffer_handle) == ((BUFFER_SIZE >> 1) - ITEM_HDR_SIZE), "Incorrect buffer free size received"); TEST_ASSERT_MESSAGE(xRingbufferGetMaxItemSize(buffer_handle) == ((BUFFER_SIZE >> 1) - ITEM_HDR_SIZE), "Incorrect max item size received"); //Calculate number of items to send. Aim to almost fill buffer to setup for wrap around int no_of_items = (BUFFER_SIZE - (ITEM_HDR_SIZE + SMALL_ITEM_SIZE)) / (ITEM_HDR_SIZE + SMALL_ITEM_SIZE); //Test sending items for (int i = 0; i < no_of_items; i++) { send_item_and_check(buffer_handle, small_item, SMALL_ITEM_SIZE, TIMEOUT_TICKS, false); } //Verify items waiting matches with the number of items sent UBaseType_t items_waiting; vRingbufferGetInfo(buffer_handle, NULL, NULL, NULL, NULL, &items_waiting); TEST_ASSERT_MESSAGE(items_waiting == no_of_items, "Incorrect items waiting"); //Test receiving items for (int i = 0; i < no_of_items; i++) { receive_check_and_return_item_no_split(buffer_handle, small_item, SMALL_ITEM_SIZE, TIMEOUT_TICKS, false); } //Verify that no items are waiting vRingbufferGetInfo(buffer_handle, NULL, NULL, NULL, NULL, &items_waiting); TEST_ASSERT_MESSAGE(items_waiting == 0, "Incorrect items waiting"); //Write pointer should be near the end, test wrap around UBaseType_t write_pos_before, write_pos_after; vRingbufferGetInfo(buffer_handle, NULL, NULL, &write_pos_before, NULL, NULL); //Send large item that causes wrap around send_item_and_check(buffer_handle, large_item, LARGE_ITEM_SIZE, TIMEOUT_TICKS, false); //Receive wrapped item receive_check_and_return_item_no_split(buffer_handle, large_item, LARGE_ITEM_SIZE, TIMEOUT_TICKS, false); vRingbufferGetInfo(buffer_handle, NULL, NULL, &write_pos_after, NULL, NULL); TEST_ASSERT_MESSAGE(write_pos_after < write_pos_before, "Failed to wrap around"); //Cleanup vRingbufferDelete(buffer_handle); } TEST_CASE("TC#2: No-Split", "[esp_ringbuf]") { //Create buffer RingbufHandle_t buffer_handle = xRingbufferCreate(BUFFER_SIZE, RINGBUF_TYPE_NOSPLIT); TEST_ASSERT_MESSAGE(buffer_handle != NULL, "Failed to create ring buffer"); //Check buffer free size and max item size upon buffer creation. Should be BUFFER_SIZE/2 - ITEM_HDR_SIZE. TEST_ASSERT_MESSAGE(xRingbufferGetCurFreeSize(buffer_handle) == ((BUFFER_SIZE >> 1) - ITEM_HDR_SIZE), "Incorrect buffer free size received"); TEST_ASSERT_MESSAGE(xRingbufferGetMaxItemSize(buffer_handle) == ((BUFFER_SIZE >> 1) - ITEM_HDR_SIZE), "Incorrect max item size received"); //Calculate number of items to send. Aim to fill the buffer int no_of_items = (BUFFER_SIZE) / (ITEM_HDR_SIZE + SMALL_ITEM_SIZE); //Test sending items for (int i = 0; i < no_of_items; i++) { send_item_and_check(buffer_handle, small_item, SMALL_ITEM_SIZE, TIMEOUT_TICKS, false); } //Verify items waiting matches with the number of items sent UBaseType_t items_waiting; vRingbufferGetInfo(buffer_handle, NULL, NULL, NULL, NULL, &items_waiting); TEST_ASSERT_MESSAGE(items_waiting == no_of_items, "Incorrect items waiting"); //At this point, the buffer should be full. TEST_ASSERT_MESSAGE(xRingbufferGetCurFreeSize(buffer_handle) == 0, "Buffer full not achieved"); //Send an item. The item should not be sent to a full buffer. send_item_and_check_failure(buffer_handle, small_item, SMALL_ITEM_SIZE, TIMEOUT_TICKS, false); //Receive one item receive_check_and_return_item_no_split(buffer_handle, small_item, SMALL_ITEM_SIZE, TIMEOUT_TICKS, false); //At this point, the buffer should not be full any more TEST_ASSERT_MESSAGE(xRingbufferGetCurFreeSize(buffer_handle) > 0, "Buffer should have free space"); //Test receiving remaining items for (int i = 0; i < no_of_items - 1; i++) { receive_check_and_return_item_no_split(buffer_handle, small_item, SMALL_ITEM_SIZE, TIMEOUT_TICKS, false); } //Verify that no items are waiting vRingbufferGetInfo(buffer_handle, NULL, NULL, NULL, NULL, &items_waiting); TEST_ASSERT_MESSAGE(items_waiting == 0, "Incorrect items waiting"); //Cleanup vRingbufferDelete(buffer_handle); } TEST_CASE("TC#3: No-Split", "[esp_ringbuf]") { //Create buffer RingbufHandle_t buffer_handle = xRingbufferCreate(BUFFER_SIZE, RINGBUF_TYPE_NOSPLIT); TEST_ASSERT_MESSAGE(buffer_handle != NULL, "Failed to create ring buffer"); //Check buffer free size and max item size upon buffer creation. Should be BUFFER_SIZE/2 - ITEM_HDR_SIZE. TEST_ASSERT_MESSAGE(xRingbufferGetCurFreeSize(buffer_handle) == ((BUFFER_SIZE >> 1) - ITEM_HDR_SIZE), "Incorrect buffer free size received"); TEST_ASSERT_MESSAGE(xRingbufferGetMaxItemSize(buffer_handle) == ((BUFFER_SIZE >> 1) - ITEM_HDR_SIZE), "Incorrect max item size received"); //Calculate number of medium items to send. Aim to almost fill the buffer int no_of_medium_items = (BUFFER_SIZE - (ITEM_HDR_SIZE + MEDIUM_ITEM_SIZE)) / (ITEM_HDR_SIZE + MEDIUM_ITEM_SIZE); //Test sending items for (int i = 0; i < no_of_medium_items; i++) { send_item_and_check(buffer_handle, large_item, MEDIUM_ITEM_SIZE, TIMEOUT_TICKS, false); } //Verify items waiting matches with the number of medium items sent UBaseType_t items_waiting; vRingbufferGetInfo(buffer_handle, NULL, NULL, NULL, NULL, &items_waiting); TEST_ASSERT_MESSAGE(items_waiting == no_of_medium_items, "Incorrect items waiting"); //Send one small sized item. This will ensure that the item fits at the end of the buffer without causing the write pointer to wrap around. send_item_and_check(buffer_handle, small_item, SMALL_ITEM_SIZE, TIMEOUT_TICKS, false); //The buffer should not have any free space as the number of bytes remaining should be < ITEM_HDR_SIZE. TEST_ASSERT_MESSAGE(xRingbufferGetCurFreeSize(buffer_handle) == 0, "Buffer full not achieved"); //Send an item. The item should not be sent to a full buffer. send_item_and_check_failure(buffer_handle, small_item, SMALL_ITEM_SIZE, TIMEOUT_TICKS, false); //Test receiving medium items for (int i = 0; i < no_of_medium_items; i++) { receive_check_and_return_item_no_split(buffer_handle, large_item, MEDIUM_ITEM_SIZE, TIMEOUT_TICKS, false); } //Test receiving small item receive_check_and_return_item_no_split(buffer_handle, small_item, SMALL_ITEM_SIZE, TIMEOUT_TICKS, false); //Verify that no items are waiting vRingbufferGetInfo(buffer_handle, NULL, NULL, NULL, NULL, &items_waiting); TEST_ASSERT_MESSAGE(items_waiting == 0, "Incorrect items waiting"); //Cleanup vRingbufferDelete(buffer_handle); } TEST_CASE("TC#1: Allow-Split", "[esp_ringbuf]") { //Create buffer RingbufHandle_t buffer_handle = xRingbufferCreate(BUFFER_SIZE, RINGBUF_TYPE_ALLOWSPLIT); TEST_ASSERT_MESSAGE(buffer_handle != NULL, "Failed to create ring buffer"); //Check buffer free size and max item size upon buffer creation. Should be BUFFER_SIZE - (ITEM_HDR_SIZE * 2). TEST_ASSERT_MESSAGE(xRingbufferGetCurFreeSize(buffer_handle) == (BUFFER_SIZE - (ITEM_HDR_SIZE * 2)), "Incorrect buffer free size received"); TEST_ASSERT_MESSAGE(xRingbufferGetMaxItemSize(buffer_handle) == (BUFFER_SIZE - (ITEM_HDR_SIZE * 2)), "Incorrect max item size received"); //Calculate number of items to send. Aim to almost fill buffer to setup for wrap around int no_of_items = (BUFFER_SIZE - (ITEM_HDR_SIZE + SMALL_ITEM_SIZE)) / (ITEM_HDR_SIZE + SMALL_ITEM_SIZE); //Test sending items for (int i = 0; i < no_of_items; i++) { send_item_and_check(buffer_handle, small_item, SMALL_ITEM_SIZE, TIMEOUT_TICKS, false); } //Verify items waiting matches with the number of items sent UBaseType_t items_waiting; vRingbufferGetInfo(buffer_handle, NULL, NULL, NULL, NULL, &items_waiting); TEST_ASSERT_MESSAGE(items_waiting == no_of_items, "Incorrect items waiting"); //Test receiving items for (int i = 0; i < no_of_items; i++) { receive_check_and_return_item_allow_split(buffer_handle, small_item, SMALL_ITEM_SIZE, TIMEOUT_TICKS, false); } //Verify that no items are waiting vRingbufferGetInfo(buffer_handle, NULL, NULL, NULL, NULL, &items_waiting); TEST_ASSERT_MESSAGE(items_waiting == 0, "Incorrect items waiting"); //Write pointer should be near the end, test wrap around UBaseType_t write_pos_before, write_pos_after; vRingbufferGetInfo(buffer_handle, NULL, NULL, &write_pos_before, NULL, NULL); //Send large item that causes wrap around send_item_and_check(buffer_handle, large_item, LARGE_ITEM_SIZE, TIMEOUT_TICKS, false); //Receive wrapped item receive_check_and_return_item_allow_split(buffer_handle, large_item, LARGE_ITEM_SIZE, TIMEOUT_TICKS, false); vRingbufferGetInfo(buffer_handle, NULL, NULL, &write_pos_after, NULL, NULL); TEST_ASSERT_MESSAGE(write_pos_after < write_pos_before, "Failed to wrap around"); //Cleanup vRingbufferDelete(buffer_handle); } TEST_CASE("TC#2: Allow-Split", "[esp_ringbuf]") { //Create buffer RingbufHandle_t buffer_handle = xRingbufferCreate(BUFFER_SIZE, RINGBUF_TYPE_ALLOWSPLIT); TEST_ASSERT_MESSAGE(buffer_handle != NULL, "Failed to create ring buffer"); //Check buffer free size and max item size upon buffer creation. Should be BUFFER_SIZE - (ITEM_HDR_SIZE * 2). TEST_ASSERT_MESSAGE(xRingbufferGetCurFreeSize(buffer_handle) == (BUFFER_SIZE - (ITEM_HDR_SIZE * 2)), "Incorrect buffer free size received"); TEST_ASSERT_MESSAGE(xRingbufferGetMaxItemSize(buffer_handle) == (BUFFER_SIZE - (ITEM_HDR_SIZE * 2)), "Incorrect max item size received"); //Calculate number of items to send. Aim to fill the buffer int no_of_items = (BUFFER_SIZE) / (ITEM_HDR_SIZE + SMALL_ITEM_SIZE); //Test sending items for (int i = 0; i < no_of_items; i++) { send_item_and_check(buffer_handle, small_item, SMALL_ITEM_SIZE, TIMEOUT_TICKS, false); } //Verify items waiting matches with the number of items sent UBaseType_t items_waiting; vRingbufferGetInfo(buffer_handle, NULL, NULL, NULL, NULL, &items_waiting); TEST_ASSERT_MESSAGE(items_waiting == no_of_items, "Incorrect items waiting"); //At this point, the buffer should be full. TEST_ASSERT_MESSAGE(xRingbufferGetCurFreeSize(buffer_handle) == 0, "Buffer full not achieved"); //Send an item. The item should not be sent to a full buffer. send_item_and_check_failure(buffer_handle, small_item, SMALL_ITEM_SIZE, TIMEOUT_TICKS, false); //Receive one item receive_check_and_return_item_allow_split(buffer_handle, small_item, SMALL_ITEM_SIZE, TIMEOUT_TICKS, false); //At this point, the buffer should not be full any more TEST_ASSERT_MESSAGE(xRingbufferGetCurFreeSize(buffer_handle) > 0, "Buffer should have free space"); //Test receiving remaining items for (int i = 0; i < no_of_items - 1; i++) { receive_check_and_return_item_allow_split(buffer_handle, small_item, SMALL_ITEM_SIZE, TIMEOUT_TICKS, false); } //Verify that no items are waiting vRingbufferGetInfo(buffer_handle, NULL, NULL, NULL, NULL, &items_waiting); TEST_ASSERT_MESSAGE(items_waiting == 0, "Incorrect items waiting"); //Cleanup vRingbufferDelete(buffer_handle); } TEST_CASE("TC#3: Allow-Split", "[esp_ringbuf]") { //Create buffer RingbufHandle_t buffer_handle = xRingbufferCreate(BUFFER_SIZE, RINGBUF_TYPE_ALLOWSPLIT); TEST_ASSERT_MESSAGE(buffer_handle != NULL, "Failed to create ring buffer"); //Check buffer free size and max item size upon buffer creation. Should be BUFFER_SIZE - (ITEM_HDR_SIZE * 2). TEST_ASSERT_MESSAGE(xRingbufferGetCurFreeSize(buffer_handle) == (BUFFER_SIZE - (ITEM_HDR_SIZE * 2)), "Incorrect buffer free size received"); TEST_ASSERT_MESSAGE(xRingbufferGetMaxItemSize(buffer_handle) == (BUFFER_SIZE - (ITEM_HDR_SIZE * 2)), "Incorrect max item size received"); //Calculate number of medium items to send. Aim to almost fill the buffer int no_of_medium_items = (BUFFER_SIZE - (ITEM_HDR_SIZE + MEDIUM_ITEM_SIZE)) / (ITEM_HDR_SIZE + MEDIUM_ITEM_SIZE); //Test sending items for (int i = 0; i < no_of_medium_items; i++) { send_item_and_check(buffer_handle, large_item, MEDIUM_ITEM_SIZE, TIMEOUT_TICKS, false); } //Verify items waiting matches with the number of medium items sent UBaseType_t items_waiting; vRingbufferGetInfo(buffer_handle, NULL, NULL, NULL, NULL, &items_waiting); TEST_ASSERT_MESSAGE(items_waiting == no_of_medium_items, "Incorrect items waiting"); //Send one small sized item. This will ensure that the item fits at the end of the buffer without causing the write pointer to wrap around. send_item_and_check(buffer_handle, small_item, SMALL_ITEM_SIZE, TIMEOUT_TICKS, false); //The buffer should not have any free space as the number of bytes remaining should be < ITEM_HDR_SIZE. TEST_ASSERT_MESSAGE(xRingbufferGetCurFreeSize(buffer_handle) == 0, "Buffer full not achieved"); //Send an item. The item should not be sent to a full buffer. send_item_and_check_failure(buffer_handle, small_item, SMALL_ITEM_SIZE, TIMEOUT_TICKS, false); //Test receiving medium items for (int i = 0; i < no_of_medium_items; i++) { receive_check_and_return_item_allow_split(buffer_handle, large_item, MEDIUM_ITEM_SIZE, TIMEOUT_TICKS, false); } //Test receiving small item receive_check_and_return_item_allow_split(buffer_handle, small_item, SMALL_ITEM_SIZE, TIMEOUT_TICKS, false); //Verify that no items are waiting vRingbufferGetInfo(buffer_handle, NULL, NULL, NULL, NULL, &items_waiting); TEST_ASSERT_MESSAGE(items_waiting == 0, "Incorrect items waiting"); //Cleanup vRingbufferDelete(buffer_handle); } TEST_CASE("TC#1: Byte buffer", "[esp_ringbuf]") { //Create buffer RingbufHandle_t buffer_handle = xRingbufferCreate(BUFFER_SIZE, RINGBUF_TYPE_BYTEBUF); TEST_ASSERT_MESSAGE(buffer_handle != NULL, "Failed to create ring buffer"); //Check buffer free size and max item size upon buffer creation. Should be BUFFER_SIZE TEST_ASSERT_MESSAGE(xRingbufferGetCurFreeSize(buffer_handle) == BUFFER_SIZE, "Incorrect buffer free size received"); TEST_ASSERT_MESSAGE(xRingbufferGetMaxItemSize(buffer_handle) == BUFFER_SIZE, "Incorrect max item size received"); //Calculate number of items to send. Aim to almost fill buffer to setup for wrap around int no_of_items = (BUFFER_SIZE - SMALL_ITEM_SIZE) / SMALL_ITEM_SIZE; //Test sending items for (int i = 0; i < no_of_items; i++) { send_item_and_check(buffer_handle, small_item, SMALL_ITEM_SIZE, TIMEOUT_TICKS, false); } //Verify items waiting matches with the number of items sent UBaseType_t items_waiting; vRingbufferGetInfo(buffer_handle, NULL, NULL, NULL, NULL, &items_waiting); TEST_ASSERT_MESSAGE(items_waiting == no_of_items * SMALL_ITEM_SIZE, "Incorrect number of bytes waiting"); //Test receiving items for (int i = 0; i < no_of_items; i++) { receive_check_and_return_item_byte_buffer(buffer_handle, small_item, SMALL_ITEM_SIZE, TIMEOUT_TICKS, false); } //Verify that no items are waiting vRingbufferGetInfo(buffer_handle, NULL, NULL, NULL, NULL, &items_waiting); TEST_ASSERT_MESSAGE(items_waiting == 0, "Incorrect number of bytes waiting"); //Write pointer should be near the end, test wrap around UBaseType_t write_pos_before, write_pos_after; vRingbufferGetInfo(buffer_handle, NULL, NULL, &write_pos_before, NULL, NULL); //Send large item that causes wrap around send_item_and_check(buffer_handle, large_item, LARGE_ITEM_SIZE, TIMEOUT_TICKS, false); //Receive wrapped item receive_check_and_return_item_byte_buffer(buffer_handle, large_item, LARGE_ITEM_SIZE, TIMEOUT_TICKS, false); vRingbufferGetInfo(buffer_handle, NULL, NULL, &write_pos_after, NULL, NULL); TEST_ASSERT_MESSAGE(write_pos_after < write_pos_before, "Failed to wrap around"); //Cleanup vRingbufferDelete(buffer_handle); } TEST_CASE("TC#2: Byte buffer", "[esp_ringbuf]") { //Create buffer RingbufHandle_t buffer_handle = xRingbufferCreate(BUFFER_SIZE, RINGBUF_TYPE_BYTEBUF); TEST_ASSERT_MESSAGE(buffer_handle != NULL, "Failed to create ring buffer"); //Check buffer free size and max item size upon buffer creation. Should be BUFFER_SIZE. TEST_ASSERT_MESSAGE(xRingbufferGetCurFreeSize(buffer_handle) == BUFFER_SIZE, "Incorrect buffer free size received"); TEST_ASSERT_MESSAGE(xRingbufferGetMaxItemSize(buffer_handle) == BUFFER_SIZE, "Incorrect max item size received"); //Calculate number of items to send. Aim to fill the buffer int no_of_items = BUFFER_SIZE / SMALL_ITEM_SIZE; //Test sending items for (int i = 0; i < no_of_items; i++) { send_item_and_check(buffer_handle, small_item, SMALL_ITEM_SIZE, TIMEOUT_TICKS, false); } //Verify items waiting matches with the number of items sent UBaseType_t items_waiting; vRingbufferGetInfo(buffer_handle, NULL, NULL, NULL, NULL, &items_waiting); TEST_ASSERT_MESSAGE(items_waiting == no_of_items * SMALL_ITEM_SIZE, "Incorrect number of bytes waiting"); //At this point, the buffer should be full. TEST_ASSERT_MESSAGE(xRingbufferGetCurFreeSize(buffer_handle) == 0, "Buffer full not achieved"); //Send an item. The item should not be sent to a full buffer. send_item_and_check_failure(buffer_handle, small_item, SMALL_ITEM_SIZE, TIMEOUT_TICKS, false); //Receive one item receive_check_and_return_item_byte_buffer(buffer_handle, small_item, SMALL_ITEM_SIZE, TIMEOUT_TICKS, false); //At this point, the buffer should not be full any more TEST_ASSERT_MESSAGE(xRingbufferGetCurFreeSize(buffer_handle) > 0, "Buffer should have free space"); //Test receiving remaining items for (int i = 0; i < no_of_items - 1; i++) { receive_check_and_return_item_byte_buffer(buffer_handle, small_item, SMALL_ITEM_SIZE, TIMEOUT_TICKS, false); } //Verify that no items are waiting vRingbufferGetInfo(buffer_handle, NULL, NULL, NULL, NULL, &items_waiting); TEST_ASSERT_MESSAGE(items_waiting == 0, "Incorrect items waiting"); //Cleanup vRingbufferDelete(buffer_handle); } TEST_CASE("TC#3: Byte buffer", "[esp_ringbuf]") { //Create buffer RingbufHandle_t buffer_handle = xRingbufferCreate(BUFFER_SIZE, RINGBUF_TYPE_BYTEBUF); TEST_ASSERT_MESSAGE(buffer_handle != NULL, "Failed to create ring buffer"); //Check buffer free size and max item size upon buffer creation. Should be BUFFER_SIZE. TEST_ASSERT_MESSAGE(xRingbufferGetCurFreeSize(buffer_handle) == BUFFER_SIZE, "Incorrect buffer free size received"); TEST_ASSERT_MESSAGE(xRingbufferGetMaxItemSize(buffer_handle) == BUFFER_SIZE, "Incorrect max item size received"); //Calculate number of medium items to send. Aim to almost fill the buffer int no_of_medium_items = BUFFER_SIZE / MEDIUM_ITEM_SIZE; //Test sending items for (int i = 0; i < no_of_medium_items; i++) { send_item_and_check(buffer_handle, large_item, MEDIUM_ITEM_SIZE, TIMEOUT_TICKS, false); } //Verify items waiting matches with the number of medium items sent UBaseType_t items_waiting; vRingbufferGetInfo(buffer_handle, NULL, NULL, NULL, NULL, &items_waiting); TEST_ASSERT_MESSAGE(items_waiting == no_of_medium_items * MEDIUM_ITEM_SIZE, "Incorrect number of bytes waiting"); //The buffer should not have any free space for one small item. TEST_ASSERT_MESSAGE(xRingbufferGetCurFreeSize(buffer_handle) < SMALL_ITEM_SIZE, "Buffer full not achieved"); //Send an item. The item should not be sent to a full buffer. send_item_and_check_failure(buffer_handle, small_item, SMALL_ITEM_SIZE, TIMEOUT_TICKS, false); //Test receiving medium items for (int i = 0; i < no_of_medium_items; i++) { receive_check_and_return_item_byte_buffer(buffer_handle, large_item, MEDIUM_ITEM_SIZE, TIMEOUT_TICKS, false); } //Verify that no items are waiting vRingbufferGetInfo(buffer_handle, NULL, NULL, NULL, NULL, &items_waiting); TEST_ASSERT_MESSAGE(items_waiting == 0, "Incorrect items waiting"); //Cleanup vRingbufferDelete(buffer_handle); } /* ----------------------- Ring buffer queue sets test ------------------------ * The following test case will test receiving from ring buffers that have been * added to a queue set. The test case will do the following... * 1) Ring buffer of each type is created and added to the queue set * 2) A receiving task is created to select from the queue set and read from the appropriate ring buffer */ static void queue_set_receiving_task(void *queue_set_handle) { QueueSetHandle_t queue_set = (QueueSetHandle_t)queue_set_handle; //Receive multiple items via queue set BaseType_t done = pdFALSE; int no_of_items = BUFFER_SIZE / SMALL_ITEM_SIZE; int items_rec_count[NO_OF_RB_TYPES] = {0}; while (done != pdTRUE) { QueueSetMemberHandle_t member = xQueueSelectFromSet(queue_set, TIMEOUT_TICKS); //Read from selected ring buffer if (xRingbufferCanRead(buffer_handles[0], member) == pdTRUE) { //No-split buffer receive_check_and_return_item_no_split(buffer_handles[0], small_item, SMALL_ITEM_SIZE, 0, false); items_rec_count[0] ++; } else if (xRingbufferCanRead(buffer_handles[1], member) == pdTRUE) { //Allow-split buffer receive_check_and_return_item_allow_split(buffer_handles[1], small_item, SMALL_ITEM_SIZE, 0, false); items_rec_count[1] ++; } else if (xRingbufferCanRead(buffer_handles[2], member) == pdTRUE) { //Byte buffer receive_check_and_return_item_byte_buffer(buffer_handles[2], small_item, SMALL_ITEM_SIZE, 0, false); items_rec_count[2] ++; } else { TEST_ASSERT_MESSAGE(false, "Error with queue set member"); } //Check for completion if (items_rec_count[0] == no_of_items && items_rec_count[1] == no_of_items && items_rec_count[2] == no_of_items) { done = pdTRUE; } } xSemaphoreGive(done_sem); vTaskDelete(NULL); } TEST_CASE("Test ring buffer with queue sets", "[esp_ringbuf]") { QueueSetHandle_t queue_set = xQueueCreateSet(NO_OF_RB_TYPES); done_sem = xSemaphoreCreateBinary(); //Create ring buffer of each type, then add them to a queue set for (int i = 0; i < NO_OF_RB_TYPES; i++) { buffer_handles[i] = xRingbufferCreate(BUFFER_SIZE, i); TEST_ASSERT_MESSAGE(buffer_handles[i] != NULL, "Failed to create ring buffer"); TEST_ASSERT_MESSAGE(xRingbufferAddToQueueSetRead(buffer_handles[i], queue_set) == pdPASS, "Failed to add to read queue set"); } //Create a task to send items to each ring buffer int no_of_items = BUFFER_SIZE / SMALL_ITEM_SIZE; xTaskCreatePinnedToCore(queue_set_receiving_task, "rec tsk", 2048, (void *)queue_set, 10, NULL, 0); //Send multiple items to each type of ring buffer for (int i = 0; i < no_of_items; i++) { for (int j = 0; j < NO_OF_RB_TYPES; j++) { send_item_and_check(buffer_handles[j], small_item, SMALL_ITEM_SIZE, TIMEOUT_TICKS, false); } } xSemaphoreTake(done_sem, portMAX_DELAY); vSemaphoreDelete(done_sem); //Remove and delete ring buffers from queue sets for (int i = 0; i < NO_OF_RB_TYPES; i++) { TEST_ASSERT_MESSAGE(xRingbufferRemoveFromQueueSetRead(buffer_handles[i], queue_set) == pdTRUE, "Failed to remove from read queue set"); vRingbufferDelete(buffer_handles[i]); } vQueueDelete(queue_set); vTaskDelay(1); } /* -------------------------- Test ring buffer ISR ----------------------------- * The following test case tests ring buffer ISR API. A timer is used to trigger * the ISR. The test case will do the following * 1) ISR will be triggered periodically by timer * 2) The ISR will iterate through all ring buffer types where each iteration * will send then receive an item to a ring buffer. */ #define ISR_ITERATIONS ((BUFFER_SIZE / SMALL_ITEM_SIZE) * 2) static int buf_type; static int iterations; static bool on_timer_alarm(gptimer_handle_t timer, const gptimer_alarm_event_data_t *edata, void *user_ctx) { bool need_yield = false; //Test sending to buffer from ISR from ISR if (buf_type < NO_OF_RB_TYPES) { send_item_and_check(buffer_handles[buf_type], (void *)small_item, SMALL_ITEM_SIZE, 0, true); } //Receive item from ISR if (buf_type == RINGBUF_TYPE_NOSPLIT) { //Test receive from ISR for no-split buffer receive_check_and_return_item_no_split(buffer_handles[buf_type], (void *)small_item, SMALL_ITEM_SIZE, 0, true); buf_type++; } else if (buf_type == RINGBUF_TYPE_ALLOWSPLIT) { //Test send from ISR to allow-split buffer receive_check_and_return_item_allow_split(buffer_handles[buf_type], (void *)small_item, SMALL_ITEM_SIZE, 0, true); buf_type++; } else if (buf_type == RINGBUF_TYPE_BYTEBUF) { //Test receive from ISR for byte buffer receive_check_and_return_item_byte_buffer(buffer_handles[buf_type], (void *)small_item, SMALL_ITEM_SIZE, 0, true); buf_type++; } else if (buf_type == NO_OF_RB_TYPES) { //Check if all iterations complete if (iterations < ISR_ITERATIONS) { iterations++; buf_type = 0; //Reset and iterate through each buffer type again goto out; } else { //Signal complete BaseType_t task_woken = pdFALSE; xSemaphoreGiveFromISR(done_sem, &task_woken); if (task_woken == pdTRUE) { buf_type++; need_yield = true; } } } out: return need_yield; } // IDF-6471 - test hangs up on QEMU TEST_CASE("Test ring buffer ISR", "[esp_ringbuf][qemu-ignore]") { gptimer_handle_t gptimer; for (int i = 0; i < NO_OF_RB_TYPES; i++) { buffer_handles[i] = xRingbufferCreate(BUFFER_SIZE, i); } done_sem = xSemaphoreCreateBinary(); buf_type = 0; iterations = 0; //Setup timer for ISR gptimer_config_t config = { .clk_src = GPTIMER_CLK_SRC_DEFAULT, .direction = GPTIMER_COUNT_UP, .resolution_hz = 1000000, }; TEST_ESP_OK(gptimer_new_timer(&config, &gptimer)); gptimer_alarm_config_t alarm_config = { .reload_count = 0, .alarm_count = 2000, .flags.auto_reload_on_alarm = true, }; gptimer_event_callbacks_t cbs = { .on_alarm = on_timer_alarm, }; TEST_ESP_OK(gptimer_register_event_callbacks(gptimer, &cbs, NULL)); TEST_ESP_OK(gptimer_set_alarm_action(gptimer, &alarm_config)); TEST_ESP_OK(gptimer_enable(gptimer)); TEST_ESP_OK(gptimer_start(gptimer)); //Wait for ISR to complete multiple iterations xSemaphoreTake(done_sem, portMAX_DELAY); //Cleanup TEST_ESP_OK(gptimer_stop(gptimer)); TEST_ESP_OK(gptimer_disable(gptimer)); TEST_ESP_OK(gptimer_del_timer(gptimer)); vSemaphoreDelete(done_sem); for (int i = 0; i < NO_OF_RB_TYPES; i++) { vRingbufferDelete(buffer_handles[i]); } } /* ---------------------------- Test ring buffer SMP --------------------------- * The following test case tests each type of ring buffer in an SMP fashion. A * sending task and a receiving task is created. The sending task will split * a continuous piece of data into items of random length and send it to a ring * buffer. The receiving task will receive and check those items. * Every permutation of core pinning of the sending and receiving task will be * tested. */ #define SRAND_SEED 3 //Arbitrarily chosen srand() seed #define SMP_TEST_ITERATIONS 4 static const char continuous_data[] = {"A_very_long_string_that_will_be_split_into_" "items_of_random_lengths_and_sent_to_the_ring_" "buffer._The_maximum_random_length_will_also_" "be_increased_over_multiple_iterations_in_this" "_test" }; #define CONT_DATA_LEN sizeof(continuous_data) //32-bit aligned size that guarantees a wrap around at some point #define CONT_DATA_TEST_BUFF_LEN (((CONT_DATA_LEN/2) + 0x03) & ~0x3) typedef struct { RingbufHandle_t buffer; RingbufferType_t type; } task_args_t; static SemaphoreHandle_t tasks_done; static SemaphoreHandle_t tx_done; static SemaphoreHandle_t rx_done; static void send_to_buffer(RingbufHandle_t buffer, size_t max_item_size) { for (int iter = 0; iter < SMP_TEST_ITERATIONS; iter++) { size_t bytes_sent = 0; //Number of data bytes sent in this iteration size_t next_item_size; //Size of next item to send while (bytes_sent < CONT_DATA_LEN) { //Get size of next item next_item_size = rand() % (max_item_size + 1); if (next_item_size + bytes_sent > CONT_DATA_LEN) { next_item_size = CONT_DATA_LEN - bytes_sent; } //Send item TEST_ASSERT_MESSAGE(xRingbufferSend(buffer, (void *) & (continuous_data[bytes_sent]), next_item_size, TIMEOUT_TICKS) == pdTRUE, "Failed to send an item"); bytes_sent += next_item_size; } xSemaphoreGive(tx_done); xSemaphoreTake(rx_done, portMAX_DELAY); } } static void read_from_buffer(RingbufHandle_t buffer, RingbufferType_t buf_type, size_t max_rec_size) { for (int iter = 0; iter < SMP_TEST_ITERATIONS; iter++) { size_t bytes_rec = 0; //Number of data bytes received in this iteration while (bytes_rec < CONT_DATA_LEN) { size_t item_size, item_size2; //Possible for allow split buffers to receive two items char *item_data, *item_data2; //Select appropriate receive function for type of ring buffer if (buf_type == RINGBUF_TYPE_NOSPLIT) { item_data = (char *)xRingbufferReceive(buffer, &item_size, TIMEOUT_TICKS); } else if (buf_type == RINGBUF_TYPE_ALLOWSPLIT) { BaseType_t ret = xRingbufferReceiveSplit(buffer, (void **)&item_data, (void **)&item_data2, &item_size, &item_size2, TIMEOUT_TICKS); TEST_ASSERT_MESSAGE(ret == pdTRUE, "Failed to receive any item"); } else { item_data = (char *)xRingbufferReceiveUpTo(buffer, &item_size, TIMEOUT_TICKS, max_rec_size); } //Check received item and return it TEST_ASSERT_MESSAGE(item_data != NULL, "Failed to receive an item"); if (buf_type == RINGBUF_TYPE_BYTEBUF) { TEST_ASSERT_MESSAGE(item_size <= max_rec_size, "Received data exceeds max size"); } for (int i = 0; i < item_size; i++) { //Check item_data is valid TEST_ASSERT_MESSAGE(item_data[i] == continuous_data[bytes_rec + i], "Received data is corrupted"); } bytes_rec += item_size; vRingbufferReturnItem(buffer, item_data); if (buf_type == RINGBUF_TYPE_ALLOWSPLIT && item_data2 != NULL) { //Check item_data2 is valid for (int i = 0; i < item_size2; i++) { TEST_ASSERT_MESSAGE(item_data2[i] == continuous_data[bytes_rec + i], "Received split data is corrupted"); } bytes_rec += item_size2; vRingbufferReturnItem(buffer, item_data2); } } TEST_ASSERT_MESSAGE(bytes_rec == CONT_DATA_LEN, "Total length of received data is incorrect"); xSemaphoreGive(rx_done); xSemaphoreTake(tx_done, portMAX_DELAY); } } static void send_task(void *args) { RingbufHandle_t buffer = ((task_args_t *)args)->buffer; size_t max_item_len = xRingbufferGetMaxItemSize(buffer); //Test sending short length items send_to_buffer(buffer, 1); //Test sending mid length items send_to_buffer(buffer, max_item_len / 2); //Test sending long length items send_to_buffer(buffer, max_item_len); vTaskDelete(NULL); } static void rec_task(void *args) { RingbufHandle_t buffer = ((task_args_t *)args)->buffer; size_t max_rec_len = xRingbufferGetMaxItemSize(buffer); //Test receiving short length items read_from_buffer(buffer, ((task_args_t *)args)->type, 1); //Test receiving mid length items read_from_buffer(buffer, ((task_args_t *)args)->type, max_rec_len / 2); //Test receiving long length items read_from_buffer(buffer, ((task_args_t *)args)->type, max_rec_len); xSemaphoreGive(tasks_done); vTaskDelete(NULL); } static void setup(void) { esp_rom_printf("Size of test data: %d\n", CONT_DATA_LEN); tx_done = xSemaphoreCreateBinary(); //Semaphore to indicate send is done for a particular iteration rx_done = xSemaphoreCreateBinary(); //Semaphore to indicate receive is done for a particular iteration tasks_done = xSemaphoreCreateBinary(); //Semaphore used to to indicate send and receive tasks completed running srand(SRAND_SEED); //Seed RNG } static void cleanup(void) { //Cleanup vSemaphoreDelete(tx_done); vSemaphoreDelete(rx_done); vSemaphoreDelete(tasks_done); } TEST_CASE("Test ring buffer SMP", "[esp_ringbuf]") { setup(); //Iterate through buffer types (No split, split, then byte buff) for (RingbufferType_t buf_type = 0; buf_type < RINGBUF_TYPE_MAX; buf_type++) { //Create buffer task_args_t task_args; task_args.buffer = xRingbufferCreate(CONT_DATA_TEST_BUFF_LEN, buf_type); //Create buffer of selected type task_args.type = buf_type; TEST_ASSERT_MESSAGE(task_args.buffer != NULL, "Failed to create ring buffer"); for (int prior_mod = -1; prior_mod < 2; prior_mod++) { //Test different relative priorities //Test every permutation of core affinity for (int send_core = 0; send_core < CONFIG_FREERTOS_NUMBER_OF_CORES; send_core++) { for (int rec_core = 0; rec_core < CONFIG_FREERTOS_NUMBER_OF_CORES; rec_core ++) { esp_rom_printf("Type: %d, PM: %d, SC: %d, RC: %d\n", buf_type, prior_mod, send_core, rec_core); xTaskCreatePinnedToCore(send_task, "send tsk", 2048, (void *)&task_args, 10 + prior_mod, NULL, send_core); xTaskCreatePinnedToCore(rec_task, "rec tsk", 2048, (void *)&task_args, 10, NULL, rec_core); xSemaphoreTake(tasks_done, portMAX_DELAY); vTaskDelay(5); //Allow idle to clean up } } } //Delete ring buffer vRingbufferDelete(task_args.buffer); vTaskDelay(10); } cleanup(); } #if ( configSUPPORT_STATIC_ALLOCATION == 1 ) TEST_CASE("Test static ring buffer SMP", "[esp_ringbuf]") { setup(); //Iterate through buffer types (No split, split, then byte buff) for (RingbufferType_t buf_type = 0; buf_type < RINGBUF_TYPE_MAX; buf_type++) { StaticRingbuffer_t *buffer_struct; uint8_t *buffer_storage; //Allocate memory and create semaphores #if CONFIG_SPIRAM_USE_CAPS_ALLOC //When SPIRAM can only be allocated using heap_caps_malloc() buffer_struct = (StaticRingbuffer_t *)heap_caps_malloc(sizeof(StaticRingbuffer_t), MALLOC_CAP_SPIRAM); buffer_storage = (uint8_t *)heap_caps_malloc(sizeof(uint8_t) * CONT_DATA_TEST_BUFF_LEN, MALLOC_CAP_SPIRAM); #else //Case where SPIRAM is disabled or when SPIRAM is allocatable through malloc() buffer_struct = (StaticRingbuffer_t *)malloc(sizeof(StaticRingbuffer_t)); buffer_storage = (uint8_t *)malloc(sizeof(uint8_t) * CONT_DATA_TEST_BUFF_LEN); #endif TEST_ASSERT(buffer_struct != NULL && buffer_storage != NULL); //Create buffer task_args_t task_args; task_args.buffer = xRingbufferCreateStatic(CONT_DATA_TEST_BUFF_LEN, buf_type, buffer_storage, buffer_struct); //Create buffer of selected type task_args.type = buf_type; TEST_ASSERT_MESSAGE(task_args.buffer != NULL, "Failed to create ring buffer"); for (int prior_mod = -1; prior_mod < 2; prior_mod++) { //Test different relative priorities //Test every permutation of core affinity for (int send_core = 0; send_core < CONFIG_FREERTOS_NUMBER_OF_CORES; send_core++) { for (int rec_core = 0; rec_core < CONFIG_FREERTOS_NUMBER_OF_CORES; rec_core ++) { esp_rom_printf("Type: %d, PM: %d, SC: %d, RC: %d\n", buf_type, prior_mod, send_core, rec_core); xTaskCreatePinnedToCore(send_task, "send tsk", 2048, (void *)&task_args, 10 + prior_mod, NULL, send_core); xTaskCreatePinnedToCore(rec_task, "rec tsk", 2048, (void *)&task_args, 10, NULL, rec_core); xSemaphoreTake(tasks_done, portMAX_DELAY); vTaskDelay(5); //Allow idle to clean up } } } //Delete ring buffer vRingbufferDelete(task_args.buffer); //Deallocate memory free(buffer_storage); free(buffer_struct); vTaskDelay(10); } cleanup(); } #endif #if !CONFIG_RINGBUF_PLACE_FUNCTIONS_INTO_FLASH && !CONFIG_RINGBUF_PLACE_ISR_FUNCTIONS_INTO_FLASH /* -------------------------- Test ring buffer IRAM ------------------------- */ static IRAM_ATTR __attribute__((noinline)) bool iram_ringbuf_test(void) { bool result = true; uint8_t item[4]; size_t item_size; RingbufHandle_t handle = xRingbufferCreate(CONT_DATA_TEST_BUFF_LEN, RINGBUF_TYPE_NOSPLIT); result = result && (handle != NULL); spi_flash_guard_get()->start(); // Disables flash cache xRingbufferGetMaxItemSize(handle); xRingbufferSendFromISR(handle, (void *)item, sizeof(item), NULL); xRingbufferReceiveFromISR(handle, &item_size); spi_flash_guard_get()->end(); // Re-enables flash cache vRingbufferDelete(handle); return result; } TEST_CASE("Test ringbuffer functions work with flash cache disabled", "[esp_ringbuf]") { TEST_ASSERT(iram_ringbuf_test()); } #endif /* !CONFIG_RINGBUF_PLACE_FUNCTIONS_INTO_FLASH && !CONFIG_RINGBUF_PLACE_ISR_FUNCTIONS_INTO_FLASH */ /* ------------------------ Test ring buffer 0 Item Size ----------------------- * The following test case tests that sending/acquiring an item/bytes of 0 size * is permissible. */ TEST_CASE("Test ringbuffer 0 item size", "[esp_ringbuf]") { RingbufHandle_t no_split_rb = xRingbufferCreate(BUFFER_SIZE, RINGBUF_TYPE_NOSPLIT); RingbufHandle_t allow_split_rb = xRingbufferCreate(BUFFER_SIZE, RINGBUF_TYPE_ALLOWSPLIT); RingbufHandle_t byte_rb = xRingbufferCreate(BUFFER_SIZE, RINGBUF_TYPE_BYTEBUF); TEST_ASSERT_MESSAGE(no_split_rb && allow_split_rb && byte_rb, "Failed to create ring buffers"); void *pvItem1; void *pvItem2; size_t xItemSize1; size_t xItemSize2; //Test that 0 item size on no split buffers should only send a header with no data TEST_ASSERT_EQUAL(pdTRUE, xRingbufferSend(no_split_rb, NULL, 0, 0)); TEST_ASSERT_NOT_EQUAL(NULL, xRingbufferReceive(no_split_rb, &xItemSize1, 0)); TEST_ASSERT_EQUAL(0, xItemSize1); //Test that acquiring 0 item size on no split buffers should only send a header without reserving a data buffer TEST_ASSERT_EQUAL(pdTRUE, xRingbufferSendAcquire(no_split_rb, &pvItem1, 0, 0)); TEST_ASSERT_NOT_EQUAL(NULL, pvItem1); TEST_ASSERT_EQUAL(pdTRUE, xRingbufferSendComplete(no_split_rb, pvItem1)); TEST_ASSERT_NOT_EQUAL(NULL, xRingbufferReceive(no_split_rb, &xItemSize1, 0)); TEST_ASSERT_EQUAL(0, xItemSize1); //Test that 0 item size on allow split buffers should only send a header with no data TEST_ASSERT_EQUAL(pdTRUE, xRingbufferSend(allow_split_rb, NULL, 0, 0)); TEST_ASSERT_EQUAL(pdTRUE, xRingbufferReceiveSplit(allow_split_rb, &pvItem1, &pvItem2, &xItemSize1, &xItemSize2, 0)); TEST_ASSERT_NOT_EQUAL(NULL, pvItem1); TEST_ASSERT_EQUAL(NULL, pvItem2); TEST_ASSERT_EQUAL(0, xItemSize1); //Test that 0 item size on byte buffers should send nothing TEST_ASSERT_EQUAL(pdTRUE, xRingbufferSend(byte_rb, NULL, 0, 0)); TEST_ASSERT_EQUAL(pdFALSE, xRingbufferReceiveUpTo(byte_rb, &xItemSize1, 0, BUFFER_SIZE)); //Cleanup vRingbufferDelete(no_split_rb); vRingbufferDelete(allow_split_rb); vRingbufferDelete(byte_rb); } /* --------------------- Test ring buffer create with caps --------------------- * The following test case tests ring buffer creation with caps. Specifically * the following APIs: * * - xRingbufferCreateWithCaps() * - vRingbufferDeleteWithCaps() * - xRingbufferGetStaticBuffer() */ TEST_CASE("Test ringbuffer with caps", "[esp_ringbuf]") { RingbufHandle_t rb_handle; uint8_t *rb_storage; StaticRingbuffer_t *rb_obj; // Create ring buffer with caps rb_handle = xRingbufferCreateWithCaps(BUFFER_SIZE, RINGBUF_TYPE_NOSPLIT, (MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT)); TEST_ASSERT_NOT_EQUAL(NULL, rb_handle); // Get the ring buffer's memory TEST_ASSERT_EQUAL(pdTRUE, xRingbufferGetStaticBuffer(rb_handle, &rb_storage, &rb_obj)); TEST_ASSERT(esp_ptr_in_dram(rb_storage)); TEST_ASSERT(esp_ptr_in_dram(rb_obj)); // Free the ring buffer vRingbufferDeleteWithCaps(rb_handle); }