1 /*
2 * Copyright (c) 2020-2023 Huawei Device Co., Ltd.
3 *
4 * HDF is dual licensed: you can use it either under the terms of
5 * the GPL, or the BSD license, at your option.
6 * See the LICENSE file in the root of this repository for complete details.
7 */
8
9 #ifdef __USER__
10 #include <sched.h>
11 #endif
12
13 #include "hdf_base.h"
14 #include "hdf_log.h"
15 #include "osal_case_cmd_test.h"
16 #include "osal_file_test.h"
17 #include "osal_firmware.h"
18 #include "osal_get_case_test.h"
19 #include "osal_irq.h"
20 #include "osal_list_test.h"
21 #include "osal_mem.h"
22 #include "osal_mutex.h"
23 #include "osal_spinlock.h"
24 #include "osal_test_case_def.h"
25 #ifndef __USER__
26 #include "osal_test_type.h"
27 #endif
28 #ifdef __USER__
29 #include "pthread.h"
30 #endif
31 #include "osal_thread.h"
32 #include "osal_time.h"
33 #include "osal_timer.h"
34 #include "securec.h"
35
36 #define IRQ_NUM_TEST 33
37 #define HDF_LOG_TAG osal_test
38
39 #define OSAL_TEST_TIME_DEFAULT 100
40
41 uint32_t g_osalTestCases[OSAL_TEST_CASE_CNT];
42
43 OsalTimespec g_hdfTestBegin;
44 OsalTimespec g_hdfTestEnd;
45 static int32_t g_waitMutexTime = 3100;
46 static bool g_threadTest1Flag = true;
47 OSAL_DECLARE_THREAD(thread1);
48 OSAL_DECLARE_THREAD(thread2);
49 #ifdef __USER__
50 OSAL_DECLARE_THREAD(thread3);
51 OSAL_DECLARE_THREAD(thread4);
52 OSAL_DECLARE_THREAD(thread5);
53 #endif
54 OSAL_DECLARE_THREAD(thread);
55 struct OsalMutex g_mutexTest;
56 OSAL_DECLARE_SPINLOCK(g_spinTest);
57
58 #define HDF_THREAD_TEST_SLEEP_S 1
59 #define HDF_THREAD_TEST_SLEEP_US 600
60 #define HDF_THREAD_TEST_SLEEP_MS 300
61 #define HDF_THREAD_TEST_MUX_CNT 20
62 static bool g_thread1RunFlag;
63 static bool g_threadMuxLockFlag;
64 static int32_t g_test1Para = 120;
65 static int32_t g_test2Para = 123;
66 #define TIME_RANGE 200000
67 #define NUMERATOR 15
68 #define DENOMINATOR 100
OsalCheckTime(OsalTimespec * time,uint32_t ms)69 static bool OsalCheckTime(OsalTimespec *time, uint32_t ms)
70 {
71 uint64_t t1 = time->sec * HDF_KILO_UNIT * HDF_KILO_UNIT + time->usec;
72 uint64_t t2 = (uint64_t)ms * HDF_KILO_UNIT;
73 uint64_t diff = (t1 < t2) ? (t2 - t1) : (t1 - t2);
74 uint64_t timeRange = t2 / DENOMINATOR * NUMERATOR;
75 timeRange = (timeRange < TIME_RANGE) ? TIME_RANGE: timeRange;
76
77 return diff < timeRange;
78 }
79
ThreadTest1(void * arg)80 static int ThreadTest1(void *arg)
81 {
82 static int cnt = 0;
83 int ret;
84
85 HDF_LOGI("[OSAL_UT_TEST]%s test thread para end", __func__);
86 (void)arg;
87
88 g_thread1RunFlag = true;
89
90 while (g_threadTest1Flag) {
91 OsalSleep(HDF_THREAD_TEST_SLEEP_S);
92 HDF_LOGE("%s %d", __func__, cnt);
93 cnt++;
94 if (cnt > HDF_THREAD_TEST_MUX_CNT) {
95 g_waitMutexTime = HDF_WAIT_FOREVER;
96 }
97 ret = OsalMutexTimedLock(&g_mutexTest, g_waitMutexTime);
98 if (g_threadMuxLockFlag) {
99 UT_TEST_CHECK_RET(ret == HDF_FAILURE, OSAL_MUTEX_LOCK_TIMEOUT);
100 } else {
101 UT_TEST_CHECK_RET(ret == HDF_FAILURE, OSAL_MUTEX_LOCK_TIMEOUT);
102 }
103
104 OsalMSleep(HDF_THREAD_TEST_SLEEP_MS);
105 if (ret == HDF_SUCCESS) {
106 ret = OsalMutexUnlock(&g_mutexTest);
107 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_MUTEX_UNLOCK);
108 }
109 OsalMSleep(HDF_THREAD_TEST_SLEEP_US);
110
111 ret = OsalSpinLock(&g_spinTest);
112 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_SPIN_LOCK);
113 ret = OsalSpinUnlock(&g_spinTest);
114 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_SPIN_UNLOCK);
115
116 OsalMSleep(HDF_THREAD_TEST_SLEEP_MS);
117 if (cnt % HDF_THREAD_TEST_MUX_CNT == 0) {
118 HDF_LOGE("%s ", __func__);
119 }
120 if (g_testEndFlag) {
121 break;
122 }
123 }
124 HDF_LOGE("%s thread return\n", __func__);
125 return 0;
126 }
127
128 static bool g_thread2RunFlag;
129 static bool g_threadTest2Flag = true;
ThreadTest2(void * arg)130 static int ThreadTest2(void *arg)
131 {
132 static int cnt = 0;
133 OsalTimespec hdfTs1 = { 0, 0 };
134 OsalTimespec hdfTs2 = { 0, 0 };
135 OsalTimespec hdfTsDiff = { 0, 0 };
136 int ret;
137 int32_t para;
138
139 HDF_LOGI("[OSAL_UT_TEST]%s test thread para end", __func__);
140 if (arg != NULL) {
141 para = *(int32_t *)arg;
142 UT_TEST_CHECK_RET(para != g_test2Para, OSAL_THREAD_PARA_CHECK);
143 } else {
144 UT_TEST_CHECK_RET(true, OSAL_THREAD_PARA_CHECK);
145 }
146
147 g_thread2RunFlag = true;
148
149 while (g_threadTest2Flag) {
150 OsalSleep(HDF_THREAD_TEST_SLEEP_S);
151 OsalGetTime(&hdfTs1);
152 HDF_LOGE("%s %d", __func__, cnt);
153
154 cnt++;
155 ret = OsalMutexTimedLock(&g_mutexTest, g_waitMutexTime);
156 if (g_threadMuxLockFlag) {
157 UT_TEST_CHECK_RET(ret == HDF_FAILURE, OSAL_MUTEX_LOCK_TIMEOUT);
158 } else {
159 UT_TEST_CHECK_RET(ret == HDF_FAILURE, OSAL_MUTEX_LOCK_TIMEOUT);
160 }
161
162 OsalMSleep(HDF_THREAD_TEST_SLEEP_MS);
163 if (ret == HDF_SUCCESS) {
164 ret = OsalMutexUnlock(&g_mutexTest);
165 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_MUTEX_UNLOCK);
166 }
167
168 OsalMSleep(HDF_THREAD_TEST_SLEEP_US);
169
170 ret = OsalSpinLock(&g_spinTest);
171 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_SPIN_LOCK);
172 ret = OsalSpinUnlock(&g_spinTest);
173 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_SPIN_UNLOCK);
174
175 OsalMSleep(HDF_THREAD_TEST_SLEEP_MS);
176 OsalGetTime(&hdfTs2);
177 OsalDiffTime(&hdfTs1, &hdfTs2, &hdfTsDiff);
178 if (cnt % HDF_THREAD_TEST_MUX_CNT == 0) {
179 HDF_LOGE("%s %us %uus", __func__,
180 (uint32_t)hdfTsDiff.sec, (uint32_t)hdfTsDiff.usec);
181 }
182 if (g_testEndFlag) {
183 break;
184 }
185 }
186 HDF_LOGE("%s thread return\n", __func__);
187 return 0;
188 }
189
190 #ifdef __USER__
191 #define SCHED_OTHER_PRIORITY 0
192 #define SCHED_FIFO_PRIORITY 15
193 #define SCHED_RR_PRIORITY 15
ThreadTest3(void * arg)194 static int ThreadTest3(void *arg)
195 {
196 int policy;
197 struct sched_param param;
198
199 HDF_LOGI("[OSAL_UT_TEST]%s test thread para end", __func__);
200 (void)arg;
201
202 OsalSleep(HDF_THREAD_TEST_SLEEP_S);
203 pthread_getschedparam(pthread_self(), &policy, ¶m);
204 #ifndef __LITEOS__
205 UT_TEST_CHECK_RET(policy != SCHED_OTHER, OSAL_THREAD_CREATE);
206 UT_TEST_CHECK_RET(param.sched_priority != SCHED_OTHER_PRIORITY, OSAL_THREAD_CREATE);
207 #endif
208 printf("%s: policy is %d, param.sched_priority is %d \n", __func__, policy, param.sched_priority);
209 HDF_LOGI("%s thread return\n", __func__);
210
211 return 0;
212 }
213
ThreadTest4(void * arg)214 static int ThreadTest4(void *arg)
215 {
216 int policy;
217 struct sched_param param;
218
219 HDF_LOGI("[OSAL_UT_TEST]%s test thread para end", __func__);
220 (void)arg;
221
222 OsalSleep(HDF_THREAD_TEST_SLEEP_S);
223 pthread_getschedparam(pthread_self(), &policy, ¶m);
224 #ifndef __LITEOS__
225 UT_TEST_CHECK_RET(policy != SCHED_FIFO, OSAL_THREAD_CREATE);
226 UT_TEST_CHECK_RET(param.sched_priority != SCHED_FIFO_PRIORITY, OSAL_THREAD_CREATE);
227 #endif
228 printf("%s: policy is %d, param.sched_priority is %d \n", __func__, policy, param.sched_priority);
229 HDF_LOGI("%s thread return\n", __func__);
230
231 return 0;
232 }
233
ThreadTest5(void * arg)234 static int ThreadTest5(void *arg)
235 {
236 int policy;
237 struct sched_param param;
238
239 HDF_LOGI("[OSAL_UT_TEST]%s test thread para end", __func__);
240 (void)arg;
241
242 OsalSleep(HDF_THREAD_TEST_SLEEP_S);
243 pthread_getschedparam(pthread_self(), &policy, ¶m);
244 #ifndef __LITEOS__
245 UT_TEST_CHECK_RET(policy != SCHED_RR, OSAL_THREAD_CREATE);
246 UT_TEST_CHECK_RET(param.sched_priority != SCHED_RR_PRIORITY, OSAL_THREAD_CREATE);
247 #endif
248 printf("%s: policy is %d, param.sched_priority is %d \n", __func__, policy, param.sched_priority);
249 HDF_LOGI("%s thread return\n", __func__);
250
251 return 0;
252 }
253 #endif
254
255 #define HDF_DBG_CNT_CTRL 10
256 #ifndef __USER__
257 OSAL_DECLARE_TIMER(g_testTimerLoop1);
258 OSAL_DECLARE_TIMER(g_testTimerLoop2);
259 OSAL_DECLARE_TIMER(g_testTimerOnce);
260 #define HDF_TIMER1_PERIOD 630
261 #define HDF_TIMER2_PERIOD 1350
262 static int32_t g_timerPeriod1 = HDF_TIMER1_PERIOD;
263 static int32_t g_timerPeriod2 = HDF_TIMER2_PERIOD;
264 static int32_t g_timerPeriod3 = 10300;
265 static int32_t g_timerPeriod1Modify = 1250;
266 static int32_t g_timerPeriod2Modify = 750;
267 #define HDF_TIMER_TEST_MODIFY 8
268 #define HDF_TEST_TIMER_PARA 1
269 #define HDF_TEST_TIMER_MODIFY 2
270 #define HDF_TEST_TIMER_END 3
271
272 static bool g_timerLoop1RunFlag;
273 static int g_timer1Cnt = 0;
TimerLoopTest1(uintptr_t arg)274 static void TimerLoopTest1(uintptr_t arg)
275 {
276 int32_t para;
277 OsalTimespec hdfTs1 = { 0, 0 };
278 static OsalTimespec hdfTs2 = { 0, 0 };
279 OsalTimespec hdfTsDiff = { 0, 0 };
280 static int index = HDF_TEST_TIMER_PARA;
281 int32_t ret;
282
283 if (g_timer1Cnt == 0) {
284 OsalGetTime(&hdfTs2);
285 }
286
287 para = *(int32_t *)arg;
288 if ((g_timer1Cnt >= 1) && (g_timer1Cnt != HDF_TIMER_TEST_MODIFY + 1)) {
289 OsalGetTime(&hdfTs1);
290 OsalDiffTime(&hdfTs2, &hdfTs1, &hdfTsDiff);
291 HDF_LOGE("%s %d %d %d %d %d", __func__, g_timer1Cnt, para, (int32_t)hdfTsDiff.sec,
292 (int32_t)hdfTsDiff.usec, g_timerPeriod1);
293 UT_TEST_CHECK_RET(!OsalCheckTime(&hdfTsDiff, g_timerPeriod1), OSAL_TIMER_PERIOD_CHECK);
294 UT_TEST_CHECK_RET(g_timerPeriod1 != para, OSAL_TIMER_PARA_CHECK);
295 if (index == HDF_TEST_TIMER_PARA) {
296 HDF_LOGE("[OSAL_UT_TEST]%s test timer para end", __func__);
297 index = HDF_TEST_TIMER_END;
298 }
299 if (index == HDF_TEST_TIMER_MODIFY) {
300 HDF_LOGE("[OSAL_UT_TEST]%s test timer modify function end", __func__);
301 index = HDF_TEST_TIMER_END;
302 }
303 }
304
305 if (g_timer1Cnt == HDF_TIMER_TEST_MODIFY) {
306 g_timerPeriod1 = g_timerPeriod1Modify;
307 ret = OsalTimerSetTimeout(&g_testTimerLoop1, g_timerPeriod1);
308 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_TIMER_MODIFY_CHECK);
309 index = HDF_TEST_TIMER_MODIFY;
310 }
311
312 OsalGetTime(&hdfTs2);
313
314 g_timer1Cnt++;
315 g_timerLoop1RunFlag = true;
316 }
317
318 static bool g_timerLoop2RunFlag;
319 static int g_timer2Cnt = 0;
TimerLoopTest2(uintptr_t arg)320 static void TimerLoopTest2(uintptr_t arg)
321 {
322 int32_t para;
323 OsalTimespec hdfTs1 = { 0, 0 };
324 static OsalTimespec hdfTs2 = { 0, 0 };
325 OsalTimespec hdfTsDiff = { 0, 0 };
326 static int index = HDF_TEST_TIMER_PARA;
327 int32_t ret;
328
329 if (g_timer2Cnt == 0) {
330 OsalGetTime(&hdfTs2);
331 }
332
333 para = *(int32_t *)arg;
334 if ((g_timer2Cnt >= 1) && (g_timer2Cnt != HDF_TIMER_TEST_MODIFY + 1)) {
335 OsalGetTime(&hdfTs1);
336 OsalDiffTime(&hdfTs2, &hdfTs1, &hdfTsDiff);
337 HDF_LOGE("%s %d %d %d %d %d", __func__, g_timer2Cnt, para, (int32_t)hdfTsDiff.sec,
338 (int32_t)hdfTsDiff.usec, g_timerPeriod2);
339
340 UT_TEST_CHECK_RET(!OsalCheckTime(&hdfTsDiff, g_timerPeriod2), OSAL_TIMER_PERIOD_CHECK);
341 UT_TEST_CHECK_RET(g_timerPeriod2 != para, OSAL_TIMER_PARA_CHECK);
342 if (index == HDF_TEST_TIMER_PARA) {
343 HDF_LOGE("[OSAL_UT_TEST]%s test timer para end", __func__);
344 index = HDF_TEST_TIMER_END;
345 }
346 if (index == HDF_TEST_TIMER_MODIFY) {
347 HDF_LOGE("[OSAL_UT_TEST]%s test timer modify function end", __func__);
348 index = HDF_TEST_TIMER_END;
349 }
350 }
351
352 if (g_timer2Cnt == HDF_TIMER_TEST_MODIFY) {
353 g_timerPeriod2 = g_timerPeriod2Modify;
354 HDF_LOGE("[OSAL_UT_TEST]%s modify timer", __func__);
355 ret = OsalTimerSetTimeout(&g_testTimerLoop2, g_timerPeriod2);
356 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_TIMER_MODIFY_CHECK);
357 index = HDF_TEST_TIMER_MODIFY;
358 }
359 OsalGetTime(&hdfTs2);
360 g_timer2Cnt++;
361 g_timerLoop2RunFlag = true;
362 }
363
364 static int g_timerOnceRunCnt = 0;
TimerOnceTest(uintptr_t arg)365 static void TimerOnceTest(uintptr_t arg)
366 {
367 int32_t para;
368 para = *(int32_t *)arg;
369
370 HDF_LOGE("%s %d", __func__, para);
371 UT_TEST_CHECK_RET(para != g_timerPeriod3, OSAL_TIMER_PARA_CHECK);
372 g_timerOnceRunCnt++;
373 }
374
OsaTimerTest(void)375 static void OsaTimerTest(void)
376 {
377 int32_t ret;
378
379 HDF_LOGI("[OSAL_UT_TEST]%s start", __func__);
380 g_timerPeriod1 = HDF_TIMER1_PERIOD;
381 g_timerPeriod2 = HDF_TIMER2_PERIOD;
382
383 ret = OsalTimerCreate(&g_testTimerLoop1, g_timerPeriod1, TimerLoopTest1, (uintptr_t)&g_timerPeriod1);
384 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_TIMER_CREATE_LOOP);
385 OsalTimerStartLoop(&g_testTimerLoop1);
386
387 ret = OsalTimerCreate(&g_testTimerLoop2, g_timerPeriod2, TimerLoopTest2, (uintptr_t)&g_timerPeriod2);
388 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_TIMER_CREATE_LOOP);
389 OsalTimerStartLoop(&g_testTimerLoop2);
390
391 ret = OsalTimerCreate(&g_testTimerOnce, g_timerPeriod3, TimerOnceTest, (uintptr_t)&g_timerPeriod3);
392 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_TIMER_CREATE_ONCE);
393 OsalTimerStartOnce(&g_testTimerOnce);
394
395 HDF_LOGI("[OSAL_UT_TEST]%s end", __func__);
396 }
397
398 #define HDF_ONCE_TIMER_DEL_TIME 10
OsaTimerTestStop(void)399 static void OsaTimerTestStop(void)
400 {
401 int32_t ret;
402
403 HDF_LOGI("[OSAL_UT_TEST]%s start", __func__);
404 ret = OsalTimerDelete(&g_testTimerLoop2);
405 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_TIMER_STOP_CHECK);
406 g_timerLoop2RunFlag = false;
407
408 ret = OsalTimerDelete(&g_testTimerOnce);
409 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_TIMER_STOP_CHECK);
410
411 ret = OsalTimerCreate(&g_testTimerOnce, g_timerPeriod3, TimerOnceTest, (uintptr_t)&g_timerPeriod3);
412 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_TIMER_CREATE_ONCE);
413
414 OsalTimerStartOnce(&g_testTimerOnce);
415 HDF_LOGI("[OSAL_UT_TEST]%s OsalTimerStartOnce", __func__);
416 OsalMSleep(HDF_ONCE_TIMER_DEL_TIME);
417 ret = OsalTimerDelete(&g_testTimerOnce);
418 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_TIMER_STOP_CHECK);
419
420 HDF_LOGI("[OSAL_UT_TEST]%s end", __func__);
421 }
422
423 #define HDF_FILE_SEEK_TEST 8
OsaFWTest(int flag)424 static void OsaFWTest(int flag)
425 {
426 struct OsalFirmware fw;
427 struct OsalFwBlock block;
428 int32_t ret;
429 char *name = NULL;
430 char *fwBuf = OsalFWTestBuff();
431
432 HDF_LOGE("[OSAL_UT_TEST]%s start", __func__);
433 if (flag != 0) {
434 HDF_LOGE("%s file do not exist %d", __func__, flag);
435 return;
436 }
437 #if defined(__LITEOS__)
438 name = TEST_FW_PATH_NAME;
439 #else
440 name = TEST_FW_NAME;
441 #endif
442 (void)memset_s(&fw, sizeof(fw), 0, sizeof(fw));
443 ret = OsalRequestFirmware(&fw, name, NULL);
444 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_FW_REQUEST);
445 HDF_LOGE("%s %u", name, fw.fwSize);
446
447 (void)memset_s(&block, sizeof(block), 0, sizeof(block));
448 ret = OsalReadFirmware(&fw, &block);
449 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_FW_READ);
450 HDF_LOGE("%s %d %d", name, block.dataSize, block.curOffset);
451 UT_TEST_CHECK_RET(memcmp(block.data, fwBuf, block.dataSize) != 0, OSAL_FW_DATA_CHECK);
452 #if defined(__LITEOS__)
453 ret = OsalSeekFirmware(&fw, HDF_FILE_SEEK_TEST);
454 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_FW_SEEK);
455 HDF_LOGE("%s %u %d", name, block.dataSize, block.curOffset);
456 ret = OsalReadFirmware(&fw, &block);
457 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_FW_READ);
458 HDF_LOGE("%s %u %d", name, block.dataSize, block.curOffset);
459 fwBuf += HDF_FILE_SEEK_TEST;
460 UT_TEST_CHECK_RET(memcmp(block.data, fwBuf, block.dataSize) != 0, OSAL_FW_DATA_CHECK);
461 #endif
462 ret = OsalReleaseFirmware(&fw);
463 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_FW_RELEASE);
464 ret = OsalReadFirmware(&fw, &block);
465 UT_TEST_CHECK_RET(ret == HDF_SUCCESS, OSAL_FW_READ_AFTER_RELEASE);
466 HDF_LOGE("[OSAL_UT_TEST]%s end", __func__);
467 }
468
469 #define THREAD_TEST_TIMER_RUN 20
470 #define THREAD_TEST_TIMER_STOP 25
471
OsaCheckRun(int cnt)472 static void OsaCheckRun(int cnt)
473 {
474 OsalTimespec diffTime = { 0, 0 };
475
476 if (cnt == THREAD_TEST_TIMER_RUN) {
477 UT_TEST_CHECK_RET(g_timerOnceRunCnt == 0, OSAL_TIMER_RUN_CHECK);
478 UT_TEST_CHECK_RET(!g_timerLoop2RunFlag, OSAL_TIMER_RUN_CHECK);
479 UT_TEST_CHECK_RET(!g_timerLoop1RunFlag, OSAL_TIMER_RUN_CHECK);
480 HDF_LOGI("[OSAL_UT_TEST]%s timer run end", __func__);
481 }
482
483 if (cnt == THREAD_TEST_TIMER_STOP) {
484 UT_TEST_CHECK_RET(g_timerOnceRunCnt != 1, OSAL_TIMER_STOP_CHECK);
485 UT_TEST_CHECK_RET(g_timerLoop2RunFlag, OSAL_TIMER_STOP_CHECK);
486 HDF_LOGI("[OSAL_UT_TEST]%s timer stop end", __func__);
487 }
488 if (cnt == THREAD_TEST_TIMER_STOP) {
489 OsalGetTime(&g_hdfTestEnd);
490 OsalDiffTime(&g_hdfTestBegin, &g_hdfTestEnd, &diffTime);
491 HDF_LOGI("[OSAL_UT_TEST]%s **** All case test end, use %ds****", __func__, (uint32_t)diffTime.sec);
492 HDF_LOGI("[OSAL_UT_TEST]%s ***************************", __func__);
493 }
494 }
495 static uint8_t g_irqData = 100;
IRQHandle(uint32_t irqId,void * data)496 static uint32_t IRQHandle(uint32_t irqId, void *data)
497 {
498 uint8_t *p = data;
499 static OsalTimespec hdfTs = { 0, 0 };
500 OsalTimespec hdfTs2 = { 0, 0 };
501 OsalTimespec hdfTsDiff = { 0, 0 };
502 if (p == NULL) {
503 HDF_LOGE("%s nul ptr", __func__);
504 return 1;
505 }
506
507 OsalGetTime(&hdfTs2);
508 OsalDiffTime(&hdfTs, &hdfTs2, &hdfTsDiff);
509
510 HDF_LOGE("%s IRQ handle, irqId:%u, data:%u, %ds %dus", __func__, irqId, *p,
511 (int32_t)(hdfTsDiff.sec), (int32_t)(hdfTsDiff.usec));
512 OsalGetTime(&hdfTs);
513
514 return 0;
515 }
516
517 #define IRQ_TEST_CNT 10
OsaIrqTest(void)518 static void OsaIrqTest(void)
519 {
520 int i = 0;
521 int32_t ret;
522 int32_t retFlag = HDF_FAILURE;
523 #if defined(__LITEOS__)
524 retFlag = HDF_SUCCESS;
525 #endif
526
527 HDF_LOGI("[OSAL_UT_TEST]%s start", __func__);
528 #if defined(__LITEOS__)
529 ret = OsalUnregisterIrq(IRQ_NUM_TEST, &g_irqData);
530 UT_TEST_CHECK_RET(ret == retFlag, OSAL_IRQ_UNREG_ABNORMAL);
531 #endif
532 ret = OsalRegisterIrq(IRQ_NUM_TEST, 0, IRQHandle, "test", &g_irqData);
533 UT_TEST_CHECK_RET(ret != retFlag, OSAL_IRQ_REG_NORMAL);
534 ret = OsalDisableIrq(IRQ_NUM_TEST);
535 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_IRQ_REG_NORMAL);
536 ret = OsalEnableIrq(IRQ_NUM_TEST);
537 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_IRQ_REG_NORMAL);
538 #if defined(__LITEOS__)
539 ret = OsalUnregisterIrq(IRQ_NUM_TEST, &g_irqData);
540 UT_TEST_CHECK_RET(ret != retFlag, OSAL_IRQ_UNREG_NORMAL);
541 #endif
542
543 ret = OsalDisableIrq(IRQ_NUM_TEST);
544 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_IRQ_REG_NORMAL);
545
546 ret = OsalEnableIrq(IRQ_NUM_TEST);
547 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_IRQ_REG_NORMAL);
548
549 #if defined(__LITEOS__)
550 ret = OsalUnregisterIrq(IRQ_NUM_TEST, &g_irqData);
551 UT_TEST_CHECK_RET(ret == retFlag, OSAL_IRQ_UNREG_ABNORMAL);
552 #endif
553
554 for (; i < IRQ_TEST_CNT; i++) {
555 ret = OsalRegisterIrq(IRQ_NUM_TEST, 0, IRQHandle, "test", &g_irqData);
556 UT_TEST_CHECK_RET(ret != retFlag, OSAL_IRQ_REG_NORMAL_STRESS);
557 ret = OsalDisableIrq(IRQ_NUM_TEST);
558 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_IRQ_REG_NORMAL_STRESS);
559 ret = OsalEnableIrq(IRQ_NUM_TEST);
560 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_IRQ_REG_NORMAL_STRESS);
561 #if defined(__LITEOS__)
562 ret = OsalUnregisterIrq(IRQ_NUM_TEST, &g_irqData);
563 UT_TEST_CHECK_RET(ret != retFlag, OSAL_IRQ_UNREG_NORMAL_STRESS);
564 #endif
565 }
566
567 HDF_LOGI("[OSAL_UT_TEST]%s end", __func__);
568 }
569
570 #define IRQ_TEST_REG 1
571 #define IRQ_TEST_ENABLE 10
572 #define IRQ_TEST_DISABLE 20
573 #define IRQ_TEST_UNREG 30
574 #define THREAD_TEST_STOP_TIMER 25
575 #define THREAD_TEST_STOP_TIMER_CHECK 45
576 #endif
577
578 #define THREAD_TEST_DBG_CTRL 200
579 #define THREAD_TEST_MUX_BEGIN 3
580 #define THREAD_TEST_MUX_END 5
581 #define THREAD_TEST_SLEEP_MS 1
582 static bool g_thread3RunFlag;
583 static bool g_threadTestFlag = true;
ThreadTest(void * arg)584 static int ThreadTest(void *arg)
585 {
586 static int cnt = 0;
587 HDF_STATUS ret;
588 HDF_LOGI("in threadTest %s %d", __func__, __LINE__);
589
590 g_thread3RunFlag = true;
591 (void)arg;
592
593 while (g_threadTestFlag) {
594 OsalSleep(THREAD_TEST_SLEEP_MS);
595
596 if (cnt < THREAD_TEST_DBG_CTRL && cnt % HDF_DBG_CNT_CTRL == 0) {
597 HDF_LOGI("in threadTest %d", cnt);
598 }
599 cnt++;
600
601 if (cnt == THREAD_TEST_MUX_BEGIN) {
602 HDF_LOGE("%s mutex Lock", __func__);
603 g_threadMuxLockFlag = true;
604 ret = OsalMutexTimedLock(&g_mutexTest, g_waitMutexTime);
605 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_MUTEX_STRESS_TEST);
606 }
607 if (cnt == THREAD_TEST_MUX_END) {
608 ret = OsalMutexUnlock(&g_mutexTest);
609 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_MUTEX_STRESS_TEST);
610 HDF_LOGE("%s mutex unLock", __func__);
611 g_threadMuxLockFlag = false;
612 }
613 #ifndef __USER__
614 if (cnt == THREAD_TEST_STOP_TIMER) {
615 OsaTimerTestStop();
616 }
617 OsaCheckRun(cnt);
618 #endif
619 if (g_testEndFlag) {
620 break;
621 }
622 }
623 HDF_LOGE("%s thread return\n", __func__);
624 return 0;
625 }
626
627 #define HDF_TEST_STACK_SIZE (1024 * 16) // 16KB
OsaThreadTest1(void)628 static void OsaThreadTest1(void)
629 {
630 struct OsalThreadParam threadCfg;
631 static int para = 120;
632 int32_t ret;
633
634 (void)memset_s(&threadCfg, sizeof(threadCfg), 0, sizeof(threadCfg));
635 threadCfg.name = "hdf_test0";
636 threadCfg.priority = OSAL_THREAD_PRI_HIGHEST;
637 threadCfg.stackSize = HDF_TEST_STACK_SIZE;
638 ret = OsalThreadCreate(&thread, (OsalThreadEntry)ThreadTest, (void *)¶);
639 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_THREAD_CREATE);
640 ret = OsalThreadStart(&thread, &threadCfg);
641 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_THREAD_CREATE);
642 }
643
644 #ifdef __USER__
645 #define HDF_TEST_POLICY_STACK_SIZE 0
OsaThreadSchedPolicyTest(void)646 static void OsaThreadSchedPolicyTest(void)
647 {
648 HDF_LOGE("[OSAL_UT_TEST]%{public}s start", __func__);
649
650 struct OsalThreadParam threadCfg1;
651 (void)memset_s(&threadCfg1, sizeof(threadCfg1), 0, sizeof(threadCfg1));
652 threadCfg1.name = "hdf_test3";
653 threadCfg1.priority = OSAL_THREAD_PRI_HIGH;
654 threadCfg1.stackSize = HDF_TEST_POLICY_STACK_SIZE;
655 threadCfg1.policy = SCHED_OTHER;
656 int ret = OsalThreadCreate(&thread3, (OsalThreadEntry)ThreadTest3, NULL);
657 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_THREAD_CREATE);
658 ret = OsalThreadStart(&thread3, &threadCfg1);
659 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_THREAD_CREATE);
660
661 struct OsalThreadParam threadCfg2;
662 (void)memset_s(&threadCfg2, sizeof(threadCfg2), 0, sizeof(threadCfg2));
663 threadCfg2.name = "hdf_test4";
664 threadCfg2.priority = OSAL_THREAD_PRI_HIGH;
665 threadCfg2.stackSize = HDF_TEST_POLICY_STACK_SIZE;
666 threadCfg2.policy = SCHED_FIFO;
667 ret = OsalThreadCreate(&thread4, (OsalThreadEntry)ThreadTest4, NULL);
668 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_THREAD_CREATE);
669 ret = OsalThreadStart(&thread4, &threadCfg2);
670 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_THREAD_CREATE);
671
672 struct OsalThreadParam threadCfg3;
673 (void)memset_s(&threadCfg3, sizeof(threadCfg3), 0, sizeof(threadCfg3));
674 threadCfg3.name = "hdf_test5";
675 threadCfg3.priority = OSAL_THREAD_PRI_HIGH;
676 threadCfg3.stackSize = HDF_TEST_POLICY_STACK_SIZE;
677 threadCfg3.policy = SCHED_RR;
678 ret = OsalThreadCreate(&thread5, (OsalThreadEntry)ThreadTest5, NULL);
679 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_THREAD_CREATE);
680 ret = OsalThreadStart(&thread5, &threadCfg3);
681 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_THREAD_CREATE);
682 }
683 #endif
684
OsaThreadTest(void)685 static void OsaThreadTest(void)
686 {
687 struct OsalThreadParam threadCfg;
688 int ret;
689
690 HDF_LOGI("[OSAL_UT_TEST]%s start", __func__);
691 ret = OsalMutexInit(&g_mutexTest);
692 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_MUTEX_CREATE);
693 ret = OsalSpinInit(&g_spinTest);
694 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_SPIN_CREATE);
695
696 (void)memset_s(&threadCfg, sizeof(threadCfg), 0, sizeof(threadCfg));
697 threadCfg.name = "hdf_test1";
698 threadCfg.priority = OSAL_THREAD_PRI_HIGH;
699 threadCfg.stackSize = HDF_TEST_STACK_SIZE;
700 ret = OsalThreadCreate(&thread1, (OsalThreadEntry)ThreadTest1, (void *)&g_test1Para);
701 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_THREAD_CREATE);
702 ret = OsalThreadStart(&thread1, &threadCfg);
703 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_THREAD_CREATE);
704
705 OsalMSleep(HDF_THREAD_TEST_SLEEP_S);
706
707 (void)memset_s(&threadCfg, sizeof(threadCfg), 0, sizeof(threadCfg));
708 threadCfg.name = "hdf_test2";
709 threadCfg.priority = OSAL_THREAD_PRI_DEFAULT;
710 threadCfg.stackSize = HDF_TEST_STACK_SIZE;
711 ret = OsalThreadCreate(&thread2, (OsalThreadEntry)ThreadTest2, (void *)&g_test2Para);
712 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_THREAD_CREATE);
713 ret = OsalThreadStart(&thread2, &threadCfg);
714 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_THREAD_CREATE);
715
716 OsaThreadTest1();
717 HDF_LOGI("[OSAL_UT_TEST]%s end", __func__);
718 }
719
720 #define TIME_TEST_SLEEP_S 2
721 #define TIME_TEST_SLEEP_MS 200
722 #define TIME_TEST_SLEEP_US 200
723 #define TIME_TEST_MS_RANGE_H 210
724 #define TIME_TEST_MS_RANGE_L 190
725 #define TIME_TEST_US_RANGE_H 1000
726 #define TIME_TEST_US_RANGE_L 200
OsaTimeTest(void)727 static void OsaTimeTest(void)
728 {
729 int32_t ret;
730 OsalTimespec hdfTs = { 0, 0 };
731 OsalTimespec hdfTs2 = { 0, 0 };
732 OsalTimespec hdfTsDiff = { 0, 0 };
733
734 OsalGetTime(&hdfTs);
735 OsalSleep(TIME_TEST_SLEEP_S);
736 ret = OsalGetTime(&hdfTs2);
737 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_TIME_GETTIME);
738 ret = OsalDiffTime(&hdfTs, &hdfTs2, &hdfTsDiff);
739 HDF_LOGE("%s %us %uus", __func__, (uint32_t)hdfTsDiff.sec, (uint32_t)hdfTsDiff.usec);
740 UT_TEST_CHECK_RET(!OsalCheckTime(&hdfTsDiff, TIME_TEST_SLEEP_S * HDF_KILO_UNIT), OSAL_TIME_DIFFTIME);
741
742 OsalGetTime(&hdfTs);
743 OsalUDelay(TIME_TEST_SLEEP_MS);
744 (void)OsalGetTime(&hdfTs2);
745 (void)OsalDiffTime(&hdfTs, &hdfTs2, &hdfTsDiff);
746 HDF_LOGE("%s %us %uus", __func__, (uint32_t)hdfTsDiff.sec, (uint32_t)hdfTsDiff.usec);
747
748 OsalGetTime(&hdfTs);
749 OsalMDelay(TIME_TEST_SLEEP_MS);
750 (void)OsalGetTime(&hdfTs2);
751 (void)OsalDiffTime(&hdfTs, &hdfTs2, &hdfTsDiff);
752 HDF_LOGE("%s %us %uus", __func__, (uint32_t)hdfTsDiff.sec, (uint32_t)hdfTsDiff.usec);
753
754 OsalGetTime(&hdfTs);
755 OsalMSleep(TIME_TEST_SLEEP_MS);
756 ret = OsalGetTime(&hdfTs2);
757 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_TIME_GETTIME);
758 ret = OsalDiffTime(&hdfTs, &hdfTs2, &hdfTsDiff);
759 HDF_LOGE("%s %us %uus", __func__, (uint32_t)hdfTsDiff.sec, (uint32_t)hdfTsDiff.usec);
760 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_TIME_DIFFTIME);
761 UT_TEST_CHECK_RET(!OsalCheckTime(&hdfTsDiff, TIME_TEST_SLEEP_MS), OSAL_TIME_DIFFTIME);
762 }
763 enum {
764 MEM_ALIGN_TEST_0 = 1,
765 MEM_ALIGN_TEST_1 = 2,
766 MEM_ALIGN_TEST_2 = 3,
767 MEM_ALIGN_TEST_3 = 4,
768 MEM_ALIGN_TEST_4 = 7,
769 MEM_ALIGN_TEST_5 = 8,
770 MEM_ALIGN_TEST_6 = 16,
771 };
772 #define MALLOC_TEST_CASE1_SIZE 0x4000
773 #define MALLOC_TEST_CASE2_SIZE 0x1FF
774 #define MALLOC_TEST_CNT 1000
OsaMemoryTest(void)775 static void OsaMemoryTest(void)
776 {
777 void *buf = NULL;
778 int i = 0;
779
780 HDF_LOGI("[OSAL_UT_TEST]%s start", __func__);
781 buf = OsalMemCalloc(MALLOC_TEST_CASE1_SIZE);
782 UT_TEST_CHECK_RET(buf == NULL, OSAL_MALLOC_BIG);
783 OsalMemFree(buf);
784
785 buf = OsalMemCalloc(MALLOC_TEST_CASE2_SIZE);
786 UT_TEST_CHECK_RET(buf == NULL, OSAL_MALLOC_SMALL);
787 OsalMemFree(buf);
788
789 buf = OsalMemAllocAlign(MEM_ALIGN_TEST_0, MALLOC_TEST_CASE1_SIZE);
790 UT_TEST_CHECK_RET(buf != NULL, OSAL_MALLOC_BIG);
791 OsalMemFree(buf);
792 buf = OsalMemAllocAlign(MEM_ALIGN_TEST_1, MALLOC_TEST_CASE1_SIZE);
793 UT_TEST_CHECK_RET(buf != NULL, OSAL_MALLOC_BIG);
794 OsalMemFree(buf);
795 buf = OsalMemAllocAlign(MEM_ALIGN_TEST_2, MALLOC_TEST_CASE1_SIZE);
796 UT_TEST_CHECK_RET(buf != NULL, OSAL_MALLOC_BIG);
797 OsalMemFree(buf);
798 buf = OsalMemAllocAlign(MEM_ALIGN_TEST_3, MALLOC_TEST_CASE1_SIZE);
799 if (sizeof(void *) == MEM_ALIGN_TEST_3) {
800 UT_TEST_CHECK_RET(buf == NULL, OSAL_MALLOC_BIG);
801 } else {
802 UT_TEST_CHECK_RET(buf != NULL, OSAL_MALLOC_BIG);
803 }
804 OsalMemFree(buf);
805 buf = OsalMemAllocAlign(MEM_ALIGN_TEST_4, MALLOC_TEST_CASE1_SIZE);
806 UT_TEST_CHECK_RET(buf != NULL, OSAL_MALLOC_BIG);
807 OsalMemFree(buf);
808 buf = OsalMemAllocAlign(MEM_ALIGN_TEST_5, MALLOC_TEST_CASE1_SIZE);
809 UT_TEST_CHECK_RET(buf == NULL, OSAL_MALLOC_BIG);
810 OsalMemFree(buf);
811 buf = OsalMemAllocAlign(MEM_ALIGN_TEST_6, MALLOC_TEST_CASE1_SIZE);
812 UT_TEST_CHECK_RET(buf == NULL, OSAL_MALLOC_BIG);
813 OsalMemFree(buf);
814
815 for (; i < MALLOC_TEST_CNT; i++) {
816 buf = OsalMemCalloc(MALLOC_TEST_CASE1_SIZE);
817 UT_TEST_CHECK_RET(buf == NULL, OSAL_MALLOC_BIG_STRESS);
818 OsalMemFree(buf);
819
820 buf = OsalMemCalloc(MALLOC_TEST_CASE2_SIZE);
821 UT_TEST_CHECK_RET(buf == NULL, OSAL_MALLOC_SMALL_STRESS);
822 OsalMemFree(buf);
823 }
824 HDF_LOGI("[OSAL_UT_TEST]%s end", __func__);
825 }
826
OsaLogTest(void)827 static void OsaLogTest(void)
828 {
829 HDF_LOGI("[OSAL_UT_TEST]%s start", __func__);
830 HDF_LOGE("{private}%{private}s %{private}d{private}", __func__, __LINE__);
831 HDF_LOGW("%{public}s %{public}d", __func__, __LINE__);
832 HDF_LOGI("%{public}s %{private}d", __func__, __LINE__);
833 HDF_LOGI("%{private}s %{public}d", __func__, __LINE__);
834 HDF_LOGD("%s", __func__);
835 HDF_LOGV("%s", __func__);
836 HDF_LOGI("[OSAL_UT_TEST]%{private}s end", __func__);
837 HDF_LOGI("[OSAL_UT_TEST]%s end", __func__);
838 }
839
OsaMutexTest(void)840 static void OsaMutexTest(void)
841 {
842 HDF_STATUS ret;
843 struct OsalMutex mutex;
844
845 HDF_LOGE("[OSAL_UT_TEST]%s start", __func__);
846
847 (void)memset_s(&mutex, sizeof(mutex), 0, sizeof(mutex));
848 ret = OsalMutexInit(&mutex);
849 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_MUTEX_CREATE);
850 ret = OsalMutexTimedLock(&mutex, OSAL_TEST_TIME_DEFAULT);
851 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_MUTEX_LOCK_TIMEOUT);
852 ret = OsalMutexUnlock(&mutex);
853 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_MUTEX_UNLOCK);
854 ret = OsalMutexLock(&mutex);
855 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_MUTEX_LOCK_FOREVER);
856 ret = OsalMutexUnlock(&mutex);
857 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_MUTEX_UNLOCK);
858 ret = OsalMutexDestroy(&mutex);
859 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_MUTEX_DESTROY);
860
861 HDF_LOGE("[OSAL_UT_TEST]%s test no init", __func__);
862 ret = OsalMutexTimedLock(&mutex, HDF_WAIT_FOREVER);
863 UT_TEST_CHECK_RET(ret == HDF_SUCCESS, OSAL_MUTEX_VISIT_DESTROY);
864 ret = OsalMutexUnlock(&mutex);
865 UT_TEST_CHECK_RET(ret == HDF_SUCCESS, OSAL_MUTEX_VISIT_DESTROY);
866 ret = OsalMutexDestroy(&mutex);
867 UT_TEST_CHECK_RET(ret == HDF_SUCCESS, OSAL_MUTEX_VISIT_DESTROY);
868
869 HDF_LOGI("[OSAL_UT_TEST]%s end", __func__);
870 }
871
OsaSpinTest(void)872 static void OsaSpinTest(void)
873 {
874 int32_t ret;
875 #ifndef __USER__
876 uint32_t flag = 0;
877 #endif
878 OSAL_DECLARE_SPINLOCK(spin);
879
880 HDF_LOGE("[OSAL_UT_TEST]%s start", __func__);
881 (void)memset_s(&spin, sizeof(spin), 0, sizeof(spin));
882 ret = OsalSpinInit(&spin);
883 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_SPIN_CREATE);
884
885 ret = OsalSpinLock(&spin);
886 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_SPIN_LOCK);
887 ret = OsalSpinUnlock(&spin);
888 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_SPIN_UNLOCK);
889 #ifndef __USER__
890 ret = OsalSpinLockIrq(&spin);
891 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_SPIN_LOCK_IRQ);
892 ret = OsalSpinUnlockIrq(&spin);
893 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_SPIN_UNLOCK_IRQ);
894
895 ret = OsalSpinLockIrqSave(&spin, &flag);
896 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_SPIN_LOCK_IRQ_SAVE);
897 ret = OsalSpinUnlockIrqRestore(&spin, &flag);
898 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_SPIN_UNLOCK_IRQ_RESTORE);
899 #endif
900 ret = OsalSpinDestroy(&spin);
901 UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_SPIN_DESTROY);
902
903 HDF_LOGE("[OSAL_UT_TEST]%s test no init", __func__);
904 ret = OsalSpinLock(&spin);
905 UT_TEST_CHECK_RET(ret == HDF_SUCCESS, OSAL_SPIN_LOCK_AFTER_DESTROY);
906 ret = OsalSpinUnlock(&spin);
907 UT_TEST_CHECK_RET(ret == HDF_SUCCESS, OSAL_SPIN_LOCK_AFTER_DESTROY);
908 ret = OsalSpinDestroy(&spin);
909 UT_TEST_CHECK_RET(ret == HDF_SUCCESS, OSAL_SPIN_LOCK_AFTER_DESTROY);
910
911 HDF_LOGI("[OSAL_UT_TEST]%s end", __func__);
912 }
913
OsaCheckThreadRun(void)914 static void OsaCheckThreadRun(void)
915 {
916 UT_TEST_CHECK_RET(!g_thread1RunFlag, OSAL_THREAD_RUN_CHECK);
917 UT_TEST_CHECK_RET(!g_thread2RunFlag, OSAL_THREAD_RUN_CHECK);
918 UT_TEST_CHECK_RET(!g_thread3RunFlag, OSAL_THREAD_RUN_CHECK);
919 HDF_LOGI("[OSAL_UT_TEST]%s end", __func__);
920 }
921
922 #define HDF_MAIN_SLEEP_S 20
OsaTestBegin(int32_t testFlag)923 int OsaTestBegin(int32_t testFlag)
924 {
925 int ret;
926 (void)memset_s(g_osalTestCases, sizeof(g_osalTestCases), 0, sizeof(g_osalTestCases));
927 g_testEndFlag = false;
928 #ifndef __USER__
929 g_timer1Cnt = 0;
930 g_timer2Cnt = 0;
931 #endif
932 OsalGetTime(&g_hdfTestBegin);
933 OsaLogTest();
934 #ifndef __USER__
935 ret = OsalTestFileInit();
936 if (testFlag != 0) {
937 ret = testFlag;
938 }
939 #else
940 ret = 0;
941 #endif
942 OsalTestOther(ret);
943 OsaTimeTest();
944 OsaMutexTest();
945 OsaSpinTest();
946 #ifndef __USER__
947 OsaIrqTest();
948 OsaTimerTest();
949 #endif
950 #ifdef __USER__
951 OsaThreadSchedPolicyTest();
952 #endif
953 OsaThreadTest();
954 OsaMemoryTest();
955 HDF_LOGD("%s ", __func__);
956 #ifndef __USER__
957 OsaFWTest(ret);
958 OsalTestFileDeInit();
959 #endif
960 OsalSleep(HDF_MAIN_SLEEP_S);
961 HDF_LOGI("%s", __func__);
962 OsaCheckThreadRun();
963
964 return 0;
965 }
966
OsaTestEnd(void)967 int OsaTestEnd(void)
968 {
969 #ifndef __USER__
970 OsalTimerDelete(&g_testTimerLoop1);
971 OsalTimerDelete(&g_testTimerLoop2);
972 OsalTimerDelete(&g_testTimerOnce);
973 OsalStopThread();
974 #endif
975 g_testEndFlag = true;
976 OsalThreadDestroy(&thread1);
977 OsalThreadDestroy(&thread);
978 OsalThreadDestroy(&thread2);
979 #ifdef __USER__
980 OsalThreadDestroy(&thread3);
981 OsalThreadDestroy(&thread4);
982 OsalThreadDestroy(&thread5);
983 #endif
984 HDF_LOGE("%s", __func__);
985
986 return 0;
987 }
988
OsaTestALLResult(void)989 int OsaTestALLResult(void)
990 {
991 int index;
992 for (index = 0; index < OSAL_TEST_CASE_CNT; index++) {
993 if (g_osalTestCases[index] != 0) {
994 HDF_LOGE("%s %d %d", __func__, g_osalTestCases[index], index);
995 return 1;
996 }
997 }
998 return 0;
999 }
1000
1001