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