/*\r
- FreeRTOS V8.0.1 - Copyright (C) 2014 Real Time Engineers Ltd. \r
- All rights reserved\r
-\r
- VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.\r
-\r
- ***************************************************************************\r
- * *\r
- * FreeRTOS provides completely free yet professionally developed, *\r
- * robust, strictly quality controlled, supported, and cross *\r
- * platform software that has become a de facto standard. *\r
- * *\r
- * Help yourself get started quickly and support the FreeRTOS *\r
- * project by purchasing a FreeRTOS tutorial book, reference *\r
- * manual, or both from: http://www.FreeRTOS.org/Documentation *\r
- * *\r
- * Thank you! *\r
- * *\r
- ***************************************************************************\r
-\r
- This file is part of the FreeRTOS distribution.\r
-\r
- FreeRTOS is free software; you can redistribute it and/or modify it under\r
- the terms of the GNU General Public License (version 2) as published by the\r
- Free Software Foundation >>!AND MODIFIED BY!<< the FreeRTOS exception.\r
-\r
- >>! NOTE: The modification to the GPL is included to allow you to !<<\r
- >>! distribute a combined work that includes FreeRTOS without being !<<\r
- >>! obliged to provide the source code for proprietary components !<<\r
- >>! outside of the FreeRTOS kernel. !<<\r
-\r
- FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY\r
- WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS\r
- FOR A PARTICULAR PURPOSE. Full license text is available from the following\r
- link: http://www.freertos.org/a00114.html\r
-\r
- 1 tab == 4 spaces!\r
-\r
- ***************************************************************************\r
- * *\r
- * Having a problem? Start by reading the FAQ "My application does *\r
- * not run, what could be wrong?" *\r
- * *\r
- * http://www.FreeRTOS.org/FAQHelp.html *\r
- * *\r
- ***************************************************************************\r
-\r
- http://www.FreeRTOS.org - Documentation, books, training, latest versions,\r
- license and Real Time Engineers Ltd. contact details.\r
-\r
- http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,\r
- including FreeRTOS+Trace - an indispensable productivity tool, a DOS\r
- compatible FAT file system, and our tiny thread aware UDP/IP stack.\r
-\r
- http://www.OpenRTOS.com - Real Time Engineers ltd license FreeRTOS to High\r
- Integrity Systems to sell under the OpenRTOS brand. Low cost OpenRTOS\r
- licenses offer ticketed support, indemnification and middleware.\r
-\r
- http://www.SafeRTOS.com - High Integrity Systems also provide a safety\r
- engineered and independently SIL3 certified version for use in safety and\r
- mission critical applications that require provable dependability.\r
-\r
- 1 tab == 4 spaces!\r
-*/\r
+ * FreeRTOS Kernel V10.2.1\r
+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.\r
+ *\r
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of\r
+ * this software and associated documentation files (the "Software"), to deal in\r
+ * the Software without restriction, including without limitation the rights to\r
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\r
+ * the Software, and to permit persons to whom the Software is furnished to do so,\r
+ * subject to the following conditions:\r
+ *\r
+ * The above copyright notice and this permission notice shall be included in all\r
+ * copies or substantial portions of the Software.\r
+ *\r
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\r
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\r
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
+ *\r
+ * http://www.FreeRTOS.org\r
+ * http://aws.amazon.com/freertos\r
+ *\r
+ * 1 tab == 4 spaces!\r
+ */\r
\r
/*\r
* Tests the use of queue sets.\r
/* Demo includes. */\r
#include "QueueSet.h"\r
\r
+\r
+#if( configUSE_QUEUE_SETS == 1 ) /* Remove the tests if queue sets are not defined. */\r
+\r
+\r
/* The number of queues that are created and added to the queue set. */\r
#define queuesetNUM_QUEUES_IN_SET 3\r
\r
/* A delay inserted when the Tx task changes its priority to be above the idle\r
task priority to ensure the idle priority tasks get some CPU time before the\r
next iteration of the queue set Tx task. */\r
-#define queuesetTX_LOOP_DELAY ( 200 / portTICK_PERIOD_MS )\r
+#define queuesetTX_LOOP_DELAY pdMS_TO_TICKS( ( TickType_t ) 200 )\r
\r
/* The allowable maximum deviation between a received value and the expected\r
received value. A deviation will occur when data is received from a queue\r
* range of the value being used to distinguish between the two message\r
* sources.\r
*/\r
-static void prvCheckReceivedValue( unsigned long ulReceived );\r
+static void prvCheckReceivedValue( uint32_t ulReceived );\r
\r
/*\r
* For purposes of test coverage, functions that read from and write to a\r
* Checks a value received from a queue falls within the range of expected\r
* values.\r
*/\r
-static portBASE_TYPE prvCheckReceivedValueWithinExpectedRange( unsigned long ulReceived, unsigned long ulExpectedReceived );\r
+static BaseType_t prvCheckReceivedValueWithinExpectedRange( uint32_t ulReceived, uint32_t ulExpectedReceived );\r
\r
/*\r
* Increase test coverage by occasionally change the priorities of the two tasks\r
- * relative to each other. */\r
+ * relative to each other.\r
+ */\r
static void prvChangeRelativePriorities( void );\r
\r
+/*\r
+ * Queue overwrites can only be performed on queues of length of one, requiring\r
+ * a special test function so a queue of length 1 can temporarily be added to a\r
+ * set.\r
+ */\r
+static void prvTestQueueOverwriteWithQueueSet( void );\r
+\r
+/*\r
+ * Test the case where two queues within a set are written to with\r
+ * xQueueOverwrite().\r
+ */\r
+static void prvTestQueueOverwriteOnTwoQueusInQueueSet( void );\r
+static void prvTestQueueOverwriteFromISROnTwoQueusInQueueSet( void );\r
+\r
/*\r
* Local pseudo random number seed and return functions. Used to avoid calls\r
* to the standard library.\r
*/\r
-static unsigned long prvRand( void );\r
-static void prvSRand( unsigned long ulSeed );\r
+static size_t prvRand( void );\r
+static void prvSRand( size_t uxSeed );\r
\r
/*-----------------------------------------------------------*/\r
\r
\r
/* Counts how many times each queue in the set is used to ensure all the\r
queues are used. */\r
-static unsigned long ulQueueUsedCounter[ queuesetNUM_QUEUES_IN_SET ] = { 0 };\r
+static uint32_t ulQueueUsedCounter[ queuesetNUM_QUEUES_IN_SET ] = { 0 };\r
\r
/* The handle of the queue set to which the queues are added. */\r
static QueueSetHandle_t xQueueSet;\r
xAreQueueSetTasksStillRunning() returns pdPASS if the value of\r
ulCycleCounter has changed between consecutive calls, and pdFALSE if\r
ulCycleCounter has stopped incrementing (indicating an error condition). */\r
-static volatile unsigned long ulCycleCounter = 0UL;\r
+static volatile uint32_t ulCycleCounter = 0UL;\r
\r
/* Set to pdFAIL if an error is detected by any queue set task.\r
ulCycleCounter will only be incremented if xQueueSetTasksSatus equals pdPASS. */\r
-static volatile portBASE_TYPE xQueueSetTasksStatus = pdPASS;\r
+static volatile BaseType_t xQueueSetTasksStatus = pdPASS;\r
\r
/* Just a flag to let the function that writes to a queue from an ISR know that\r
the queues are setup and can be used. */\r
-static volatile portBASE_TYPE xSetupComplete = pdFALSE;\r
+static volatile BaseType_t xSetupComplete = pdFALSE;\r
\r
/* The value sent to the queue from the ISR is file scope so the\r
xAreQueeuSetTasksStillRunning() function can check it is incrementing as\r
expected. */\r
-static volatile unsigned long ulISRTxValue = queuesetINITIAL_ISR_TX_VALUE;\r
+static volatile uint32_t ulISRTxValue = queuesetINITIAL_ISR_TX_VALUE;\r
\r
/* Used by the pseudo random number generator. */\r
-static unsigned long ulNextRand = 0;\r
+static size_t uxNextRand = 0;\r
\r
/* The task handles are stored so their priorities can be changed. */\r
TaskHandle_t xQueueSetSendingTask, xQueueSetReceivingTask;\r
{\r
/* Create the tasks. */\r
xTaskCreate( prvQueueSetSendingTask, "SetTx", configMINIMAL_STACK_SIZE, NULL, queuesetMEDIUM_PRIORITY, &xQueueSetSendingTask );\r
- xTaskCreate( prvQueueSetReceivingTask, "SetRx", configMINIMAL_STACK_SIZE, ( void * ) xQueueSetSendingTask, queuesetMEDIUM_PRIORITY, &xQueueSetReceivingTask );\r
-\r
- /* It is important that the sending task does not attempt to write to a\r
- queue before the queue has been created. It is therefore placed into the\r
- suspended state before the scheduler has started. It is resumed by the\r
- receiving task after the receiving task has created the queues and added the\r
- queues to the queue set. */\r
- vTaskSuspend( xQueueSetSendingTask );\r
+\r
+ if( xQueueSetSendingTask != NULL )\r
+ {\r
+ xTaskCreate( prvQueueSetReceivingTask, "SetRx", configMINIMAL_STACK_SIZE, ( void * ) xQueueSetSendingTask, queuesetMEDIUM_PRIORITY, &xQueueSetReceivingTask );\r
+\r
+ /* It is important that the sending task does not attempt to write to a\r
+ queue before the queue has been created. It is therefore placed into\r
+ the suspended state before the scheduler has started. It is resumed by\r
+ the receiving task after the receiving task has created the queues and\r
+ added the queues to the queue set. */\r
+ vTaskSuspend( xQueueSetSendingTask );\r
+ }\r
}\r
/*-----------------------------------------------------------*/\r
\r
-portBASE_TYPE xAreQueueSetTasksStillRunning( void )\r
+BaseType_t xAreQueueSetTasksStillRunning( void )\r
{\r
-static unsigned long ulLastCycleCounter, ulLastISRTxValue = 0;\r
-static unsigned long ulLastQueueUsedCounter[ queuesetNUM_QUEUES_IN_SET ] = { 0 };\r
-portBASE_TYPE xReturn = pdPASS, x;\r
+static uint32_t ulLastCycleCounter, ulLastISRTxValue = 0;\r
+static uint32_t ulLastQueueUsedCounter[ queuesetNUM_QUEUES_IN_SET ] = { 0 };\r
+BaseType_t xReturn = pdPASS, x;\r
\r
if( ulLastCycleCounter == ulCycleCounter )\r
{\r
\r
static void prvQueueSetSendingTask( void *pvParameters )\r
{\r
-unsigned long ulTaskTxValue = 0, ulQueueToWriteTo;\r
+uint32_t ulTaskTxValue = 0;\r
+size_t uxQueueToWriteTo;\r
QueueHandle_t xQueueInUse;\r
\r
/* Remove compiler warning about the unused parameter. */\r
( void ) pvParameters;\r
\r
/* Seed mini pseudo random number generator. */\r
- prvSRand( ( unsigned long ) &ulTaskTxValue );\r
+ prvSRand( ( size_t ) &ulTaskTxValue );\r
\r
for( ;; )\r
{\r
/* Generate the index for the queue to which a value is to be sent. */\r
- ulQueueToWriteTo = prvRand() % queuesetNUM_QUEUES_IN_SET;\r
- xQueueInUse = xQueues[ ulQueueToWriteTo ];\r
+ uxQueueToWriteTo = prvRand() % queuesetNUM_QUEUES_IN_SET;\r
+ xQueueInUse = xQueues[ uxQueueToWriteTo ];\r
\r
/* Note which index is being written to to ensure all the queues are\r
used. */\r
- ( ulQueueUsedCounter[ ulQueueToWriteTo ] )++;\r
+ ( ulQueueUsedCounter[ uxQueueToWriteTo ] )++;\r
\r
/* Send to the queue to unblock the task that is waiting for data to\r
arrive on a queue within the queue set to which this queue belongs. */\r
\r
static void prvChangeRelativePriorities( void )\r
{\r
-static unsigned portBASE_TYPE ulLoops = 0;\r
+static UBaseType_t ulLoops = 0;\r
static eRelativePriorities ePriorities = eEqualPriority;\r
\r
/* Occasionally change the task priority relative to the priority of\r
\r
static void prvQueueSetReceivingTask( void *pvParameters )\r
{\r
-unsigned long ulReceived;\r
+uint32_t ulReceived;\r
QueueHandle_t xActivatedQueue;\r
+TickType_t xBlockTime;\r
\r
/* Remove compiler warnings. */\r
( void ) pvParameters;\r
\r
for( ;; )\r
{\r
+ /* For test coverage reasons, the block time is dependent on the\r
+ priority of this task - which changes during the test. When the task\r
+ is at the idle priority it polls the queue set. */\r
+ if( uxTaskPriorityGet( NULL ) == tskIDLE_PRIORITY )\r
+ {\r
+ xBlockTime = 0;\r
+ }\r
+ else\r
+ {\r
+ xBlockTime = portMAX_DELAY;\r
+ }\r
+\r
/* Wait for a message to arrive on one of the queues in the set. */\r
xActivatedQueue = xQueueSelectFromSet( xQueueSet, portMAX_DELAY );\r
- configASSERT( xActivatedQueue );\r
\r
if( xActivatedQueue == NULL )\r
{\r
- /* This should not happen as an infinite delay was used. */\r
- xQueueSetTasksStatus = pdFAIL;\r
+ if( xBlockTime != 0 )\r
+ {\r
+ /* This should not happen as an infinite delay was used. */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
}\r
else\r
{\r
prvCheckReceivedValue( ulReceived );\r
}\r
taskEXIT_CRITICAL();\r
- }\r
\r
- if( xQueueSetTasksStatus == pdPASS )\r
- {\r
- ulCycleCounter++;\r
+ if( xQueueSetTasksStatus == pdPASS )\r
+ {\r
+ ulCycleCounter++;\r
+ }\r
}\r
}\r
}\r
\r
void vQueueSetAccessQueueSetFromISR( void )\r
{\r
-static unsigned long ulCallCount = 0;\r
+static uint32_t ulCallCount = 0;\r
\r
/* xSetupComplete is set to pdTRUE when the queues have been created and\r
are available for use. */\r
}\r
/*-----------------------------------------------------------*/\r
\r
-static void prvCheckReceivedValue( unsigned long ulReceived )\r
+static void prvCheckReceivedValue( uint32_t ulReceived )\r
{\r
-static unsigned long ulExpectedReceivedFromTask = 0, ulExpectedReceivedFromISR = queuesetINITIAL_ISR_TX_VALUE;\r
+static uint32_t ulExpectedReceivedFromTask = 0, ulExpectedReceivedFromISR = queuesetINITIAL_ISR_TX_VALUE;\r
\r
/* Values are received in tasks and interrupts. It is likely that the\r
receiving task will sometimes get preempted by the receiving interrupt\r
}\r
/*-----------------------------------------------------------*/\r
\r
-static portBASE_TYPE prvCheckReceivedValueWithinExpectedRange( unsigned long ulReceived, unsigned long ulExpectedReceived )\r
+static BaseType_t prvCheckReceivedValueWithinExpectedRange( uint32_t ulReceived, uint32_t ulExpectedReceived )\r
{\r
-portBASE_TYPE xReturn = pdPASS;\r
+BaseType_t xReturn = pdPASS;\r
\r
if( ulReceived > ulExpectedReceived )\r
{\r
static void prvReceiveFromQueueInSetFromISR( void )\r
{\r
QueueSetMemberHandle_t xActivatedQueue;\r
-unsigned long ulReceived;\r
+uint32_t ulReceived;\r
\r
/* See if any of the queues in the set contain data. */\r
xActivatedQueue = xQueueSelectFromSetFromISR( xQueueSet );\r
\r
static void prvSendToQueueInSetFromISR( void )\r
{\r
-static portBASE_TYPE xQueueToWriteTo = 0;\r
+static BaseType_t xQueueToWriteTo = 0;\r
+uint32_t ulTxValueSnapshot = ulISRTxValue;\r
\r
- if( xQueueSendFromISR( xQueues[ xQueueToWriteTo ], ( void * ) &ulISRTxValue, NULL ) == pdPASS )\r
+ if( xQueueSendFromISR( xQueues[ xQueueToWriteTo ], ( void * ) &ulTxValueSnapshot, NULL ) == pdPASS )\r
{\r
ulISRTxValue++;\r
\r
- /* If the Tx value has wrapped then set it back to its\r
- initial value. */\r
+ /* If the Tx value has wrapped then set it back to its initial value. */\r
if( ulISRTxValue == 0UL )\r
{\r
ulISRTxValue = queuesetINITIAL_ISR_TX_VALUE;\r
}\r
/*-----------------------------------------------------------*/\r
\r
+static void prvTestQueueOverwriteWithQueueSet( void )\r
+{\r
+uint32_t ulValueToSend = 0, ulValueReceived = 0;\r
+QueueHandle_t xQueueHandle = NULL, xReceivedHandle = NULL;\r
+const UBaseType_t xLengthOfOne = ( UBaseType_t ) 1;\r
+\r
+ /* Create a queue that has a length of one - a requirement in order to call\r
+ xQueueOverwrite. This will get deleted again when this test completes. */\r
+ xQueueHandle = xQueueCreate( xLengthOfOne, sizeof( uint32_t ) );\r
+ configASSERT( xQueueHandle );\r
+\r
+ if( xQueueHandle != NULL )\r
+ {\r
+ xQueueAddToSet( xQueueHandle, xQueueSet );\r
+\r
+ /* Add an item to the queue then ensure the queue set correctly\r
+ indicates that one item is available, and that item is indeed the\r
+ queue written to. */\r
+ xQueueOverwrite( xQueueHandle, ( void * ) &ulValueToSend );\r
+ if( uxQueueMessagesWaiting( xQueueSet ) != ( UBaseType_t ) 1 )\r
+ {\r
+ /* Expected one item in the queue set. */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+ xQueuePeek( xQueueSet, &xReceivedHandle, queuesetDONT_BLOCK );\r
+ if( xReceivedHandle != xQueueHandle )\r
+ {\r
+ /* Wrote to xQueueHandle so expected xQueueHandle to be the handle\r
+ held in the queue set. */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+\r
+ /* Now overwrite the value in the queue and ensure the queue set state\r
+ doesn't change as the number of items in the queues within the set have\r
+ not changed. */\r
+ ulValueToSend++;\r
+ xQueueOverwrite( xQueueHandle, ( void * ) &ulValueToSend );\r
+ if( uxQueueMessagesWaiting( xQueueSet ) != ( UBaseType_t ) 1 )\r
+ {\r
+ /* Still expected one item in the queue set. */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+ xReceivedHandle = xQueueSelectFromSet( xQueueSet, queuesetDONT_BLOCK );\r
+ if( xReceivedHandle != xQueueHandle )\r
+ {\r
+ /* Wrote to xQueueHandle so expected xQueueHandle to be the handle\r
+ held in the queue set. */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+\r
+ /* Also ensure the value received from the queue is the overwritten\r
+ value, not the value originally written. */\r
+ xQueueReceive( xQueueHandle, &ulValueReceived, queuesetDONT_BLOCK );\r
+ if( ulValueReceived != ulValueToSend )\r
+ {\r
+ /* Unexpected value received from the queue. */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+\r
+ /* Should be anything in the queue set now. */\r
+ if( uxQueueMessagesWaiting( xQueueSet ) != ( UBaseType_t ) 0 )\r
+ {\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+ xReceivedHandle = xQueueSelectFromSet( xQueueSet, queuesetDONT_BLOCK );\r
+ if( xReceivedHandle != NULL )\r
+ {\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+\r
+ /* Clean up. */\r
+ xQueueRemoveFromSet( xQueueHandle, xQueueSet );\r
+ vQueueDelete( xQueueHandle );\r
+ }\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static void prvTestQueueOverwriteOnTwoQueusInQueueSet( void )\r
+{\r
+uint32_t ulValueToSend1 = 1, ulValueToSend2 = 2UL, ulValueReceived = 0;\r
+QueueHandle_t xQueueHandle1 = NULL, xQueueHandle2 = NULL, xReceivedHandle = NULL;\r
+const UBaseType_t xLengthOfOne = ( UBaseType_t ) 1;\r
+\r
+ /* Create two queues that have a length of one - a requirement in order to call\r
+ xQueueOverwrite. These will get deleted again when this test completes. */\r
+ xQueueHandle1 = xQueueCreate( xLengthOfOne, sizeof( uint32_t ) );\r
+ configASSERT( xQueueHandle1 );\r
+ xQueueHandle2 = xQueueCreate( xLengthOfOne, sizeof( uint32_t ) );\r
+ configASSERT( xQueueHandle2 );\r
+\r
+ if( ( xQueueHandle1 != NULL ) && ( xQueueHandle2 != NULL ) )\r
+ {\r
+ /* Add both queues to the queue set. */\r
+ xQueueAddToSet( xQueueHandle1, xQueueSet );\r
+ xQueueAddToSet( xQueueHandle2, xQueueSet );\r
+\r
+ /* Add an item using the first queue. */\r
+ xQueueOverwrite( xQueueHandle1, ( void * ) &ulValueToSend1 );\r
+ if( uxQueueMessagesWaiting( xQueueSet ) != ( UBaseType_t ) 1 )\r
+ {\r
+ /* Expected one item in the queue set. */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+\r
+ xQueuePeek( xQueueSet, &xReceivedHandle, queuesetDONT_BLOCK );\r
+ if( xReceivedHandle != xQueueHandle1 )\r
+ {\r
+ /* Wrote to xQueueHandle so expected xQueueHandle to be the handle\r
+ held in the queue set. */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+\r
+\r
+ /* Next add an item to the second queue. */\r
+ xQueueOverwrite( xQueueHandle2, ( void * ) &ulValueToSend2 );\r
+ if( uxQueueMessagesWaiting( xQueueSet ) != ( UBaseType_t ) 2 )\r
+ {\r
+ /* Expected two items in the queue set. */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+\r
+ /* The head of the queue set should not have changed though. */\r
+ xQueuePeek( xQueueSet, &xReceivedHandle, queuesetDONT_BLOCK );\r
+ if( xReceivedHandle != xQueueHandle1 )\r
+ {\r
+ /* Wrote to xQueueHandle so expected xQueueHandle to be the handle\r
+ held in the queue set. */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+\r
+\r
+\r
+\r
+ /* Now overwrite the value in the queue and ensure the queue set state\r
+ doesn't change as the number of items in the queues within the set have\r
+ not changed. NOTE: after this queue 1 should hold ulValueToSend2 and queue\r
+ 2 should hold the value ulValueToSend1. */\r
+ xQueueOverwrite( xQueueHandle1, ( void * ) &ulValueToSend2 );\r
+ if( uxQueueMessagesWaiting( xQueueSet ) != ( UBaseType_t ) 2 )\r
+ {\r
+ /* Still expected two items in the queue set. */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+ xQueueOverwrite( xQueueHandle2, ( void * ) &ulValueToSend1 );\r
+ if( uxQueueMessagesWaiting( xQueueSet ) != ( UBaseType_t ) 2 )\r
+ {\r
+ /* Still expected two items in the queue set. */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+\r
+\r
+ /* Repeat the above to ensure the queue set state doesn't change. */\r
+ xQueueOverwrite( xQueueHandle1, ( void * ) &ulValueToSend2 );\r
+ if( uxQueueMessagesWaiting( xQueueSet ) != ( UBaseType_t ) 2 )\r
+ {\r
+ /* Still expected two items in the queue set. */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+ xQueueOverwrite( xQueueHandle2, ( void * ) &ulValueToSend1 );\r
+ if( uxQueueMessagesWaiting( xQueueSet ) != ( UBaseType_t ) 2 )\r
+ {\r
+ /* Still expected two items in the queue set. */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+\r
+\r
+ /* Now when reading from the queue set we expect the handle to the first\r
+ queue to be received first, and for that queue to hold ulValueToSend2 as the\r
+ originally written value was overwritten. Likewise the second handle received\r
+ from the set should be that of the second queue, and that queue should hold\r
+ ulValueToSend1 as the originally written value was overwritten. */\r
+ xReceivedHandle = xQueueSelectFromSet( xQueueSet, queuesetDONT_BLOCK );\r
+ if( xReceivedHandle != xQueueHandle1 )\r
+ {\r
+ /* Wrote to xQueueHandle1 first so expected that handle to be read from\r
+ the set first. */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+ if( uxQueueMessagesWaiting( xQueueSet ) != ( UBaseType_t ) 1 )\r
+ {\r
+ /* One value was read from the set, so now only expect a single value\r
+ in the set. */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+ xQueueReceive( xReceivedHandle, &ulValueReceived, queuesetDONT_BLOCK );\r
+ if( ulValueReceived != ulValueToSend2 )\r
+ {\r
+ /* Unexpected value received from the queue. ulValueToSend1 was written\r
+ first, but then overwritten with ulValueToSend2; */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+\r
+ xReceivedHandle = xQueueSelectFromSet( xQueueSet, queuesetDONT_BLOCK );\r
+ if( xReceivedHandle != xQueueHandle2 )\r
+ {\r
+ /* xQueueHandle1 has already been removed from the set so expect only\r
+ xQueueHandle2 to be left. */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+ if( uxQueueMessagesWaiting( xQueueSet ) != ( UBaseType_t ) 0 )\r
+ {\r
+ /* The last value was read from the set so don't expect any more. */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+ xQueueReceive( xReceivedHandle, &ulValueReceived, queuesetDONT_BLOCK );\r
+ if( ulValueReceived != ulValueToSend1 )\r
+ {\r
+ /* Unexpected value received from the queue. ulValueToSend2 was written\r
+ first, but then overwritten with ulValueToSend1. */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+\r
+\r
+\r
+\r
+ /* Should be anything in the queue set now. */\r
+ xReceivedHandle = xQueueSelectFromSet( xQueueSet, queuesetDONT_BLOCK );\r
+ if( xReceivedHandle != NULL )\r
+ {\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+\r
+ /* Clean up. */\r
+ xQueueRemoveFromSet( xQueueHandle1, xQueueSet );\r
+ xQueueRemoveFromSet( xQueueHandle2, xQueueSet );\r
+ vQueueDelete( xQueueHandle1 );\r
+ vQueueDelete( xQueueHandle2 );\r
+ }\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static void prvTestQueueOverwriteFromISROnTwoQueusInQueueSet( void )\r
+{\r
+uint32_t ulValueToSend1 = 1, ulValueToSend2 = 2UL, ulValueReceived = 0;\r
+QueueHandle_t xQueueHandle1 = NULL, xQueueHandle2 = NULL, xReceivedHandle = NULL;\r
+const UBaseType_t xLengthOfOne = ( UBaseType_t ) 1;\r
+\r
+ /* Create two queues that have a length of one - a requirement in order to call\r
+ xQueueOverwrite. These will get deleted again when this test completes. */\r
+ xQueueHandle1 = xQueueCreate( xLengthOfOne, sizeof( uint32_t ) );\r
+ configASSERT( xQueueHandle1 );\r
+ xQueueHandle2 = xQueueCreate( xLengthOfOne, sizeof( uint32_t ) );\r
+ configASSERT( xQueueHandle2 );\r
+\r
+ if( ( xQueueHandle1 != NULL ) && ( xQueueHandle2 != NULL ) )\r
+ {\r
+ /* Add both queues to the queue set. */\r
+ xQueueAddToSet( xQueueHandle1, xQueueSet );\r
+ xQueueAddToSet( xQueueHandle2, xQueueSet );\r
+\r
+ /* Add an item using the first queue using the 'FromISR' version of the\r
+ overwrite function. */\r
+ xQueueOverwriteFromISR( xQueueHandle1, ( void * ) &ulValueToSend1, NULL );\r
+ if( uxQueueMessagesWaiting( xQueueSet ) != ( UBaseType_t ) 1 )\r
+ {\r
+ /* Expected one item in the queue set. */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+\r
+ xQueuePeek( xQueueSet, &xReceivedHandle, queuesetDONT_BLOCK );\r
+ if( xReceivedHandle != xQueueHandle1 )\r
+ {\r
+ /* Wrote to xQueueHandle so expected xQueueHandle to be the handle\r
+ held in the queue set. */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+\r
+\r
+ /* Next add an item to the second queue using the 'FromISR' version of the\r
+ overwrite function. */\r
+ xQueueOverwriteFromISR( xQueueHandle2, ( void * ) &ulValueToSend2, NULL );\r
+ if( uxQueueMessagesWaiting( xQueueSet ) != ( UBaseType_t ) 2 )\r
+ {\r
+ /* Expected two items in the queue set. */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+\r
+ /* The head of the queue set should not have changed though. */\r
+ xQueuePeek( xQueueSet, &xReceivedHandle, queuesetDONT_BLOCK );\r
+ if( xReceivedHandle != xQueueHandle1 )\r
+ {\r
+ /* Wrote to xQueueHandle so expected xQueueHandle to be the handle\r
+ held in the queue set. */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+\r
+\r
+\r
+\r
+ /* Now overwrite the value in the queue and ensure the queue set state\r
+ doesn't change as the number of items in the queues within the set have\r
+ not changed. NOTE: after this queue 1 should hold ulValueToSend2 and queue\r
+ 2 should hold the value ulValueToSend1. */\r
+ xQueueOverwriteFromISR( xQueueHandle1, ( void * ) &ulValueToSend2, NULL );\r
+ if( uxQueueMessagesWaiting( xQueueSet ) != ( UBaseType_t ) 2 )\r
+ {\r
+ /* Still expected two items in the queue set. */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+ xQueueOverwriteFromISR( xQueueHandle2, ( void * ) &ulValueToSend1, NULL );\r
+ if( uxQueueMessagesWaiting( xQueueSet ) != ( UBaseType_t ) 2 )\r
+ {\r
+ /* Still expected two items in the queue set. */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+\r
+\r
+ /* Repeat the above to ensure the queue set state doesn't change. */\r
+ xQueueOverwriteFromISR( xQueueHandle1, ( void * ) &ulValueToSend2, NULL );\r
+ if( uxQueueMessagesWaiting( xQueueSet ) != ( UBaseType_t ) 2 )\r
+ {\r
+ /* Still expected two items in the queue set. */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+ xQueueOverwriteFromISR( xQueueHandle2, ( void * ) &ulValueToSend1, NULL );\r
+ if( uxQueueMessagesWaiting( xQueueSet ) != ( UBaseType_t ) 2 )\r
+ {\r
+ /* Still expected two items in the queue set. */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+\r
+\r
+ /* Now when reading from the queue set we expect the handle to the first\r
+ queue to be received first, and for that queue to hold ulValueToSend2 as the\r
+ originally written value was overwritten. Likewise the second handle received\r
+ from the set should be that of the second queue, and that queue should hold\r
+ ulValueToSend1 as the originally written value was overwritten. */\r
+ xReceivedHandle = xQueueSelectFromSet( xQueueSet, queuesetDONT_BLOCK );\r
+ if( xReceivedHandle != xQueueHandle1 )\r
+ {\r
+ /* Wrote to xQueueHandle1 first so expected that handle to be read from\r
+ the set first. */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+ if( uxQueueMessagesWaiting( xQueueSet ) != ( UBaseType_t ) 1 )\r
+ {\r
+ /* One value was read from the set, so now only expect a single value\r
+ in the set. */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+ xQueueReceive( xReceivedHandle, &ulValueReceived, queuesetDONT_BLOCK );\r
+ if( ulValueReceived != ulValueToSend2 )\r
+ {\r
+ /* Unexpected value received from the queue. ulValueToSend1 was written\r
+ first, but then overwritten with ulValueToSend2; */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+\r
+ xReceivedHandle = xQueueSelectFromSet( xQueueSet, queuesetDONT_BLOCK );\r
+ if( xReceivedHandle != xQueueHandle2 )\r
+ {\r
+ /* xQueueHandle1 has already been removed from the set so expect only\r
+ xQueueHandle2 to be left. */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+ if( uxQueueMessagesWaiting( xQueueSet ) != ( UBaseType_t ) 0 )\r
+ {\r
+ /* The last value was read from the set so don't expect any more. */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+ xQueueReceive( xReceivedHandle, &ulValueReceived, queuesetDONT_BLOCK );\r
+ if( ulValueReceived != ulValueToSend1 )\r
+ {\r
+ /* Unexpected value received from the queue. ulValueToSend2 was written\r
+ first, but then overwritten with ulValueToSend1. */\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+\r
+\r
+\r
+\r
+ /* Should be anything in the queue set now. */\r
+ xReceivedHandle = xQueueSelectFromSet( xQueueSet, queuesetDONT_BLOCK );\r
+ if( xReceivedHandle != NULL )\r
+ {\r
+ xQueueSetTasksStatus = pdFAIL;\r
+ }\r
+\r
+ /* Clean up. */\r
+ xQueueRemoveFromSet( xQueueHandle1, xQueueSet );\r
+ xQueueRemoveFromSet( xQueueHandle2, xQueueSet );\r
+ vQueueDelete( xQueueHandle1 );\r
+ vQueueDelete( xQueueHandle2 );\r
+ }\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
static void prvSetupTest( void )\r
{\r
-portBASE_TYPE x;\r
-unsigned long ulValueToSend = 0;\r
+BaseType_t x;\r
+uint32_t ulValueToSend = 0;\r
\r
/* Ensure the queues are created and the queue set configured before the\r
sending task is unsuspended.\r
for( x = 0; x < queuesetNUM_QUEUES_IN_SET; x++ )\r
{\r
/* Create the queue and add it to the set. The queue is just holding\r
- unsigned long value. */\r
- xQueues[ x ] = xQueueCreate( queuesetQUEUE_LENGTH, sizeof( unsigned long ) );\r
+ uint32_t value. */\r
+ xQueues[ x ] = xQueueCreate( queuesetQUEUE_LENGTH, sizeof( uint32_t ) );\r
configASSERT( xQueues[ x ] );\r
if( xQueueAddToSet( xQueues[ x ], xQueueSet ) != pdPASS )\r
{\r
xQueueSetTasksStatus = pdFAIL;\r
}\r
\r
+ /* Testing the behaviour of queue sets when a queue overwrite operation is\r
+ performed on a set member requires a special test as overwrites can only\r
+ be performed on queues that have a length of 1. */\r
+ prvTestQueueOverwriteWithQueueSet();\r
+\r
+ /* Test the case where two queues within a set are written to with\r
+ xQueueOverwrite(). */\r
+ prvTestQueueOverwriteOnTwoQueusInQueueSet();\r
+ prvTestQueueOverwriteFromISROnTwoQueusInQueueSet();\r
+\r
+ /* In case any of the above have already indicated a failure. */\r
+ configASSERT( xQueueSetTasksStatus != pdFAIL );\r
+\r
/* Resume the task that writes to the queues. */\r
vTaskResume( xQueueSetSendingTask );\r
\r
}\r
/*-----------------------------------------------------------*/\r
\r
-static unsigned long prvRand( void )\r
+static size_t prvRand( void )\r
{\r
- ulNextRand = ( ulNextRand * 1103515245UL ) + 12345UL;\r
- return ( ulNextRand / 65536UL ) % 32768UL;\r
+ uxNextRand = ( uxNextRand * ( size_t ) 1103515245 ) + ( size_t ) 12345;\r
+ return ( uxNextRand / ( size_t ) 65536 ) % ( size_t ) 32768;\r
}\r
/*-----------------------------------------------------------*/\r
\r
-static void prvSRand( unsigned long ulSeed )\r
+static void prvSRand( size_t uxSeed )\r
{\r
- ulNextRand = ulSeed;\r
+ uxNextRand = uxSeed;\r
}\r
\r
+#endif /* ( configUSE_QUEUE_SETS == 1 ) */\r
projects / freertos / blobdiff