begriffs open source - cmsis-freertos/blob - Test/CMock/queue/sets/queue_set_utest.c

   1 /*
   2  * FreeRTOS V202107.00
   3  * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a copy of
   6  * this software and associated documentation files (the "Software"), to deal in
   7  * the Software without restriction, including without limitation the rights to
   8  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
   9  * the Software, and to permit persons to whom the Software is furnished to do so,
  10  * subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in all
  13  * copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
  17  * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
  18  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
  19  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  20  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  21  *
  22  * https://www.FreeRTOS.org
  23  * https://github.com/FreeRTOS
  24  *
  25  */
  26 /*! @file queue_set_utest.c */
  27
  28 /* C runtime includes. */
  29 #include <stdlib.h>
  30 #include <stdbool.h>
  31 #include <string.h>
  32
  33 #include "../queue_utest_common.h"
  34
  35 /* Queue includes */
  36 #include "FreeRTOS.h"
  37 #include "FreeRTOSConfig.h"
  38 #include "queue.h"
  39 #include "mock_fake_port.h"
  40
  41 /* ============================  GLOBAL VARIABLES =========================== */
  42
  43 /* ==========================  CALLBACK FUNCTIONS =========================== */
  44
  45 /* ============================= Unity Fixtures ============================= */
  46
  47 void setUp( void )
  48 {
  49     commonSetUp();
  50 }
  51
  52 void tearDown( void )
  53 {
  54     commonTearDown();
  55 }
  56
  57 void suiteSetUp()
  58 {
  59     commonSuiteSetUp();
  60 }
  61
  62 int suiteTearDown( int numFailures )
  63 {
  64     return commonSuiteTearDown( numFailures );
  65 }
  66
  67 /* ==========================  Helper functions =========================== */
  68
  69 /* ==========================  Test Cases =========================== */
  70
  71 /**
  72  * @brief Test xQueueCreateSet when calls to malloc fail.
  73  * @coverage xQueueCreateSet
  74  */
  75 void test_xQueueCreateSet_malloc_fail( void )
  76 {
  77     UnityMalloc_MakeMallocFailAfterCount( 0 );
  78
  79     QueueSetHandle_t xQueueSet = INVALID_PTR;
  80
  81     xQueueSet = xQueueCreateSet( 1 );
  82
  83     TEST_ASSERT_EQUAL( NULL, xQueueSet );
  84 }
  85
  86 /**
  87  * @brief Test xQueueCreateSet with uxEventQueueLength=0
  88  * @coverage xQueueCreateSet
  89  */
  90 void test_xQueueCreateSet_zeroLength( void )
  91 {
  92     /* Expect that xQueueCreateSet will assert because a length of 0 is invalid */
  93     fakeAssertExpectFail();
  94
  95     QueueSetHandle_t xQueueSet = xQueueCreateSet( 0 );
  96
  97     /* validate returned QueueSet handle */
  98     TEST_ASSERT_EQUAL( NULL, xQueueSet );
  99
 100     /* verify that configASSERT was called */
 101     TEST_ASSERT_EQUAL( true, fakeAssertGetFlagAndClear() );
 102     TEST_ASSERT_EQUAL( 0, getLastMallocSize() );
 103 }
 104
 105 /**
 106  * @brief Test xQueueCreateSet with uxEventQueueLength=1
 107  * @coverage xQueueCreateSet
 108  */
 109 void test_xQueueCreateSet_oneLength( void )
 110 {
 111     QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 );
 112
 113     /* validate returned QueueSet handle */
 114     TEST_ASSERT_NOT_EQUAL( NULL, xQueueSet );
 115
 116     TEST_ASSERT_EQUAL( QUEUE_T_SIZE + sizeof( void * ), getLastMallocSize() );
 117
 118     /* Veify that QueueSet is not full */
 119     TEST_ASSERT_EQUAL( 1, uxQueueSpacesAvailable( xQueueSet ) );
 120
 121     /* Veify that QueueSet is empty */
 122     TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueueSet ) );
 123
 124     vQueueDelete( xQueueSet );
 125 }
 126
 127 /**
 128  * @brief Test xQueueAddToSet with the same queue twice
 129  * @coverage xQueueAddToSet
 130  */
 131 void test_xQueueAddToSet_AlreadyInSameSet( void )
 132 {
 133     QueueSetHandle_t xQueueSet = xQueueCreateSet( 2 );
 134
 135     QueueHandle_t xQueue = xQueueCreate( 1, 0 );
 136
 137     TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue, xQueueSet ) );
 138
 139     TEST_ASSERT_EQUAL( pdFALSE, xQueueAddToSet( xQueue, xQueueSet ) );
 140
 141     ( void ) xQueueRemoveFromSet( xQueue, xQueueSet );
 142     vQueueDelete( xQueueSet );
 143     vQueueDelete( xQueue );
 144 }
 145
 146 /**
 147  * @brief Test xQueueAddToSet with a queue that is already a member of a different QueueSet.
 148  * @coverage xQueueAddToSet
 149  */
 150 void test_xQueueAddToSet_AlreadyInDifferentSet( void )
 151 {
 152     QueueSetHandle_t xQueueSet1 = xQueueCreateSet( 1 );
 153
 154     QueueSetHandle_t xQueueSet2 = xQueueCreateSet( 1 );
 155
 156     QueueHandle_t xQueue = xQueueCreate( 1, 0 );
 157
 158     TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue, xQueueSet1 ) );
 159
 160     TEST_ASSERT_EQUAL( pdFALSE, xQueueAddToSet( xQueue, xQueueSet2 ) );
 161
 162     ( void ) xQueueRemoveFromSet( xQueue, xQueueSet1 );
 163     vQueueDelete( xQueueSet1 );
 164     vQueueDelete( xQueueSet2 );
 165     vQueueDelete( xQueue );
 166 }
 167
 168 /**
 169  * @brief Test xQueueAddToSet with a queue that was previously a member of a different QueueSet, which was deleted.
 170  * @coverage xQueueAddToSet
 171  */
 172 void test_xQueueAddToSet_PreviouslyInDifferentSet( void )
 173 {
 174     QueueSetHandle_t xQueueSet1 = xQueueCreateSet( 1 );
 175     QueueSetHandle_t xQueueSet2 = xQueueCreateSet( 1 );
 176
 177     QueueHandle_t xQueue = xQueueCreate( 1, 0 );
 178
 179     TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue, xQueueSet1 ) );
 180
 181     ( void ) xQueueRemoveFromSet( xQueue, xQueueSet1 );
 182     vQueueDelete( xQueueSet1 );
 183
 184     TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue, xQueueSet2 ) );
 185
 186     ( void ) xQueueRemoveFromSet( xQueue, xQueueSet2 );
 187     vQueueDelete( xQueue );
 188     vQueueDelete( xQueueSet2 );
 189 }
 190
 191 /**
 192  * @brief Test xQueueAddToSet with a queue that is not empty.
 193  * @coverage xQueueAddToSet
 194  */
 195 void test_xQueueAddToSet_QueueNotEmpty( void )
 196 {
 197     QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 );
 198
 199     QueueHandle_t xQueue = xQueueCreate( 1, 0 );
 200
 201     TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, NULL, 0 ) );
 202
 203     TEST_ASSERT_EQUAL( pdFALSE, xQueueAddToSet( xQueue, xQueueSet ) );
 204
 205     ( void ) xQueueRemoveFromSet( xQueue, xQueueSet );
 206     vQueueDelete( xQueueSet );
 207     vQueueDelete( xQueue );
 208 }
 209
 210 /**
 211  * @brief Test xQueueSelectFromSet with multiple queues in a set.
 212  * @coverage xQueueSelectFromSet
 213  */
 214 void test_xQueueSelectFromSet( void )
 215 {
 216     QueueSetHandle_t xQueueSet = xQueueCreateSet( 3 );
 217
 218     QueueHandle_t xQueue1 = xQueueCreate( 1, sizeof( uint32_t ) );
 219     QueueHandle_t xQueue2 = xQueueCreate( 1, sizeof( uint32_t ) );
 220     QueueHandle_t xQueue3 = xQueueCreate( 1, sizeof( uint32_t ) );
 221
 222     TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue1, xQueueSet ) );
 223     TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue2, xQueueSet ) );
 224     TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue3, xQueueSet ) );
 225
 226     uint32_t testVal1 = 1;
 227
 228     TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue1, &testVal1, 0 ) );
 229
 230     uint32_t testVal2 = 2;
 231
 232     TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue2, &testVal2, 0 ) );
 233
 234     uint32_t testVal3 = 3;
 235
 236     TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue3, &testVal3, 0 ) );
 237
 238     QueueHandle_t xQueueTemp = xQueueSelectFromSet( xQueueSet, 0 );
 239
 240     TEST_ASSERT_EQUAL( xQueueTemp, xQueue1 );
 241
 242     uint32_t checkVal1 = 0;
 243
 244     TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueueTemp, &checkVal1, 0 ) );
 245     TEST_ASSERT_EQUAL( testVal1, checkVal1 );
 246
 247     xQueueTemp = xQueueSelectFromSet( xQueueSet, 0 );
 248
 249     TEST_ASSERT_EQUAL( xQueueTemp, xQueue2 );
 250
 251     uint32_t checkVal2 = 0;
 252
 253     TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueueTemp, &checkVal2, 0 ) );
 254     TEST_ASSERT_EQUAL( testVal2, checkVal2 );
 255
 256     xQueueTemp = xQueueSelectFromSet( xQueueSet, 0 );
 257
 258     TEST_ASSERT_EQUAL( xQueueTemp, xQueue3 );
 259
 260     uint32_t checkVal3 = 0;
 261
 262     TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueueTemp, &checkVal3, 0 ) );
 263     TEST_ASSERT_EQUAL( testVal3, checkVal3 );
 264
 265     ( void ) xQueueRemoveFromSet( xQueue1, xQueueSet );
 266     ( void ) xQueueRemoveFromSet( xQueue2, xQueueSet );
 267     ( void ) xQueueRemoveFromSet( xQueue3, xQueueSet );
 268     vQueueDelete( xQueueSet );
 269     vQueueDelete( xQueue1 );
 270     vQueueDelete( xQueue2 );
 271     vQueueDelete( xQueue3 );
 272 }
 273
 274 /**
 275  * @brief Test xQueueSelectFromSetFromISR with multiple queues in a set.
 276  * @coverage xQueueSelectFromSetFromISR
 277  */
 278 void test_xQueueSelectFromSetFromISR( void )
 279 {
 280     QueueSetHandle_t xQueueSet = xQueueCreateSet( 3 );
 281
 282     QueueHandle_t xQueue1 = xQueueCreate( 1, sizeof( uint32_t ) );
 283     QueueHandle_t xQueue2 = xQueueCreate( 1, sizeof( uint32_t ) );
 284     QueueHandle_t xQueue3 = xQueueCreate( 1, sizeof( uint32_t ) );
 285
 286     TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue1, xQueueSet ) );
 287     TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue2, xQueueSet ) );
 288     TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue3, xQueueSet ) );
 289
 290     uint32_t testVal1 = 1;
 291
 292     TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue1, &testVal1, 0 ) );
 293
 294     uint32_t testVal2 = 2;
 295
 296     TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue2, &testVal2, 0 ) );
 297
 298     uint32_t testVal3 = 3;
 299
 300     TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue3, &testVal3, 0 ) );
 301
 302     vFakePortAssertIfInterruptPriorityInvalid_Expect();
 303     QueueHandle_t xQueueTemp = xQueueSelectFromSetFromISR( xQueueSet );
 304
 305     TEST_ASSERT_EQUAL( xQueueTemp, xQueue1 );
 306
 307     vFakePortAssertIfInterruptPriorityInvalid_Expect();
 308     uint32_t checkVal1 = 0;
 309
 310     TEST_ASSERT_EQUAL( pdTRUE, xQueueReceiveFromISR( xQueueTemp, &checkVal1, 0 ) );
 311     TEST_ASSERT_EQUAL( testVal1, checkVal1 );
 312
 313     vFakePortAssertIfInterruptPriorityInvalid_Expect();
 314     xQueueTemp = xQueueSelectFromSetFromISR( xQueueSet );
 315
 316     TEST_ASSERT_EQUAL( xQueueTemp, xQueue2 );
 317
 318     vFakePortAssertIfInterruptPriorityInvalid_Expect();
 319     uint32_t checkVal2 = 0;
 320
 321     TEST_ASSERT_EQUAL( pdTRUE, xQueueReceiveFromISR( xQueueTemp, &checkVal2, 0 ) );
 322     TEST_ASSERT_EQUAL( testVal2, checkVal2 );
 323
 324     vFakePortAssertIfInterruptPriorityInvalid_Expect();
 325     xQueueTemp = xQueueSelectFromSetFromISR( xQueueSet );
 326
 327     TEST_ASSERT_EQUAL( xQueueTemp, xQueue3 );
 328
 329     vFakePortAssertIfInterruptPriorityInvalid_Expect();
 330     uint32_t checkVal3 = 0;
 331
 332     TEST_ASSERT_EQUAL( pdTRUE, xQueueReceiveFromISR( xQueueTemp, &checkVal3, 0 ) );
 333     TEST_ASSERT_EQUAL( testVal3, checkVal3 );
 334
 335     ( void ) xQueueRemoveFromSet( xQueue1, xQueueSet );
 336     ( void ) xQueueRemoveFromSet( xQueue2, xQueueSet );
 337     ( void ) xQueueRemoveFromSet( xQueue3, xQueueSet );
 338     vQueueDelete( xQueueSet );
 339     vQueueDelete( xQueue1 );
 340     vQueueDelete( xQueue2 );
 341     vQueueDelete( xQueue3 );
 342 }
 343
 344 /**
 345  * @brief Test xQueueRemoveFromSet where the queue to be removed
 346  * is not empty.
 347  * @coverage xQueueRemoveFromSet
 348  */
 349 void test_xQueueRemoveFromSet_QueueNotEmpty( void )
 350 {
 351     QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 );
 352
 353     QueueHandle_t xQueue = xQueueCreate( 1, 0 );
 354
 355     TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue, xQueueSet ) );
 356
 357     TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, NULL, 0 ) );
 358
 359     TEST_ASSERT_EQUAL( pdFALSE, xQueueRemoveFromSet( xQueue, xQueueSet ) );
 360
 361     vQueueDelete( xQueueSet );
 362     vQueueDelete( xQueue );
 363 }
 364
 365 /**
 366  * @brief Test xQueueRemoveFromSet where the queue to be removed
 367  * is already in a different set.
 368  * @coverage xQueueRemoveFromSet
 369  */
 370 void test_xQueueRemoveFromSet_QueueNotInSet( void )
 371 {
 372     QueueSetHandle_t xQueueSet1 = xQueueCreateSet( 1 );
 373     QueueSetHandle_t xQueueSet2 = xQueueCreateSet( 1 );
 374
 375     QueueHandle_t xQueue = xQueueCreate( 1, 0 );
 376
 377     TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue, xQueueSet1 ) );
 378
 379     TEST_ASSERT_EQUAL( pdFALSE, xQueueRemoveFromSet( xQueue, xQueueSet2 ) );
 380
 381     TEST_ASSERT_EQUAL( pdTRUE, xQueueRemoveFromSet( xQueue, xQueueSet1 ) );
 382
 383     TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue, xQueueSet2 ) );
 384
 385     vQueueDelete( xQueueSet1 );
 386     vQueueDelete( xQueueSet2 );
 387     vQueueDelete( xQueue );
 388 }
 389
 390 /**
 391  * @brief Test xQueueRemoveFromSet where the queue to be removed
 392  * is in the given set.
 393  * @coverage xQueueRemoveFromSet
 394  */
 395 void test_xQueueRemoveFromSet_QueueInSet( void )
 396 {
 397     QueueSetHandle_t xQueueSet1 = xQueueCreateSet( 1 );
 398     QueueSetHandle_t xQueueSet2 = xQueueCreateSet( 1 );
 399
 400     QueueHandle_t xQueue = xQueueCreate( 1, 0 );
 401
 402     TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue, xQueueSet1 ) );
 403
 404     TEST_ASSERT_EQUAL( pdTRUE, xQueueRemoveFromSet( xQueue, xQueueSet1 ) );
 405
 406     TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue, xQueueSet2 ) );
 407
 408     vQueueDelete( xQueueSet1 );
 409     vQueueDelete( xQueueSet2 );
 410     vQueueDelete( xQueue );
 411 }