| /* |
| * Copyright (c) 2012-2014 Wind River Systems, Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /* |
| * @file |
| * @brief Test nanokernel FIFO APIs |
| * |
| * This module tests four basic scenarios with the usage of the following FIFO |
| * routines: |
| * |
| * nano_fiber_fifo_get, nano_fiber_fifo_put |
| * nano_task_fifo_get, nano_task_fifo_put |
| * nano_isr_fifo_get, nano_isr_fifo_put |
| * |
| * Scenario #1 |
| * Task enters items into a queue, starts the fiber and waits for a semaphore. |
| * Fiber extracts all items from the queue and enters some items back into |
| * the queue. Fiber gives the semaphore for task to continue. Once the control |
| * is returned back to task, task extracts all items from the queue. |
| |
| * Scenario #2 |
| * Task enters an item into queue2, starts a fiber and extract an item from |
| * queue1 once the item is there. The fiber will extract an item from queue2 |
| * once the item is there and and enter an item to queue1. The flow of control |
| * goes from task to fiber and so forth. |
| |
| * Scenario #3 |
| * Tests the ISR interfaces. Function testIsrFifoFromFiber gets an item from |
| * the fifo queue in ISR context. It then enters four items into the queue |
| * and finishes execution. Control is returned back to function |
| * testTaskFifoGetW which also finished it's execution and returned to main. |
| * Finally function testIsrFifoFromTask is run and it gets all data from |
| * the queue and puts and gets one last item to the queue. All these are run |
| * in ISR context. |
| * |
| * Scenario #4: |
| * Timeout scenarios with multiple FIFOs and fibers. |
| */ |
| |
| #include <zephyr.h> |
| #include <tc_util.h> |
| #include <misc/__assert.h> |
| #include <misc/util.h> |
| #include <irq_offload.h> |
| |
| #include <util_test_common.h> |
| |
| #define FIBER_STACKSIZE 256 |
| #define NUM_FIFO_ELEMENT 4 |
| #define INVALID_DATA NULL |
| |
| #define TCERR1(count) TC_ERROR("Didn't get back correct FIFO, count %d\n", count) |
| #define TCERR2 TC_ERROR("Didn't get back correct FIFO\n") |
| #define TCERR3 TC_ERROR("The queue should be empty!\n") |
| |
| struct isr_fifo_info { |
| struct nano_fifo *fifo_ptr; /* FIFO */ |
| void *data; /* pointer to data to add */ |
| }; |
| |
| char __stack fiberStack1[FIBER_STACKSIZE]; |
| char __stack fiberStack2[FIBER_STACKSIZE]; |
| char __stack fiberStack3[FIBER_STACKSIZE]; |
| |
| struct nano_fifo nanoFifoObj; |
| struct nano_fifo nanoFifoObj2; |
| |
| struct nano_sem nanoSemObj1; /* Used to block/wake-up fiber1 */ |
| struct nano_sem nanoSemObj2; /* Used to block/wake-up fiber2 */ |
| struct nano_sem nanoSemObj3; /* Used to block/wake-up fiber3 */ |
| struct nano_sem nanoSemObjTask; /* Used to block/wake-up task */ |
| |
| struct nano_timer timer; |
| void *timerData[1]; |
| |
| int myFifoData1[4]; |
| int myFifoData2[2]; |
| int myFifoData3[4]; |
| int myFifoData4[2]; |
| |
| void * const pMyFifoData1 = (void *)myFifoData1; |
| void * const pMyFifoData2 = (void *)myFifoData2; |
| void * const pMyFifoData3 = (void *)myFifoData3; |
| void * const pMyFifoData4 = (void *)myFifoData4; |
| |
| void * const pPutList1[NUM_FIFO_ELEMENT] = { |
| (void *)myFifoData1, |
| (void *)myFifoData2, |
| (void *)myFifoData3, |
| (void *)myFifoData4 |
| }; |
| |
| void * const pPutList2[NUM_FIFO_ELEMENT] = { |
| (void *)myFifoData4, |
| (void *)myFifoData3, |
| (void *)myFifoData2, |
| (void *)myFifoData1 |
| }; |
| |
| int retCode = TC_PASS; |
| |
| static struct isr_fifo_info isrFifoInfo = {&nanoFifoObj, NULL}; |
| |
| void fiber1(void); |
| void fiber2(void); |
| void fiber3(void); |
| |
| void initNanoObjects(void); |
| void testTaskFifoGetW(void); |
| |
| extern int test_fifo_timeout(void); |
| |
| /** |
| * |
| * @brief Add an item to a FIFO |
| * |
| * This routine is the ISR handler for _trigger_nano_isr_fifo_put(). It adds |
| * an item to the FIFO in the context of an ISR. |
| * |
| * @param parameter pointer to ISR handler parameter |
| * |
| * @return N/A |
| */ |
| |
| void isr_fifo_put(void *parameter) |
| { |
| struct isr_fifo_info *pInfo = (struct isr_fifo_info *) parameter; |
| |
| nano_isr_fifo_put(pInfo->fifo_ptr, pInfo->data); |
| } |
| |
| static void _trigger_nano_isr_fifo_put(void) |
| { |
| irq_offload(isr_fifo_put, &isrFifoInfo); |
| } |
| |
| |
| /** |
| * |
| * @brief Get an item from a FIFO |
| * |
| * This routine is the ISR handler for _trigger_nano_isr_fifo_get(). It gets |
| * an item from the FIFO in the context of an ISR. |
| * |
| * @param parameter pointer to ISR handler parameter |
| * |
| * @return N/A |
| */ |
| |
| void isr_fifo_get(void *parameter) |
| { |
| struct isr_fifo_info *pInfo = (struct isr_fifo_info *) parameter; |
| |
| pInfo->data = nano_isr_fifo_get(pInfo->fifo_ptr, TICKS_NONE); |
| } |
| |
| static void _trigger_nano_isr_fifo_get(void) |
| { |
| irq_offload(isr_fifo_get, &isrFifoInfo); |
| } |
| |
| /** |
| * |
| * @brief Entry point for the first fiber |
| * |
| * @return N/A |
| */ |
| |
| void fiber1(void) |
| { |
| void *pData; /* pointer to FIFO object get from the queue */ |
| int count = 0; /* counter */ |
| |
| /* Wait for fiber1 to be activated. */ |
| nano_fiber_sem_take(&nanoSemObj1, TICKS_UNLIMITED); |
| |
| /* Wait for data to be added to <nanoFifoObj> by task */ |
| pData = nano_fiber_fifo_get(&nanoFifoObj, TICKS_UNLIMITED); |
| if (pData != pPutList1[0]) { |
| TC_ERROR("fiber1 (1) - expected 0x%x, got 0x%x\n", |
| pPutList1[0], pData); |
| retCode = TC_FAIL; |
| return; |
| } |
| |
| /* Wait for data to be added to <nanoFifoObj2> by fiber3 */ |
| pData = nano_fiber_fifo_get(&nanoFifoObj2, TICKS_UNLIMITED); |
| if (pData != pPutList2[0]) { |
| TC_ERROR("fiber1 (2) - expected 0x%x, got 0x%x\n", |
| pPutList2[0], pData); |
| retCode = TC_FAIL; |
| return; |
| } |
| |
| /* Wait for fiber1 to be reactivated */ |
| nano_fiber_sem_take(&nanoSemObj1, TICKS_UNLIMITED); |
| |
| TC_PRINT("Test Fiber FIFO Get\n\n"); |
| /* Get all FIFOs */ |
| while ((pData = nano_fiber_fifo_get(&nanoFifoObj, TICKS_NONE)) != NULL) { |
| TC_PRINT("FIBER FIFO Get: count = %d, ptr is %p\n", count, pData); |
| if ((count >= NUM_FIFO_ELEMENT) || (pData != pPutList1[count])) { |
| TCERR1(count); |
| retCode = TC_FAIL; |
| return; |
| } |
| count++; |
| } |
| |
| TC_END_RESULT(retCode); |
| PRINT_LINE; |
| |
| /* |
| * Entries in the FIFO queue have to be unique. |
| * Put data. |
| */ |
| TC_PRINT("Test Fiber FIFO Put\n"); |
| TC_PRINT("\nFIBER FIFO Put Order: "); |
| for (int i = 0; i < NUM_FIFO_ELEMENT; i++) { |
| nano_fiber_fifo_put(&nanoFifoObj, pPutList2[i]); |
| TC_PRINT(" %p,", pPutList2[i]); |
| } |
| TC_PRINT("\n"); |
| PRINT_LINE; |
| |
| /* Give semaphore to allow the main task to run */ |
| nano_fiber_sem_give(&nanoSemObjTask); |
| |
| } /* fiber1 */ |
| |
| |
| /** |
| * |
| * @brief Test the nano_fiber_fifo_get(TICKS_UNLIMITED) interface |
| * |
| * This function tests the fifo put and get wait interfaces in a fiber. |
| * It gets data from nanoFifoObj2 queue and puts data to nanoFifoObj queue. |
| * |
| * @return N/A |
| */ |
| |
| void testFiberFifoGetW(void) |
| { |
| void *pGetData; /* pointer to FIFO object get from the queue */ |
| void *pPutData; /* pointer to FIFO object to put to the queue */ |
| |
| TC_PRINT("Test Fiber FIFO Get Wait Interfaces\n\n"); |
| pGetData = nano_fiber_fifo_get(&nanoFifoObj2, TICKS_UNLIMITED); |
| TC_PRINT("FIBER FIFO Get from queue2: %p\n", pGetData); |
| /* Verify results */ |
| if (pGetData != pMyFifoData1) { |
| retCode = TC_FAIL; |
| TCERR2; |
| return; |
| } |
| |
| pPutData = pMyFifoData2; |
| TC_PRINT("FIBER FIFO Put to queue1: %p\n", pPutData); |
| nano_fiber_fifo_put(&nanoFifoObj, pPutData); |
| |
| pGetData = nano_fiber_fifo_get(&nanoFifoObj2, TICKS_UNLIMITED); |
| TC_PRINT("FIBER FIFO Get from queue2: %p\n", pGetData); |
| /* Verify results */ |
| if (pGetData != pMyFifoData3) { |
| retCode = TC_FAIL; |
| TCERR2; |
| return; |
| } |
| |
| pPutData = pMyFifoData4; |
| TC_PRINT("FIBER FIFO Put to queue1: %p\n", pPutData); |
| nano_fiber_fifo_put(&nanoFifoObj, pPutData); |
| |
| TC_END_RESULT(retCode); |
| |
| } /* testFiberFifoGetW */ |
| |
| |
| /** |
| * |
| * @brief Test ISR FIFO routines (triggered from fiber) |
| * |
| * This function tests the fifo put and get interfaces in the ISR context. |
| * It is invoked from a fiber. |
| * |
| * We use nanoFifoObj queue to put and get data. |
| * |
| * @return N/A |
| */ |
| |
| void testIsrFifoFromFiber(void) |
| { |
| void *pGetData; /* pointer to FIFO object get from the queue */ |
| |
| TC_PRINT("Test ISR FIFO (invoked from Fiber)\n\n"); |
| |
| /* This is data pushed by function testFiberFifoGetW */ |
| _trigger_nano_isr_fifo_get(); |
| pGetData = isrFifoInfo.data; |
| |
| TC_PRINT("ISR FIFO Get from queue1: %p\n", pGetData); |
| if (isrFifoInfo.data != pMyFifoData4) { |
| retCode = TC_FAIL; |
| TCERR2; |
| return; |
| } |
| |
| /* Verify that the queue is empty */ |
| _trigger_nano_isr_fifo_get(); |
| pGetData = isrFifoInfo.data; |
| |
| if (pGetData != NULL) { |
| TC_PRINT("Get from queue1: %p\n", pGetData); |
| retCode = TC_FAIL; |
| TCERR3; |
| return; |
| } |
| |
| /* Put more item into queue */ |
| TC_PRINT("\nISR FIFO (running in fiber) Put Order:\n"); |
| for (int i = 0; i < NUM_FIFO_ELEMENT; i++) { |
| isrFifoInfo.data = pPutList1[i]; |
| TC_PRINT(" %p,", pPutList1[i]); |
| _trigger_nano_isr_fifo_put(); |
| } |
| TC_PRINT("\n"); |
| |
| TC_END_RESULT(retCode); |
| |
| } /* testIsrFifoFromFiber */ |
| |
| |
| /** |
| * |
| * @brief Test ISR FIFO routines (triggered from task) |
| * |
| * This function tests the fifo put and get interfaces in the ISR context. |
| * It is invoked from a task. |
| * |
| * We use nanoFifoObj queue to put and get data. |
| * |
| * @return N/A |
| */ |
| |
| void testIsrFifoFromTask(void) |
| { |
| void *pGetData; /* pointer to FIFO object get from the queue */ |
| void *pPutData; /* pointer to FIFO object put to queue */ |
| int count = 0; /* counter */ |
| |
| TC_PRINT("Test ISR FIFO (invoked from Task)\n\n"); |
| |
| /* This is data pushed by function testIsrFifoFromFiber |
| * Get all FIFOs |
| */ |
| _trigger_nano_isr_fifo_get(); |
| pGetData = isrFifoInfo.data; |
| |
| while (pGetData != NULL) { |
| TC_PRINT("Get from queue1: count = %d, ptr is %p\n", count, pGetData); |
| if ((count >= NUM_FIFO_ELEMENT) || (pGetData != pPutList1[count])) { |
| TCERR1(count); |
| retCode = TC_FAIL; |
| return; |
| } |
| |
| /* Get the next element */ |
| _trigger_nano_isr_fifo_get(); |
| pGetData = isrFifoInfo.data; |
| count++; |
| } /* while */ |
| |
| |
| /* Put data into queue and get it again */ |
| pPutData = pPutList2[3]; |
| |
| isrFifoInfo.data = pPutData; |
| _trigger_nano_isr_fifo_put(); |
| isrFifoInfo.data = NULL; /* force data to a new value */ |
| /* Get data from queue */ |
| _trigger_nano_isr_fifo_get(); |
| pGetData = isrFifoInfo.data; |
| /* Verify data */ |
| if (pGetData != pPutData) { |
| retCode = TC_FAIL; |
| TCERR2; |
| return; |
| } |
| TC_PRINT("\nTest ISR FIFO (invoked from Task) - put %p and get back %p\n", |
| pPutData, pGetData); |
| |
| TC_END_RESULT(retCode); |
| } /* testIsrFifoFromTask */ |
| |
| /** |
| * |
| * @brief Entry point for the second fiber |
| * |
| * @return N/A |
| */ |
| |
| void fiber2(void) |
| { |
| void *pData; /* pointer to FIFO object from the queue */ |
| |
| /* Wait for fiber2 to be activated */ |
| |
| nano_fiber_sem_take(&nanoSemObj2, TICKS_UNLIMITED); |
| |
| /* Wait for data to be added to <nanoFifoObj> */ |
| pData = nano_fiber_fifo_get(&nanoFifoObj, TICKS_UNLIMITED); |
| if (pData != pPutList1[1]) { |
| TC_ERROR("fiber2 (1) - expected 0x%x, got 0x%x\n", |
| pPutList1[1], pData); |
| retCode = TC_FAIL; |
| return; |
| } |
| |
| /* Wait for data to be added to <nanoFifoObj2> by fiber3 */ |
| pData = nano_fiber_fifo_get(&nanoFifoObj2, TICKS_UNLIMITED); |
| if (pData != pPutList2[1]) { |
| TC_ERROR("fiber2 (2) - expected 0x%x, got 0x%x\n", |
| pPutList2[1], pData); |
| retCode = TC_FAIL; |
| return; |
| } |
| |
| /* Wait for fiber2 to be reactivated */ |
| nano_fiber_sem_take(&nanoSemObj2, TICKS_UNLIMITED); |
| |
| /* Fiber #2 has been reactivated by main task */ |
| for (int i = 0; i < 4; i++) { |
| pData = nano_fiber_fifo_get(&nanoFifoObj, TICKS_UNLIMITED); |
| if (pData != pPutList1[i]) { |
| TC_ERROR("fiber2 (3) - iteration %d expected 0x%x, got 0x%x\n", |
| i, pPutList1[i], pData); |
| retCode = TC_FAIL; |
| return; |
| } |
| } |
| |
| nano_fiber_sem_give(&nanoSemObjTask); /* Wake main task */ |
| /* Wait for fiber2 to be reactivated */ |
| nano_fiber_sem_take(&nanoSemObj2, TICKS_UNLIMITED); |
| |
| testFiberFifoGetW(); |
| PRINT_LINE; |
| testIsrFifoFromFiber(); |
| |
| TC_END_RESULT(retCode); |
| } /* fiber2 */ |
| |
| /** |
| * |
| * @brief Entry point for the third fiber |
| * |
| * @return N/A |
| */ |
| |
| void fiber3(void) |
| { |
| void *pData; |
| |
| /* Wait for fiber3 to be activated */ |
| nano_fiber_sem_take(&nanoSemObj3, TICKS_UNLIMITED); |
| |
| /* Put two items onto <nanoFifoObj2> to unblock fibers #1 and #2. */ |
| nano_fiber_fifo_put(&nanoFifoObj2, pPutList2[0]); /* Wake fiber1 */ |
| nano_fiber_fifo_put(&nanoFifoObj2, pPutList2[1]); /* Wake fiber2 */ |
| |
| /* Wait for fiber3 to be re-activated */ |
| nano_fiber_sem_take(&nanoSemObj3, TICKS_UNLIMITED); |
| |
| /* Immediately get the data from <nanoFifoObj2>. */ |
| pData = nano_fiber_fifo_get(&nanoFifoObj2, TICKS_UNLIMITED); |
| if (pData != pPutList2[0]) { |
| retCode = TC_FAIL; |
| TC_ERROR("fiber3 (1) - got 0x%x from <nanoFifoObj2>, expected 0x%x\n", |
| pData, pPutList2[0]); |
| } |
| |
| /* Put three items onto the FIFO for the task to get */ |
| nano_fiber_fifo_put(&nanoFifoObj2, pPutList2[0]); |
| nano_fiber_fifo_put(&nanoFifoObj2, pPutList2[1]); |
| nano_fiber_fifo_put(&nanoFifoObj2, pPutList2[2]); |
| |
| /* Sleep for 2 seconds */ |
| nano_fiber_timer_start(&timer, SECONDS(2)); |
| nano_fiber_timer_test(&timer, TICKS_UNLIMITED); |
| |
| /* Put final item onto the FIFO for the task to get */ |
| nano_fiber_fifo_put(&nanoFifoObj2, pPutList2[3]); |
| |
| /* Wait for fiber3 to be re-activated (not expected to occur) */ |
| nano_fiber_sem_take(&nanoSemObj3, TICKS_UNLIMITED); |
| } |
| |
| |
| /** |
| * |
| * @brief Test the nano_task_fifo_get(TICKS_UNLIMITED) interface |
| * |
| * This is in a task. It puts data to nanoFifoObj2 queue and gets |
| * data from nanoFifoObj queue. |
| * |
| * @return N/A |
| */ |
| |
| void testTaskFifoGetW(void) |
| { |
| void *pGetData; /* pointer to FIFO object get from the queue */ |
| void *pPutData; /* pointer to FIFO object to put to the queue */ |
| |
| PRINT_LINE; |
| TC_PRINT("Test Task FIFO Get Wait Interfaces\n\n"); |
| pPutData = pMyFifoData1; |
| TC_PRINT("TASK FIFO Put to queue2: %p\n", pPutData); |
| nano_task_fifo_put(&nanoFifoObj2, pPutData); |
| |
| /* Activate fiber2 */ |
| nano_task_sem_give(&nanoSemObj2); |
| |
| pGetData = nano_task_fifo_get(&nanoFifoObj, TICKS_UNLIMITED); |
| TC_PRINT("TASK FIFO Get from queue1: %p\n", pGetData); |
| /* Verify results */ |
| if (pGetData != pMyFifoData2) { |
| retCode = TC_FAIL; |
| TCERR2; |
| return; |
| } |
| |
| pPutData = pMyFifoData3; |
| TC_PRINT("TASK FIFO Put to queue2: %p\n", pPutData); |
| nano_task_fifo_put(&nanoFifoObj2, pPutData); |
| |
| TC_END_RESULT(retCode); |
| } /* testTaskFifoGetW */ |
| |
| /** |
| * |
| * @brief Initialize nanokernel objects |
| * |
| * This routine initializes the nanokernel objects used in the FIFO tests. |
| * |
| * @return N/A |
| */ |
| |
| void initNanoObjects(void) |
| { |
| nano_fifo_init(&nanoFifoObj); |
| nano_fifo_init(&nanoFifoObj2); |
| |
| nano_sem_init(&nanoSemObj1); |
| nano_sem_init(&nanoSemObj2); |
| nano_sem_init(&nanoSemObj3); |
| nano_sem_init(&nanoSemObjTask); |
| |
| nano_timer_init(&timer, timerData); |
| |
| } /* initNanoObjects */ |
| |
| /** |
| * |
| * @brief Entry point to FIFO tests |
| * |
| * This is the entry point to the FIFO tests. |
| * |
| * @return N/A |
| */ |
| |
| void main(void) |
| { |
| void *pData; /* pointer to FIFO object get from the queue */ |
| int count = 0; /* counter */ |
| |
| TC_START("Test Nanokernel FIFO"); |
| |
| /* Initialize the FIFO queues and semaphore */ |
| initNanoObjects(); |
| |
| /* Create and start the three (3) fibers. */ |
| |
| task_fiber_start(&fiberStack1[0], FIBER_STACKSIZE, (nano_fiber_entry_t) fiber1, |
| 0, 0, 7, 0); |
| |
| task_fiber_start(&fiberStack2[0], FIBER_STACKSIZE, (nano_fiber_entry_t) fiber2, |
| 0, 0, 7, 0); |
| |
| task_fiber_start(&fiberStack3[0], FIBER_STACKSIZE, (nano_fiber_entry_t) fiber3, |
| 0, 0, 7, 0); |
| |
| /* |
| * The three fibers have each blocked on a different semaphore. Giving |
| * the semaphore nanoSemObjX will unblock fiberX (where X = {1, 2, 3}). |
| * |
| * Activate fibers #1 and #2. They will each block on nanoFifoObj. |
| */ |
| |
| nano_task_sem_give(&nanoSemObj1); |
| nano_task_sem_give(&nanoSemObj2); |
| |
| /* Put two items into <nanoFifoObj> to unblock fibers #1 and #2. */ |
| nano_task_fifo_put(&nanoFifoObj, pPutList1[0]); /* Wake fiber1 */ |
| nano_task_fifo_put(&nanoFifoObj, pPutList1[1]); /* Wake fiber2 */ |
| |
| /* Activate fiber #3 */ |
| nano_task_sem_give(&nanoSemObj3); |
| |
| /* |
| * All three fibers should be blocked on their semaphores. Put data into |
| * <nanoFifoObj2>. Fiber #3 will read it after it is reactivated. |
| */ |
| |
| nano_task_fifo_put(&nanoFifoObj2, pPutList2[0]); |
| nano_task_sem_give(&nanoSemObj3); /* Reactivate fiber #3 */ |
| |
| for (int i = 0; i < 4; i++) { |
| pData = nano_task_fifo_get(&nanoFifoObj2, TICKS_UNLIMITED); |
| if (pData != pPutList2[i]) { |
| TC_ERROR("nano_task_fifo_get() expected 0x%x, got 0x%x\n", |
| pPutList2[i], pData); |
| goto exit; |
| } |
| } |
| |
| /* Add items to <nanoFifoObj> for fiber #2 */ |
| for (int i = 0; i < 4; i++) { |
| nano_task_fifo_put(&nanoFifoObj, pPutList1[i]); |
| } |
| |
| nano_task_sem_give(&nanoSemObj2); /* Activate fiber #2 */ |
| |
| /* Wait for fibers to finish */ |
| nano_task_sem_take(&nanoSemObjTask, TICKS_UNLIMITED); |
| |
| if (retCode == TC_FAIL) { |
| goto exit; |
| } |
| |
| /* |
| * Entries in the FIFO queue have to be unique. |
| * Put data to queue. |
| */ |
| |
| TC_PRINT("Test Task FIFO Put\n"); |
| TC_PRINT("\nTASK FIFO Put Order: "); |
| for (int i = 0; i < NUM_FIFO_ELEMENT; i++) { |
| nano_task_fifo_put(&nanoFifoObj, pPutList1[i]); |
| TC_PRINT(" %p,", pPutList1[i]); |
| } |
| TC_PRINT("\n"); |
| |
| PRINT_LINE; |
| |
| nano_task_sem_give(&nanoSemObj1); /* Activate fiber1 */ |
| |
| if (retCode == TC_FAIL) { |
| goto exit; |
| } |
| |
| /* |
| * Wait for fiber1 to complete execution. (Using a semaphore gives |
| * the fiber the freedom to do blocking-type operations if it wants to.) |
| */ |
| nano_task_sem_take(&nanoSemObjTask, TICKS_UNLIMITED); |
| |
| TC_PRINT("Test Task FIFO Get\n"); |
| |
| /* Get all FIFOs */ |
| while ((pData = nano_task_fifo_get(&nanoFifoObj, TICKS_NONE)) != NULL) { |
| TC_PRINT("TASK FIFO Get: count = %d, ptr is %p\n", count, pData); |
| if ((count >= NUM_FIFO_ELEMENT) || (pData != pPutList2[count])) { |
| TCERR1(count); |
| retCode = TC_FAIL; |
| goto exit; |
| } |
| count++; |
| } |
| |
| /* Test FIFO Get Wait interfaces*/ |
| testTaskFifoGetW(); |
| PRINT_LINE; |
| |
| testIsrFifoFromTask(); |
| PRINT_LINE; |
| |
| /* test timeouts */ |
| if (test_fifo_timeout() != TC_PASS) { |
| retCode = TC_FAIL; |
| goto exit; |
| } |
| PRINT_LINE; |
| |
| exit: |
| TC_END_RESULT(retCode); |
| TC_END_REPORT(retCode); |
| } |