pal_rtos_test.c

00001 /*
00002 * Copyright (c) 2016 ARM Limited. All rights reserved.
00003 * SPDX-License-Identifier: Apache-2.0
00004 * Licensed under the Apache License, Version 2.0 (the License); you may
00005 * not use this file except in compliance with the License.
00006 * You may obtain a copy of the License at
00007 *
00008 * http://www.apache.org/licenses/LICENSE-2.0
00009 *
00010 * Unless required by applicable law or agreed to in writing, software
00011 * distributed under the License is distributed on an AS IS BASIS, WITHOUT
00012 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013 * See the License for the specific language governing permissions and
00014 * limitations under the License.
00015 */
00016 
00017 #include "pal_rtos.h"
00018 #include "unity.h"
00019 #include "unity_fixture.h"
00020 #include "pal_rtos_test_utils.h"
00021 #include "pal.h"
00022 #include "pal_rtos_test_utils.h"
00023 
00024 TEST_GROUP(pal_rtos);
00025 
00026 //sometimes you may want to get at local data in a module.
00027 //for example: If you plan to pass by reference, this could be useful
00028 //however, it should often be avoided
00029 //extern int Counter;
00030 uint32_t g_threadStorage[20] = { 0 };
00031 threadsArgument_t g_threadsArg = {0};
00032 timerArgument_t g_timerArgs = {0};
00033 palMutexID_t mutex1 = NULLPTR;
00034 palMutexID_t mutex2 = NULLPTR;
00035 palSemaphoreID_t semaphore1 = NULLPTR;
00036 
00037 //forward declarations
00038 void palRunThreads();
00039 
00040 
00041 TEST_SETUP(pal_rtos)
00042 {
00043   //This is run before EACH TEST
00044   //Counter = 0x5a5a;
00045 }
00046 
00047 TEST_TEAR_DOWN(pal_rtos)
00048 {
00049 }
00050 
00051 TEST(pal_rtos, pal_osKernelSysTick_Unity)
00052 {
00053   uint32_t tick1 = 0, tick2 = 0;
00054   tick1 = pal_osKernelSysTick();
00055   tick2 = pal_osKernelSysTick();
00056   
00057   TEST_ASSERT_TRUE(tick2 != tick1);
00058 }
00059 
00060 TEST(pal_rtos, pal_osKernelSysTick64_Unity)
00061 {
00062   uint64_t tick1 = 0, tick2 = 0;
00063   
00064   tick1 = pal_osKernelSysTick64();
00065   tick2 = pal_osKernelSysTick64();
00066   
00067   TEST_ASSERT_TRUE(tick2 > tick1);
00068 }
00069 
00070 TEST(pal_rtos, pal_osKernelSysTickMicroSec_Unity)
00071 {
00072   uint64_t tick = 0;
00073   uint64_t microSec = 2000 * 1000;
00074 
00075   tick = pal_osKernelSysTickMicroSec(microSec);
00076   TEST_ASSERT_TRUE(0 != tick);
00077 }
00078 
00079 TEST(pal_rtos, pal_osKernelSysMilliSecTick_Unity)
00080 {
00081   uint64_t tick = 0;
00082   uint64_t microSec = 2000 * 1000;
00083   uint64_t milliseconds = 0;
00084   
00085   tick = pal_osKernelSysTickMicroSec(microSec);
00086   TEST_ASSERT_TRUE(0 != tick);
00087   
00088   milliseconds = pal_osKernelSysMilliSecTick(tick);
00089   TEST_ASSERT_EQUAL(milliseconds, microSec/1000);
00090 }
00091 
00092 
00093 TEST(pal_rtos, pal_osKernelSysTickFrequency_Unity)
00094 {
00095   uint64_t frequency = 0;
00096 
00097   frequency = pal_osKernelSysTickFrequency();
00098   
00099   TEST_ASSERT_TRUE(frequency > 0);
00100 }
00101 
00102 TEST(pal_rtos, pal_osDelay_Unity)
00103 {
00104   palStatus_t status = PAL_SUCCESS;
00105   uint32_t tick1 , tick2;
00106 
00107   tick1 = pal_osKernelSysTick();
00108   status = pal_osDelay(200);
00109   tick2 = pal_osKernelSysTick();
00110 
00111   TEST_ASSERT_TRUE(tick2 > tick1);
00112   TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00113 }
00114 
00115 TEST(pal_rtos, BasicTimeScenario)
00116 {
00117   palStatus_t status = PAL_SUCCESS;
00118   uint32_t tick, tick1 , tick2 , index, tickDiff, tickDelta;
00119   uint32_t tmp = 0;
00120 
00121   tick1 = pal_osKernelSysTick();
00122   for(index = 0 ; index < 2000 ; ++index)
00123       ++tmp;
00124   tick2 = pal_osKernelSysTick();
00125   
00126   TEST_ASSERT_TRUE(tick1 != tick2);
00127   TEST_ASSERT_TRUE(tick2 > tick1);  // to check that the tick counts are incremantal - be aware of wrap-arounds
00128 
00129   /****************************************/
00130   tick1 = pal_osKernelSysTick();
00131   status = pal_osDelay(2000);
00132   tick2 = pal_osKernelSysTick();
00133   
00134   TEST_ASSERT_TRUE(tick1 != tick2);
00135   TEST_ASSERT_TRUE(tick2 > tick1);
00136   TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00137   
00138   tickDiff = tick2 - tick1;
00139   tick = pal_osKernelSysTickMicroSec(2000 * 1000);
00140   // 10 milliseconds delta
00141   tickDelta = pal_osKernelSysTickMicroSec(10 * 1000);
00142   TEST_ASSERT_TRUE((tick - tickDelta < tickDiff) && (tickDiff < tick + tickDelta));
00143   TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00144 }
00145 
00146 TEST(pal_rtos, TimerUnityTest)
00147 { 
00148   palStatus_t status = PAL_SUCCESS;
00149   palTimerID_t timerID1 = NULLPTR;
00150   palTimerID_t timerID2 = NULLPTR;
00151   status = pal_init();
00152   TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00153 
00154   status = pal_osTimerCreate(palTimerFunc1, NULL, palOsTimerOnce, &timerID1);
00155   TEST_ASSERT_EQUAL(PAL_SUCCESS, status);  
00156 
00157   status = pal_osTimerCreate(palTimerFunc2, NULL, palOsTimerPeriodic, &timerID2);
00158   TEST_ASSERT_EQUAL(PAL_SUCCESS, status);  
00159 
00160   g_timerArgs.ticksBeforeTimer = pal_osKernelSysTick();
00161   status = pal_osTimerStart(timerID1, 1000);
00162   TEST_PRINTF("ticks before Timer: 0 - %d\n", g_timerArgs.ticksBeforeTimer);
00163   TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00164 
00165   g_timerArgs.ticksBeforeTimer = pal_osKernelSysTick();
00166   status = pal_osTimerStart(timerID2, 1000);
00167   TEST_PRINTF("ticks before Timer: 1 - %d\n", g_timerArgs.ticksBeforeTimer);
00168   TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00169 
00170   status = pal_osDelay(1500);
00171   TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00172 
00173   status = pal_osTimerStop(timerID2);
00174   TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00175 
00176   status = pal_osTimerDelete(&timerID1);
00177   TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00178   TEST_ASSERT_EQUAL(NULL, timerID1);
00179 
00180   status = pal_osTimerDelete(&timerID2);
00181   TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00182   TEST_ASSERT_EQUAL(NULL, timerID2);
00183 }
00184 
00185 TEST(pal_rtos, PrimitivesUnityTest1)
00186 {
00187     palStatus_t status = PAL_SUCCESS;
00188     status = pal_init(NULL);
00189     TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00190 
00191     status = pal_osMutexCreate(&mutex1);
00192     TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00193 
00194     status = pal_osMutexCreate(&mutex2);
00195     TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00196 
00197     status = pal_osSemaphoreCreate(1 ,&semaphore1);
00198     TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00199 
00200     palRunThreads();
00201 
00202     //! sleep for 10 seconds to let the threads finish their functions
00203     status = pal_osDelay(10000);
00204     TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00205 
00206     status = pal_osSemaphoreDelete(&semaphore1);
00207     TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00208     TEST_ASSERT_EQUAL(NULL, semaphore1);
00209 
00210     status = pal_osMutexDelete(&mutex1);
00211     TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00212     TEST_ASSERT_EQUAL(NULL, mutex1);
00213 
00214     status = pal_osMutexDelete(&mutex2);
00215     TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00216     TEST_ASSERT_EQUAL(NULL, mutex2);
00217 
00218 }
00219 
00220 TEST(pal_rtos, PrimitivesUnityTest2)
00221 {
00222   palStatus_t status = PAL_SUCCESS;
00223   int32_t tmp = 0;
00224   palThreadID_t threadID = NULLPTR;
00225   uint32_t stack1; //we have small stack just to pass NON-NULL paramter
00226 
00227 //Check Thread parameter validation
00228   status = pal_osThreadCreate(NULL, NULL, PAL_osPriorityIdle, 1024, &stack1, NULL, &threadID);
00229   TEST_ASSERT_EQUAL(PAL_ERR_INVALID_ARGUMENT, status);
00230 
00231   status = pal_osThreadCreate(palThreadFunc1, NULL, PAL_osPriorityError, 1024, &stack1, NULL, &threadID);
00232   TEST_ASSERT_EQUAL(PAL_ERR_INVALID_ARGUMENT, status);
00233 
00234   status = pal_osThreadCreate(palThreadFunc1, NULL, PAL_osPriorityIdle, 0, &stack1, NULL, &threadID);
00235   TEST_ASSERT_EQUAL(PAL_ERR_INVALID_ARGUMENT, status);
00236 
00237   status = pal_osThreadCreate(palThreadFunc1, NULL, PAL_osPriorityIdle, 1024, NULL, NULL, &threadID);
00238   TEST_ASSERT_EQUAL(PAL_ERR_INVALID_ARGUMENT, status);
00239 
00240   status = pal_osThreadCreate(palThreadFunc1, NULL, PAL_osPriorityIdle, 1024, &stack1, NULL, NULL);
00241   TEST_ASSERT_EQUAL(PAL_ERR_INVALID_ARGUMENT, status);
00242 
00243 //Check Semaphore parameter validation
00244   status = pal_osSemaphoreCreate(1 ,NULL);
00245   TEST_ASSERT_EQUAL(PAL_ERR_INVALID_ARGUMENT, status);
00246 
00247   status = pal_osSemaphoreDelete(NULL);
00248   TEST_ASSERT_EQUAL(PAL_ERR_INVALID_ARGUMENT, status);
00249 
00250   status = pal_osSemaphoreWait(NULLPTR, 1000, &tmp);
00251   TEST_ASSERT_EQUAL(PAL_ERR_INVALID_ARGUMENT, status);
00252 
00253   status = pal_osSemaphoreWait(tmp, 1000, NULL);
00254   TEST_ASSERT_EQUAL(PAL_ERR_INVALID_ARGUMENT, status);
00255   
00256   status = pal_osSemaphoreRelease(NULLPTR);
00257   TEST_ASSERT_EQUAL(PAL_ERR_INVALID_ARGUMENT, status);
00258 }
00259 
00260 TEST(pal_rtos, MemoryPoolUnityTest)
00261 {
00262   palStatus_t status = PAL_SUCCESS;
00263   palMemoryPoolID_t poolID1 = NULLPTR;
00264   palMemoryPoolID_t poolID2 = NULLPTR;
00265   uint8_t* ptr1[MEMORY_POOL1_BLOCK_COUNT] = {0};
00266   uint8_t* ptr2[MEMORY_POOL2_BLOCK_COUNT] = {0};
00267 
00268   status = pal_init(NULL);
00269   TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00270 
00271   status = pal_osPoolCreate(MEMORY_POOL1_BLOCK_SIZE, MEMORY_POOL1_BLOCK_COUNT, &poolID1);
00272   TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00273 
00274   status = pal_osPoolCreate(MEMORY_POOL2_BLOCK_SIZE, MEMORY_POOL2_BLOCK_COUNT, &poolID2);
00275   TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00276 
00277   for(uint8_t block1 = 0 ; block1 < MEMORY_POOL1_BLOCK_COUNT; ++block1)
00278   {
00279     ptr1[block1] = pal_osPoolAlloc(poolID1);
00280     TEST_ASSERT_NOT_EQUAL(ptr1[block1], NULL);
00281   }
00282   for(uint8_t block2 = 0 ; block2 < MEMORY_POOL2_BLOCK_COUNT; ++block2)
00283   {
00284     ptr2[block2] = pal_osPoolCAlloc(poolID2);
00285     TEST_ASSERT_NOT_EQUAL(ptr2[block2], NULL);
00286   }
00287 
00288   for(uint8_t freeblock1 = 0; freeblock1 < MEMORY_POOL1_BLOCK_COUNT; ++freeblock1)
00289   {
00290     status = pal_osPoolFree(poolID1, ptr1[freeblock1]);
00291     TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00292   }
00293 
00294   for(uint8_t freeblock2 = 0; freeblock2 < MEMORY_POOL2_BLOCK_COUNT; ++freeblock2)
00295   {
00296     status = pal_osPoolFree(poolID2, ptr2[freeblock2]);
00297     TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00298   }
00299 
00300   status = pal_osPoolDestroy(&poolID1);
00301   TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00302   TEST_ASSERT_EQUAL(poolID1, NULL);
00303   status = pal_osPoolDestroy(&poolID2);
00304   TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00305   TEST_ASSERT_EQUAL(poolID2, NULL);
00306 }
00307 
00308 
00309 TEST(pal_rtos, MessageUnityTest)
00310 {
00311   palStatus_t status = PAL_SUCCESS;
00312   palMessageQID_t messageQID = NULLPTR;
00313   uint32_t infoToSend = 3215;
00314   uint32_t infoToGet = 0;
00315 
00316   status = pal_init(NULL);
00317   TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00318 
00319   status = pal_osMessageQueueCreate(10, &messageQID);
00320   TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00321 
00322   status = pal_osMessagePut(messageQID, infoToSend, 1500);
00323   TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00324 
00325   status = pal_osMessageGet(messageQID, 1500, &infoToGet);
00326 
00327   TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00328   TEST_ASSERT_EQUAL_UINT32(infoToSend, infoToGet);
00329 
00330   status = pal_osMessageQueueDestroy(&messageQID);
00331   TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00332   TEST_ASSERT_EQUAL(messageQID, NULL);
00333 }
00334 
00335 TEST(pal_rtos, AtomicIncrementUnityTest)
00336 {
00337   int32_t num1 = 0;
00338   int32_t increment = 10;
00339   int32_t tmp = 0;
00340   int32_t original = num1;
00341 
00342   tmp = pal_osAtomicIncrement(&num1, increment);
00343 
00344   
00345   TEST_ASSERT_EQUAL(original + increment, tmp);
00346   
00347 }
00348 
00349 TEST(pal_rtos, pal_init_test)
00350 {
00351   palStatus_t status = PAL_SUCCESS;
00352   
00353   status = pal_init();
00354   TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00355 
00356   status = pal_init();
00357   TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00358 
00359   status = pal_init();
00360   TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00361 
00362   pal_destroy();
00363     
00364   pal_destroy();
00365     
00366   pal_destroy();
00367     
00368   pal_destroy();
00369 }
00370 
00371 TEST(pal_rtos, CustomizedTest)
00372 {
00373   palStatus_t status = PAL_SUCCESS;
00374   palThreadID_t threadID1 = NULLPTR;
00375   palThreadID_t threadID2 = NULLPTR;
00376   uint32_t *stack1 = (uint32_t*)malloc(sizeof(uint32_t) * 512);
00377   uint32_t *stack2 = (uint32_t*)malloc(sizeof(uint32_t) * 512);
00378 
00379   
00380   status = pal_osThreadCreate(palThreadFuncCustom1, NULL, PAL_osPriorityAboveNormal, 1024, stack1, NULL, &threadID1);
00381   TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00382 
00383   status = pal_osThreadCreate(palThreadFuncCustom2, NULL, PAL_osPriorityHigh, 1024, stack2, NULL, &threadID2);
00384   TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00385 
00386   pal_osDelay(3000);
00387 
00388   status = pal_osThreadTerminate(&threadID1);
00389   TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00390 
00391   status = pal_osThreadTerminate(&threadID2);
00392   TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00393 
00394 
00395   status = pal_osThreadCreate(palThreadFuncCustom1, NULL, PAL_osPriorityAboveNormal, 1024, stack1, NULL, &threadID1);
00396   TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00397 
00398   status = pal_osThreadCreate(palThreadFuncCustom2, NULL, PAL_osPriorityHigh, 1024, stack2, NULL, &threadID2);
00399   TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00400 
00401   pal_osDelay(3000);
00402   status = pal_osThreadTerminate(&threadID1);
00403   TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00404 
00405   status = pal_osThreadTerminate(&threadID2);
00406   TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00407   pal_osDelay(500);
00408 
00409   free(stack1);
00410   free(stack2);
00411   
00412 }
00413