tests/kernel/test_fifo/microkernel/src/fifo.c - third_party/github/zephyrproject-rtos/zephyr - Git at Google

 /*
  * 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 microkernel FIFO APIs
  *
  * This module tests the following FIFO routines:
  *
  *   task_fifo_put
  *   task_fifo_get
  *   task_fifo_size_get
  *   task_fifo_purge
  *
  * Scenarios tested include:
  * - Check number of elements in queue when queue is empty, full or
  *   while it is being dequeued
  * - Verify the data being dequeued are in correct order
  * - Verify the return codes are correct for the APIs
  */

 #include <tc_util.h>
 #include <stdbool.h>
 #include <zephyr.h>

 #define MULTIPLIER              100     /* Used to initialize myData */
 #define NUM_OF_ELEMENT          5       /* Number of elements in myData array */
 #define DEPTH_OF_FIFO_QUEUE     2       /* FIFO queue depth--see prj.mdef */

 #define SPECIAL_DATA            999     /* Special number to put in queue */

 static int myData[NUM_OF_ELEMENT];
 static int tcRC = TC_PASS;              /* test case return code */

 #ifdef TEST_PRIV_FIFO
 	DEFINE_FIFO(FIFOQ, 2, 4);
 #endif

 /**
  *
  * @brief Initialize data array
  *
  * This routine initializes the myData array used in the FIFO tests.
  *
  * @return N/A
  */

 void initMyData(void)
 {
 	for (int i = 0; i < NUM_OF_ELEMENT; i++) {
 		myData[i] = i * MULTIPLIER + 1;
 	}  /* for */
 }  /* initMyData */

 /**
  *
  * @brief Print data array
  *
  * This routine prints myData array.
  *
  * @return N/A
  */

 void printMyData(void)
 {
 	for (int i = 0; i < NUM_OF_ELEMENT; i++) {
 		PRINT_DATA("myData[%d] = %d,\n", i, myData[i]);
 	}  /* for */

 } /* printMyData */

 /**
  *
  * @brief Verify return value
  *
  * This routine verifies current value against expected value
  * and returns true if they are the same.
  *
  * @param expectRetValue     expect value
  * @param currentRetValue    current value
  *
  * @return  true, false
  */

 bool verifyRetValue(int expectRetValue, int currentRetValue)
 {
 	return (expectRetValue == currentRetValue);
 } /* verifyRetValue */

 /**
  *
  * @brief Initialize microkernel objects
  *
  * This routine initializes the microkernel objects used in the FIFO tests.
  *
  * @return N/A
  */

 void initMicroObjects(void)
 {
 	initMyData();
 	printMyData();
 } /* initMicroObjects */

 /**
  *
  * @brief Fills up the FIFO queue
  *
  * This routine fills the FIFO queue with myData array.  This assumes the
  * queue is empty before we put in elements.
  *
  * @param queue          FIFO queue
  * @param numElements    Number of elements used to inserted into the queue
  *
  * @return TC_PASS, TC_FAIL
  *
  * Also updates tcRC when result is TC_FAIL.
  */

 int fillFIFO(kfifo_t queue, int numElements)
 {
 	int result = TC_PASS;       /* TC_PASS or TC_FAIL for this function */
 	int retValue;               /* return value from task_fifo_xxx APIs */

 	for (int i = 0; i < numElements; i++) {
 		retValue = task_fifo_put(queue, &myData[i], TICKS_NONE);
 		switch (retValue) {
 		case RC_OK:
 			/* TC_PRINT("i=%d, successfully put in data=%d\n", i, myData[i]);  */
 			if (i >= DEPTH_OF_FIFO_QUEUE) {
 				TC_ERROR("Incorrect return value of RC_OK when i = %d\n", i);
 				result = TC_FAIL;
 				goto exitTest3;
 			}
 			break;
 		case RC_FAIL:
 			/* TC_PRINT("i=%d, FIFOQ is full. Cannot put data=%d\n", i, myData[i]); */
 			if (i < DEPTH_OF_FIFO_QUEUE) {
 				TC_ERROR("Incorrect return value of RC_FAIL when i = %d\n", i);
 				result = TC_FAIL;
 				goto exitTest3;
 			}
 			break;
 		default:
 			TC_ERROR("Incorrect return value of %d when i = %d\n", retValue, i);
 			result = TC_FAIL;
 			goto exitTest3;
 		} /* switch */

 	} /* for */

 exitTest3:
 	if (result == TC_FAIL) {
 		tcRC = TC_FAIL;
 	}

 	TC_END_RESULT(result);
 	return result;

 } /* fillFIFO */

 /**
  *
  * @brief Task to test FIFO queue
  *
  * This routine is run in three context switches:
  * - it puts an element to the FIFO queue
  * - it purges the FIFO queue
  * - it dequeues an element from the FIFO queue
  *
  * @return  N/A
  */
 void MicroTestFifoTask(void)
 {
 	int retValue;                 /* return value of task_fifo_xxx interface */
 	int locData = SPECIAL_DATA;   /* variable to pass data to and from queue */

 	/* (1) Wait for semaphore: put element test */
 	task_sem_take(SEMSIG_MicroTestFifoTask, TICKS_UNLIMITED);

 	TC_PRINT("Starts %s\n", __func__);
 	/* Put one element */
 	TC_PRINT("%s: Puts element %d\n", __func__, locData);
 	retValue = task_fifo_put(FIFOQ, &locData, TICKS_NONE);
 	/*
 	 * Execution is switched back to RegressionTask (a higher priority task)
 	 * which is not block anymore.
 	 */
 	if (verifyRetValue(RC_OK, retValue)) {
 		TC_PRINT("%s: FIFOPut OK for %d\n", __func__, locData);
 	} else {
 		TC_ERROR("FIFOPut failed, retValue %d\n", retValue);
 		tcRC = TC_FAIL;
 		goto exitTest4;
 	}

 	/*
 	 * (2) Wait for semaphore: purge queue test.  Purge queue while another
 	 * task is in task_fifo_put(TICKS_UNLIMITED).  This is to test return
 	 * value of the task_fifo_put(TICKS_UNLIMITED) interface.
 	 */
 	task_sem_take(SEMSIG_MicroTestFifoTask, TICKS_UNLIMITED);
 	/*
 	 * RegressionTask is waiting to put data into FIFO queue, which is
 	 * full.  We purge the queue here and the task_fifo_put(TICKS_UNLIMITED)
 	 * interface will terminate the wait and return RC_FAIL.
 	 */
 	TC_PRINT("%s: About to purge queue\n", __func__);
 	retValue = task_fifo_purge(FIFOQ);

 	/*
 	 * Execution is switched back to RegressionTask (a higher priority task)
 	 * which is not block anymore.
 	 */
 	if (verifyRetValue(RC_OK, retValue)) {
 		TC_PRINT("%s: Successfully purged queue\n", __func__);
 	} else {
 		TC_ERROR("Problem purging queue, %d\n", retValue);
 		tcRC = TC_FAIL;
 		goto exitTest4;
 	}

 	/* (3) Wait for semaphore: get element test */
 	task_sem_take(SEMSIG_MicroTestFifoTask, TICKS_UNLIMITED);
 	TC_PRINT("%s: About to dequeue 1 element\n", __func__);
 	retValue =  task_fifo_get(FIFOQ, &locData, TICKS_NONE);
 	/*
 	 * Execution is switched back to RegressionTask (a higher priority task)
 	 * which is not block anymore
 	 */
 	if ((retValue != RC_OK) || (locData != myData[0])) {
 		TC_ERROR("task_fifo_get failed,\n  retValue %d OR got data %d while expect %d\n"
 			, retValue, locData, myData[0]);
 		tcRC = TC_FAIL;
 		goto exitTest4;
 	} else {
 		TC_PRINT("%s: task_fifo_get got back correct data %d\n", __func__, locData);
 	}

 exitTest4:
 	TC_END_RESULT(tcRC);

 	/* Allow RegressionTask to print final result of the test */
 	task_sem_give(SEM_TestDone);
 }

 /**
  *
  * @brief Verifies data in queue is correct
  *
  * This routine assumes that the queue is full when this function is called.
  * It counts the number of elements in the queue, dequeues elements and verifies
  * that they are in the right order. Expect the dequeue order as: myData[0],
  * myData[1].
  *
  * @param loopCnt    number of elements passed to the for loop
  *
  * @return  TC_PASS, TC_FAIL
  *
  * Also updates tcRC when result is TC_FAIL.
  */
 int verifyQueueData(int loopCnt)
 {
 	int result = TC_PASS;       /* TC_PASS or TC_FAIL for this function */
 	int retValue;               /* task_fifo_xxx interface return value */
 	int locData;                /* local variable used for passing data */

 	/*
 	 * Counts elements using task_fifo_size_get interface.  Dequeues elements from
 	 * FIFOQ.  Test for proper return code when FIFO queue is empty using
 	 * task_fifo_get interface.
 	 */
 	for (int i = 0; i < loopCnt; i++) {
 		/* Counts number of elements */
 		retValue = task_fifo_size_get(FIFOQ);
 		if (!verifyRetValue(DEPTH_OF_FIFO_QUEUE-i, retValue)) {
 			TC_ERROR("i=%d, incorrect number of FIFO elements in queue: %d, expect %d\n"
 				, i, retValue, DEPTH_OF_FIFO_QUEUE-i);
 			result = TC_FAIL;
 			goto exitTest2;
 		} else {
 			/* TC_PRINT("%s: i=%d, %d elements in queue\n", __func__, i, retValue); */
 		}

 		/* Dequeues element */
 		retValue = task_fifo_get(FIFOQ, &locData, TICKS_NONE);

 		switch (retValue) {
 		case RC_OK:
 			if ((i >= DEPTH_OF_FIFO_QUEUE) || (locData != myData[i])) {
 				TC_ERROR("RC_OK but got wrong data %d for i=%d\n", locData, i);
 				result = TC_FAIL;
 				goto exitTest2;
 			}

 			TC_PRINT("%s: i=%d, successfully get data %d\n", __func__, i, locData);
 			break;
 		case RC_FAIL:
 			if (i < DEPTH_OF_FIFO_QUEUE) {
 				TC_ERROR("RC_FAIL but i is only %d\n", i);
 				result = TC_FAIL;
 				goto exitTest2;
 			}
 			TC_PRINT("%s: i=%d, FIFOQ is empty. No data.\n", __func__, i);
 			break;
 		default:
 			TC_ERROR("i=%d, incorrect return value %d\n", i, retValue);
 			result = TC_FAIL;
 			goto exitTest2;
 		}  /* switch */
 	} /* for */

 exitTest2:

 	if (result == TC_FAIL) {
 		tcRC = TC_FAIL;
 	}

 	TC_END_RESULT(result);
 	return result;

 } /* verifyQueueData */


 /**
  *
  * @brief Main task to test FIFO queue
  *
  * This routine initializes data, fills the FIFO queue and verifies the
  * data in the queue is in correct order when items are being dequeued.
  * It also tests the wait (with and without timeouts) to put data into
  * queue when the queue is full.  The queue is purged at some point
  * and checked to see if the number of elements is correct.
  * The get wait interfaces (with and without timeouts) are also tested
  * and data verified.
  *
  * @return  N/A
  */

 void RegressionTask(void)
 {
 	int retValue;               /* task_fifo_xxx interface return value */
 	int locData;                /* local variable used for passing data */
 	int result;                 /* result from utility functions */

 	TC_START("Test Microkernel FIFO");

 	initMicroObjects();

 	/*
 	 * Checks number of elements in queue, expect 0. Test task_fifo_size_get
 	 * interface.
 	 */
 	retValue = task_fifo_size_get(FIFOQ);
 	if (!verifyRetValue(0, retValue)) {
 		TC_ERROR("Incorrect number of FIFO elements in queue: %d\n", retValue);
 		tcRC = TC_FAIL;
 		goto exitTest;
 	}

 	/*
 	 * FIFOQ is only two elements deep.  Test for proper return code when
 	 * FIFO queue is full.  Test task_fifo_put(TICKS_NONE) interface.
 	 */
 	result = fillFIFO(FIFOQ, NUM_OF_ELEMENT);
 	if (result == TC_FAIL) { /* terminate test */
 		TC_ERROR("Failed fillFIFO.\n");
 		goto exitTest;
 	}

 	/*
 	 * Checks number of elements in FIFO queue, should be full.  Also verifies
 	 * data is in correct order.  Test task_fifo_size_get  and task_fifo_get interface.
 	 */
 	result = verifyQueueData(DEPTH_OF_FIFO_QUEUE + 1);
 	if (result == TC_FAIL) { /* terminate test */
 		TC_ERROR("Failed verifyQueueData.\n");
 		goto exitTest;
 	}

 /*----------------------------------------------------------------------------*/

 	/* Fill FIFO queue */
 	result = fillFIFO(FIFOQ, NUM_OF_ELEMENT);
 	if (result == TC_FAIL) { /* terminate test */
 		TC_ERROR("Failed fillFIFO.\n");
 		goto exitTest;
 	}

 	/*
 	 * Put myData[4] into queue with wait, test task_fifo_put(timeout)
 	 * interface. Queue is full, so this data did not make it into queue.
 	 * Expect return code of RC_TIME.
 	 */
 	TC_PRINT("%s: About to putWT with data %d\n", __func__, myData[4]);
 	retValue = task_fifo_put(FIFOQ, &myData[4], 2);  /* wait for 2 ticks */
 	if (verifyRetValue(RC_TIME, retValue)) {
 		TC_PRINT("%s: FIFO Put time out as expected for data %d\n"
 			, __func__, myData[4]);
 	} else {
 		TC_ERROR("Failed task_fifo_put for data %d, retValue %d\n",
 				 myData[4], retValue);
 		tcRC = TC_FAIL;
 		goto exitTest;
 	}

 	/* Queue is full at this stage.  Verify data is correct. */
 	result = verifyQueueData(DEPTH_OF_FIFO_QUEUE);
 	if (result == TC_FAIL) { /* terminate test */
 		TC_ERROR("Failed verifyQueueData.\n");
 		goto exitTest;
 	}

 /*----------------------------------------------------------------------------*/

 	/* Fill FIFO queue.  Check number of elements in queue, should be 2. */
 	result = fillFIFO(FIFOQ, NUM_OF_ELEMENT);
 	if (result == TC_FAIL) { /* terminate test */
 		TC_ERROR("Failed fillFIFO.\n");
 		goto exitTest;
 	}

 	retValue = task_fifo_size_get(FIFOQ);
 	if (verifyRetValue(DEPTH_OF_FIFO_QUEUE, retValue)) {
 		TC_PRINT("%s: %d element in queue\n", __func__, retValue);
 	} else {
 		TC_ERROR("Incorrect number of FIFO elements in queue: %d\n", retValue);
 		tcRC = TC_FAIL;
 		goto exitTest;
 	}

 	/*
 	 * Purge queue, check number of elements in queue.  Test task_fifo_purge
 	 * interface.
 	 */
 	retValue = task_fifo_purge(FIFOQ);
 	if (verifyRetValue(RC_OK, retValue)) {
 		TC_PRINT("%s: Successfully purged queue\n", __func__);
 	} else {
 		TC_ERROR("Problem purging queue, %d\n", retValue);
 		tcRC = TC_FAIL;
 		goto exitTest;
 	}

 	/* Count number of elements in queue */
 	retValue = task_fifo_size_get(FIFOQ);
 	if (verifyRetValue(0, retValue)) {
 		TC_PRINT("%s: confirm %d element in queue\n", __func__, retValue);
 	} else {
 		TC_ERROR("Incorrect number of FIFO elements in queue: %d\n", retValue);
 		tcRC = TC_FAIL;
 		goto exitTest;
 	}

 	PRINT_LINE;
 /*----------------------------------------------------------------------------*/

 	/*
 	 * Semaphore to allow MicroTestFifoTask to run, but MicroTestFifoTask is lower
 	 * priority, so it won't run until this current task is blocked
 	 * in task_fifo_get interface later.
 	 */
 	task_sem_give(SEMSIG_MicroTestFifoTask);

 	/*
 	 * Test task_fifo_get interface.
 	 * Expect MicroTestFifoTask to run and insert SPECIAL_DATA into queue.
 	 */
 	TC_PRINT("%s: About to GetW data\n", __func__);
 	retValue = task_fifo_get(FIFOQ, &locData, TICKS_UNLIMITED);
 	if ((retValue != RC_OK) || (locData != SPECIAL_DATA)) {
 		TC_ERROR("Failed task_fifo_get interface for data %d, retValue %d\n"
 			, locData, retValue);
 		tcRC = TC_FAIL;
 		goto exitTest;
 	} else {
 		TC_PRINT("%s: GetW get back %d\n", __func__, locData);
 	}

 	/* MicroTestFifoTask may have modified tcRC */
 	if (tcRC == TC_FAIL) {    /* terminate test */
 		TC_ERROR("tcRC failed.");
 		goto exitTest;
 	}

 	/*
 	 * Test task_fifo_get(timeout) interface.  Try to get more data, but
 	 * there is none before it times out.
 	 */
 	retValue = task_fifo_get(FIFOQ, &locData, 2);
 	if (verifyRetValue(RC_TIME, retValue)) {
 		TC_PRINT("%s: GetWT timeout expected\n", __func__);
 	} else {
 		TC_ERROR("Failed task_fifo_get interface for retValue %d\n", retValue);
 		tcRC = TC_FAIL;
 		goto exitTest;
 	}

 /*----------------------------------------------------------------------------*/

 	/* Fill FIFO queue */
 	result = fillFIFO(FIFOQ, NUM_OF_ELEMENT);
 	if (result == TC_FAIL) { /* terminate test */
 		TC_ERROR("Failed fillFIFO.\n");
 		goto exitTest;
 	}

 	/* Semaphore to allow MicroTestFifoTask to run */
 	task_sem_give(SEMSIG_MicroTestFifoTask);

 	/* MicroTestFifoTask may have modified tcRC */
 	if (tcRC == TC_FAIL) {    /* terminate test */
 		TC_ERROR("tcRC failed.");
 		goto exitTest;
 	}

 	/* Queue is full */
 	locData = SPECIAL_DATA;
 	TC_PRINT("%s: about to putW data %d\n", __func__, locData);
 	retValue = task_fifo_put(FIFOQ,  &locData, TICKS_UNLIMITED);

 	/*
 	 * Execution is switched to MicroTestFifoTask, which will purge the queue.
 	 * When the queue is purged while other tasks are waiting to put data into
 	 * queue, the return value will be RC_FAIL.
 	 */
 	if (verifyRetValue(RC_FAIL, retValue)) {
 		TC_PRINT("%s: PutW ok when queue is purged while waiting\n", __func__);
 	} else {
 		TC_ERROR("Failed task_fifo_put interface when queue is purged, retValue %d\n"
 			, retValue);
 		tcRC = TC_FAIL;
 		goto exitTest;
 	}

 /*----------------------------------------------------------------------------*/

 	/* Fill FIFO queue */
 	result = fillFIFO(FIFOQ, NUM_OF_ELEMENT);
 	if (result == TC_FAIL) { /* terminate test */
 		TC_ERROR("Failed fillFIFO.\n");
 		goto exitTest;
 	}

 	/* Semaphore to allow MicroTestFifoTask to run */
 	task_sem_give(SEMSIG_MicroTestFifoTask);

 	/* MicroTestFifoTask may have modified tcRC */
 	if (tcRC == TC_FAIL) {    /* terminate test */
 		TC_ERROR("tcRC failed.");
 		goto exitTest;
 	}

 	/* Queue is full */
 	TC_PRINT("%s: about to putW data %d\n", __func__, myData[4]);
 	retValue = task_fifo_put(FIFOQ,  &myData[4], TICKS_UNLIMITED);
 	/* Execution is switched to MicroTestFifoTask, which will dequeue one element */
 	if (verifyRetValue(RC_OK, retValue)) {
 		TC_PRINT("%s: PutW success for data %d\n", __func__, myData[4]);
 	} else {
 		TC_ERROR("Failed task_fifo_put interface for data %d, retValue %d\n"
 			, myData[4], retValue);
 		tcRC = TC_FAIL;
 		goto exitTest;
 	}

 	PRINT_LINE;
 /*----------------------------------------------------------------------------*/

 	/*
 	 * Dequeue all data to check.  Expect data in the queue to be:
 	 * myData[1], myData[4].  myData[0] was dequeued by MicroTestFifoTask.
 	 */

 	/* Get first data */
 	retValue = task_fifo_get(FIFOQ, &locData, TICKS_NONE);
 	if ((retValue != RC_OK) || (locData != myData[1])) {
 		TC_ERROR("Get back data %d, retValue %d\n", locData, retValue);
 		tcRC = TC_FAIL;
 		goto exitTest;
 	} else {
 		TC_PRINT("%s: Get back data %d\n", __func__, locData);
 	}

 	/* Get second data */
 	retValue = task_fifo_get(FIFOQ, &locData, TICKS_NONE);
 	if ((retValue != RC_OK) || (locData != myData[4])) {
 		TC_ERROR("Get back data %d, retValue %d\n", locData, retValue);
 		tcRC = TC_FAIL;
 		goto exitTest;
 	} else {
 		TC_PRINT("%s: Get back data %d\n", __func__, locData);
 	}

 	/* Queue should be empty */
 	retValue = task_fifo_get(FIFOQ, &locData, TICKS_NONE);
 	if (retValue != RC_FAIL) {
 		TC_ERROR("%s: incorrect retValue %d\n", __func__, retValue);
 		tcRC = TC_FAIL;
 		goto exitTest;
 	} else {
 		TC_PRINT("%s: queue is empty.  Test Done!\n", __func__);
 	}

 	task_sem_take(SEM_TestDone, TICKS_UNLIMITED);

 exitTest:

 	TC_END_RESULT(tcRC);
 	TC_END_REPORT(tcRC);
 }  /* RegressionTask */
	/*
	* 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 microkernel FIFO APIs
	*
	* This module tests the following FIFO routines:
	*
	* task_fifo_put
	* task_fifo_get
	* task_fifo_size_get
	* task_fifo_purge
	*
	* Scenarios tested include:
	* - Check number of elements in queue when queue is empty, full or
	* while it is being dequeued
	* - Verify the data being dequeued are in correct order
	* - Verify the return codes are correct for the APIs
	*/

	#include <tc_util.h>
	#include <stdbool.h>
	#include <zephyr.h>

	#define MULTIPLIER 100 /* Used to initialize myData */
	#define NUM_OF_ELEMENT 5 /* Number of elements in myData array */
	#define DEPTH_OF_FIFO_QUEUE 2 /* FIFO queue depth--see prj.mdef */

	#define SPECIAL_DATA 999 /* Special number to put in queue */

	static int myData[NUM_OF_ELEMENT];
	static int tcRC = TC_PASS; /* test case return code */

	#ifdef TEST_PRIV_FIFO
	DEFINE_FIFO(FIFOQ, 2, 4);
	#endif

	/**
	*
	* @brief Initialize data array
	*
	* This routine initializes the myData array used in the FIFO tests.
	*
	* @return N/A
	*/

	void initMyData(void)
	{
	for (int i = 0; i < NUM_OF_ELEMENT; i++) {
	myData[i] = i * MULTIPLIER + 1;
	} /* for */
	} /* initMyData */

	/**
	*
	* @brief Print data array
	*
	* This routine prints myData array.
	*
	* @return N/A
	*/

	void printMyData(void)
	{
	for (int i = 0; i < NUM_OF_ELEMENT; i++) {
	PRINT_DATA("myData[%d] = %d,\n", i, myData[i]);
	} /* for */

	} /* printMyData */

	/**
	*
	* @brief Verify return value
	*
	* This routine verifies current value against expected value
	* and returns true if they are the same.
	*
	* @param expectRetValue expect value
	* @param currentRetValue current value
	*
	* @return true, false
	*/

	bool verifyRetValue(int expectRetValue, int currentRetValue)
	{
	return (expectRetValue == currentRetValue);
	} /* verifyRetValue */

	/**
	*
	* @brief Initialize microkernel objects
	*
	* This routine initializes the microkernel objects used in the FIFO tests.
	*
	* @return N/A
	*/

	void initMicroObjects(void)
	{
	initMyData();
	printMyData();
	} /* initMicroObjects */

	/**
	*
	* @brief Fills up the FIFO queue
	*
	* This routine fills the FIFO queue with myData array. This assumes the
	* queue is empty before we put in elements.
	*
	* @param queue FIFO queue
	* @param numElements Number of elements used to inserted into the queue
	*
	* @return TC_PASS, TC_FAIL
	*
	* Also updates tcRC when result is TC_FAIL.
	*/

	int fillFIFO(kfifo_t queue, int numElements)
	{
	int result = TC_PASS; /* TC_PASS or TC_FAIL for this function */
	int retValue; /* return value from task_fifo_xxx APIs */

	for (int i = 0; i < numElements; i++) {
	retValue = task_fifo_put(queue, &myData[i], TICKS_NONE);
	switch (retValue) {
	case RC_OK:
	/* TC_PRINT("i=%d, successfully put in data=%d\n", i, myData[i]); */
	if (i >= DEPTH_OF_FIFO_QUEUE) {
	TC_ERROR("Incorrect return value of RC_OK when i = %d\n", i);
	result = TC_FAIL;
	goto exitTest3;
	}
	break;
	case RC_FAIL:
	/* TC_PRINT("i=%d, FIFOQ is full. Cannot put data=%d\n", i, myData[i]); */
	if (i < DEPTH_OF_FIFO_QUEUE) {
	TC_ERROR("Incorrect return value of RC_FAIL when i = %d\n", i);
	result = TC_FAIL;
	goto exitTest3;
	}
	break;
	default:
	TC_ERROR("Incorrect return value of %d when i = %d\n", retValue, i);
	result = TC_FAIL;
	goto exitTest3;
	} /* switch */

	} /* for */

	exitTest3:
	if (result == TC_FAIL) {
	tcRC = TC_FAIL;
	}

	TC_END_RESULT(result);
	return result;

	} /* fillFIFO */

	/**
	*
	* @brief Task to test FIFO queue
	*
	* This routine is run in three context switches:
	* - it puts an element to the FIFO queue
	* - it purges the FIFO queue
	* - it dequeues an element from the FIFO queue
	*
	* @return N/A
	*/
	void MicroTestFifoTask(void)
	{
	int retValue; /* return value of task_fifo_xxx interface */
	int locData = SPECIAL_DATA; /* variable to pass data to and from queue */

	/* (1) Wait for semaphore: put element test */
	task_sem_take(SEMSIG_MicroTestFifoTask, TICKS_UNLIMITED);

	TC_PRINT("Starts %s\n", __func__);
	/* Put one element */
	TC_PRINT("%s: Puts element %d\n", __func__, locData);
	retValue = task_fifo_put(FIFOQ, &locData, TICKS_NONE);
	/*
	* Execution is switched back to RegressionTask (a higher priority task)
	* which is not block anymore.
	*/
	if (verifyRetValue(RC_OK, retValue)) {
	TC_PRINT("%s: FIFOPut OK for %d\n", __func__, locData);
	} else {
	TC_ERROR("FIFOPut failed, retValue %d\n", retValue);
	tcRC = TC_FAIL;
	goto exitTest4;
	}

	/*
	* (2) Wait for semaphore: purge queue test. Purge queue while another
	* task is in task_fifo_put(TICKS_UNLIMITED). This is to test return
	* value of the task_fifo_put(TICKS_UNLIMITED) interface.
	*/
	task_sem_take(SEMSIG_MicroTestFifoTask, TICKS_UNLIMITED);
	/*
	* RegressionTask is waiting to put data into FIFO queue, which is
	* full. We purge the queue here and the task_fifo_put(TICKS_UNLIMITED)
	* interface will terminate the wait and return RC_FAIL.
	*/
	TC_PRINT("%s: About to purge queue\n", __func__);
	retValue = task_fifo_purge(FIFOQ);

	/*
	* Execution is switched back to RegressionTask (a higher priority task)
	* which is not block anymore.
	*/
	if (verifyRetValue(RC_OK, retValue)) {
	TC_PRINT("%s: Successfully purged queue\n", __func__);
	} else {
	TC_ERROR("Problem purging queue, %d\n", retValue);
	tcRC = TC_FAIL;
	goto exitTest4;
	}

	/* (3) Wait for semaphore: get element test */
	task_sem_take(SEMSIG_MicroTestFifoTask, TICKS_UNLIMITED);
	TC_PRINT("%s: About to dequeue 1 element\n", __func__);
	retValue = task_fifo_get(FIFOQ, &locData, TICKS_NONE);
	/*
	* Execution is switched back to RegressionTask (a higher priority task)
	* which is not block anymore
	*/
	if ((retValue != RC_OK) \|\| (locData != myData[0])) {
	TC_ERROR("task_fifo_get failed,\n retValue %d OR got data %d while expect %d\n"
	, retValue, locData, myData[0]);
	tcRC = TC_FAIL;
	goto exitTest4;
	} else {
	TC_PRINT("%s: task_fifo_get got back correct data %d\n", __func__, locData);
	}

	exitTest4:
	TC_END_RESULT(tcRC);

	/* Allow RegressionTask to print final result of the test */
	task_sem_give(SEM_TestDone);
	}

	/**
	*
	* @brief Verifies data in queue is correct
	*
	* This routine assumes that the queue is full when this function is called.
	* It counts the number of elements in the queue, dequeues elements and verifies
	* that they are in the right order. Expect the dequeue order as: myData[0],
	* myData[1].
	*
	* @param loopCnt number of elements passed to the for loop
	*
	* @return TC_PASS, TC_FAIL
	*
	* Also updates tcRC when result is TC_FAIL.
	*/
	int verifyQueueData(int loopCnt)
	{
	int result = TC_PASS; /* TC_PASS or TC_FAIL for this function */
	int retValue; /* task_fifo_xxx interface return value */
	int locData; /* local variable used for passing data */

	/*
	* Counts elements using task_fifo_size_get interface. Dequeues elements from
	* FIFOQ. Test for proper return code when FIFO queue is empty using
	* task_fifo_get interface.
	*/
	for (int i = 0; i < loopCnt; i++) {
	/* Counts number of elements */
	retValue = task_fifo_size_get(FIFOQ);
	if (!verifyRetValue(DEPTH_OF_FIFO_QUEUE-i, retValue)) {
	TC_ERROR("i=%d, incorrect number of FIFO elements in queue: %d, expect %d\n"
	, i, retValue, DEPTH_OF_FIFO_QUEUE-i);
	result = TC_FAIL;
	goto exitTest2;
	} else {
	/* TC_PRINT("%s: i=%d, %d elements in queue\n", __func__, i, retValue); */
	}

	/* Dequeues element */
	retValue = task_fifo_get(FIFOQ, &locData, TICKS_NONE);

	switch (retValue) {
	case RC_OK:
	if ((i >= DEPTH_OF_FIFO_QUEUE) \|\| (locData != myData[i])) {
	TC_ERROR("RC_OK but got wrong data %d for i=%d\n", locData, i);
	result = TC_FAIL;
	goto exitTest2;
	}

	TC_PRINT("%s: i=%d, successfully get data %d\n", __func__, i, locData);
	break;
	case RC_FAIL:
	if (i < DEPTH_OF_FIFO_QUEUE) {
	TC_ERROR("RC_FAIL but i is only %d\n", i);
	result = TC_FAIL;
	goto exitTest2;
	}
	TC_PRINT("%s: i=%d, FIFOQ is empty. No data.\n", __func__, i);
	break;
	default:
	TC_ERROR("i=%d, incorrect return value %d\n", i, retValue);
	result = TC_FAIL;
	goto exitTest2;
	} /* switch */
	} /* for */

	exitTest2:

	if (result == TC_FAIL) {
	tcRC = TC_FAIL;
	}

	TC_END_RESULT(result);
	return result;

	} /* verifyQueueData */


	/**
	*
	* @brief Main task to test FIFO queue
	*
	* This routine initializes data, fills the FIFO queue and verifies the
	* data in the queue is in correct order when items are being dequeued.
	* It also tests the wait (with and without timeouts) to put data into
	* queue when the queue is full. The queue is purged at some point
	* and checked to see if the number of elements is correct.
	* The get wait interfaces (with and without timeouts) are also tested
	* and data verified.
	*
	* @return N/A
	*/

	void RegressionTask(void)
	{
	int retValue; /* task_fifo_xxx interface return value */
	int locData; /* local variable used for passing data */
	int result; /* result from utility functions */

	TC_START("Test Microkernel FIFO");

	initMicroObjects();

	/*
	* Checks number of elements in queue, expect 0. Test task_fifo_size_get
	* interface.
	*/
	retValue = task_fifo_size_get(FIFOQ);
	if (!verifyRetValue(0, retValue)) {
	TC_ERROR("Incorrect number of FIFO elements in queue: %d\n", retValue);
	tcRC = TC_FAIL;
	goto exitTest;
	}

	/*
	* FIFOQ is only two elements deep. Test for proper return code when
	* FIFO queue is full. Test task_fifo_put(TICKS_NONE) interface.
	*/
	result = fillFIFO(FIFOQ, NUM_OF_ELEMENT);
	if (result == TC_FAIL) { /* terminate test */
	TC_ERROR("Failed fillFIFO.\n");
	goto exitTest;
	}

	/*
	* Checks number of elements in FIFO queue, should be full. Also verifies
	* data is in correct order. Test task_fifo_size_get and task_fifo_get interface.
	*/
	result = verifyQueueData(DEPTH_OF_FIFO_QUEUE + 1);
	if (result == TC_FAIL) { /* terminate test */
	TC_ERROR("Failed verifyQueueData.\n");
	goto exitTest;
	}

	/----------------------------------------------------------------------------/

	/* Fill FIFO queue */
	result = fillFIFO(FIFOQ, NUM_OF_ELEMENT);
	if (result == TC_FAIL) { /* terminate test */
	TC_ERROR("Failed fillFIFO.\n");
	goto exitTest;
	}

	/*
	* Put myData[4] into queue with wait, test task_fifo_put(timeout)
	* interface. Queue is full, so this data did not make it into queue.
	* Expect return code of RC_TIME.
	*/
	TC_PRINT("%s: About to putWT with data %d\n", __func__, myData[4]);
	retValue = task_fifo_put(FIFOQ, &myData[4], 2); /* wait for 2 ticks */
	if (verifyRetValue(RC_TIME, retValue)) {
	TC_PRINT("%s: FIFO Put time out as expected for data %d\n"
	, __func__, myData[4]);
	} else {
	TC_ERROR("Failed task_fifo_put for data %d, retValue %d\n",
	myData[4], retValue);
	tcRC = TC_FAIL;
	goto exitTest;
	}

	/* Queue is full at this stage. Verify data is correct. */
	result = verifyQueueData(DEPTH_OF_FIFO_QUEUE);
	if (result == TC_FAIL) { /* terminate test */
	TC_ERROR("Failed verifyQueueData.\n");
	goto exitTest;
	}

	/----------------------------------------------------------------------------/

	/* Fill FIFO queue. Check number of elements in queue, should be 2. */
	result = fillFIFO(FIFOQ, NUM_OF_ELEMENT);
	if (result == TC_FAIL) { /* terminate test */
	TC_ERROR("Failed fillFIFO.\n");
	goto exitTest;
	}

	retValue = task_fifo_size_get(FIFOQ);
	if (verifyRetValue(DEPTH_OF_FIFO_QUEUE, retValue)) {
	TC_PRINT("%s: %d element in queue\n", __func__, retValue);
	} else {
	TC_ERROR("Incorrect number of FIFO elements in queue: %d\n", retValue);
	tcRC = TC_FAIL;
	goto exitTest;
	}

	/*
	* Purge queue, check number of elements in queue. Test task_fifo_purge
	* interface.
	*/
	retValue = task_fifo_purge(FIFOQ);
	if (verifyRetValue(RC_OK, retValue)) {
	TC_PRINT("%s: Successfully purged queue\n", __func__);
	} else {
	TC_ERROR("Problem purging queue, %d\n", retValue);
	tcRC = TC_FAIL;
	goto exitTest;
	}

	/* Count number of elements in queue */
	retValue = task_fifo_size_get(FIFOQ);
	if (verifyRetValue(0, retValue)) {
	TC_PRINT("%s: confirm %d element in queue\n", __func__, retValue);
	} else {
	TC_ERROR("Incorrect number of FIFO elements in queue: %d\n", retValue);
	tcRC = TC_FAIL;
	goto exitTest;
	}

	PRINT_LINE;
	/----------------------------------------------------------------------------/

	/*
	* Semaphore to allow MicroTestFifoTask to run, but MicroTestFifoTask is lower
	* priority, so it won't run until this current task is blocked
	* in task_fifo_get interface later.
	*/
	task_sem_give(SEMSIG_MicroTestFifoTask);

	/*
	* Test task_fifo_get interface.
	* Expect MicroTestFifoTask to run and insert SPECIAL_DATA into queue.
	*/
	TC_PRINT("%s: About to GetW data\n", __func__);
	retValue = task_fifo_get(FIFOQ, &locData, TICKS_UNLIMITED);
	if ((retValue != RC_OK) \|\| (locData != SPECIAL_DATA)) {
	TC_ERROR("Failed task_fifo_get interface for data %d, retValue %d\n"
	, locData, retValue);
	tcRC = TC_FAIL;
	goto exitTest;
	} else {
	TC_PRINT("%s: GetW get back %d\n", __func__, locData);
	}

	/* MicroTestFifoTask may have modified tcRC */
	if (tcRC == TC_FAIL) { /* terminate test */
	TC_ERROR("tcRC failed.");
	goto exitTest;
	}

	/*
	* Test task_fifo_get(timeout) interface. Try to get more data, but
	* there is none before it times out.
	*/
	retValue = task_fifo_get(FIFOQ, &locData, 2);
	if (verifyRetValue(RC_TIME, retValue)) {
	TC_PRINT("%s: GetWT timeout expected\n", __func__);
	} else {
	TC_ERROR("Failed task_fifo_get interface for retValue %d\n", retValue);
	tcRC = TC_FAIL;
	goto exitTest;
	}

	/----------------------------------------------------------------------------/

	/* Fill FIFO queue */
	result = fillFIFO(FIFOQ, NUM_OF_ELEMENT);
	if (result == TC_FAIL) { /* terminate test */
	TC_ERROR("Failed fillFIFO.\n");
	goto exitTest;
	}

	/* Semaphore to allow MicroTestFifoTask to run */
	task_sem_give(SEMSIG_MicroTestFifoTask);

	/* MicroTestFifoTask may have modified tcRC */
	if (tcRC == TC_FAIL) { /* terminate test */
	TC_ERROR("tcRC failed.");
	goto exitTest;
	}

	/* Queue is full */
	locData = SPECIAL_DATA;
	TC_PRINT("%s: about to putW data %d\n", __func__, locData);
	retValue = task_fifo_put(FIFOQ, &locData, TICKS_UNLIMITED);

	/*
	* Execution is switched to MicroTestFifoTask, which will purge the queue.
	* When the queue is purged while other tasks are waiting to put data into
	* queue, the return value will be RC_FAIL.
	*/
	if (verifyRetValue(RC_FAIL, retValue)) {
	TC_PRINT("%s: PutW ok when queue is purged while waiting\n", __func__);
	} else {
	TC_ERROR("Failed task_fifo_put interface when queue is purged, retValue %d\n"
	, retValue);
	tcRC = TC_FAIL;
	goto exitTest;
	}

	/----------------------------------------------------------------------------/

	/* Fill FIFO queue */
	result = fillFIFO(FIFOQ, NUM_OF_ELEMENT);
	if (result == TC_FAIL) { /* terminate test */
	TC_ERROR("Failed fillFIFO.\n");
	goto exitTest;
	}

	/* Semaphore to allow MicroTestFifoTask to run */
	task_sem_give(SEMSIG_MicroTestFifoTask);

	/* MicroTestFifoTask may have modified tcRC */
	if (tcRC == TC_FAIL) { /* terminate test */
	TC_ERROR("tcRC failed.");
	goto exitTest;
	}

	/* Queue is full */
	TC_PRINT("%s: about to putW data %d\n", __func__, myData[4]);
	retValue = task_fifo_put(FIFOQ, &myData[4], TICKS_UNLIMITED);
	/* Execution is switched to MicroTestFifoTask, which will dequeue one element */
	if (verifyRetValue(RC_OK, retValue)) {
	TC_PRINT("%s: PutW success for data %d\n", __func__, myData[4]);
	} else {
	TC_ERROR("Failed task_fifo_put interface for data %d, retValue %d\n"
	, myData[4], retValue);
	tcRC = TC_FAIL;
	goto exitTest;
	}

	PRINT_LINE;
	/----------------------------------------------------------------------------/

	/*
	* Dequeue all data to check. Expect data in the queue to be:
	* myData[1], myData[4]. myData[0] was dequeued by MicroTestFifoTask.
	*/

	/* Get first data */
	retValue = task_fifo_get(FIFOQ, &locData, TICKS_NONE);
	if ((retValue != RC_OK) \|\| (locData != myData[1])) {
	TC_ERROR("Get back data %d, retValue %d\n", locData, retValue);
	tcRC = TC_FAIL;
	goto exitTest;
	} else {
	TC_PRINT("%s: Get back data %d\n", __func__, locData);
	}

	/* Get second data */
	retValue = task_fifo_get(FIFOQ, &locData, TICKS_NONE);
	if ((retValue != RC_OK) \|\| (locData != myData[4])) {
	TC_ERROR("Get back data %d, retValue %d\n", locData, retValue);
	tcRC = TC_FAIL;
	goto exitTest;
	} else {
	TC_PRINT("%s: Get back data %d\n", __func__, locData);
	}

	/* Queue should be empty */
	retValue = task_fifo_get(FIFOQ, &locData, TICKS_NONE);
	if (retValue != RC_FAIL) {
	TC_ERROR("%s: incorrect retValue %d\n", __func__, retValue);
	tcRC = TC_FAIL;
	goto exitTest;
	} else {
	TC_PRINT("%s: queue is empty. Test Done!\n", __func__);
	}

	task_sem_take(SEM_TestDone, TICKS_UNLIMITED);

	exitTest:

	TC_END_RESULT(tcRC);
	TC_END_REPORT(tcRC);
	} /* RegressionTask */