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 "securec.h"
10 #include "hdf_log.h"
11 #include "hdf_workqueue.h"
12 #include "osal_atomic.h"
13 #include "osal_file.h"
14 #include "osal_case_cmd_test.h"
15 #include "osal_time.h"
16
17 #define HDF_LOG_TAG osal_lite
18
19 #define MSG_SEND_PERIOD 5
20 #define MSG_NOSEND_CNT 1
21 #define MSG_NOSEND_CHECK_CNT 2
22 #define MSG_EVENT_AGAIN 3
23 #define MSG_EVENT_AGAIN_CHECK 4
24
25 #define TEST_ITEM_HAVE_EVENT 0
26 #define TEST_ITEM_NO_EVENT 1
27 #define TEST_ITEM_HAVE_EVENT_TIMEOUT 2
28
29 #define OSAL_TEST_PERIOD 20
30 static bool g_osalWorkStatus = true;
31 static bool g_osalDelayStatus = true;
32 static HdfWork g_work;
33 static HdfWorkQueue g_workQue;
34
35 static HdfWork g_delayWork;
36 static uint32_t g_workPara = 1000;
37 static int g_delayTime = 100;
38 #define DELAY_TIME_DEFAULT 100
39 #define DELAY_TIME_FOR_OUT 10000
40
TestWorkEntry(void * para)41 static void TestWorkEntry(void *para)
42 {
43 static int cnt = 0;
44 if (para != NULL) {
45 if (cnt % DELAY_TIME_DEFAULT == 0) {
46 HDF_LOGE("%s %u", __func__, *(uint32_t *)para);
47 }
48 cnt++;
49 }
50 g_osalWorkStatus = false;
51 }
52
TestDelayWorkEntry(void * para)53 static void TestDelayWorkEntry(void *para)
54 {
55 static int cnt = 0;
56
57 if (para != NULL) {
58 if (cnt % DELAY_TIME_DEFAULT == 0) {
59 HDF_LOGE("%s %u", __func__, *(uint32_t *)para);
60 }
61 cnt++;
62 }
63
64 g_osalDelayStatus = false;
65 }
66
TestWorkInit(void)67 static void TestWorkInit(void)
68 {
69 HdfWorkQueueInit(&g_workQue, "osal_workQueue");
70
71 HdfWorkInit(&g_work, TestWorkEntry, (void *)&g_workPara);
72
73 HdfDelayedWorkInit(&g_delayWork, TestDelayWorkEntry, (void *)&g_workPara);
74 }
75
TestAddRoute(int cnt)76 void TestAddRoute(int cnt)
77 {
78 if (cnt % MSG_SEND_PERIOD == 0) {
79 g_osalWorkStatus = true;
80 HdfAddWork(&g_workQue, &g_work);
81 g_osalDelayStatus = true;
82 g_delayTime = DELAY_TIME_DEFAULT;
83 HdfAddDelayedWork(&g_workQue, &g_delayWork, g_delayTime);
84 } else if (cnt % MSG_SEND_PERIOD == TEST_ITEM_NO_EVENT) {
85 UT_TEST_CHECK_RET(g_osalWorkStatus, OSAL_WORK_RUN_CHECK);
86 UT_TEST_CHECK_RET(g_osalDelayStatus, OSAL_DELAY_WORK_RUN_CHECK);
87 } else if (cnt % MSG_SEND_PERIOD == MSG_NOSEND_CHECK_CNT) {
88 g_delayTime = DELAY_TIME_FOR_OUT;
89 g_osalDelayStatus = true;
90 HdfAddDelayedWork(&g_workQue, &g_delayWork, g_delayTime);
91 g_osalWorkStatus = true;
92 HdfAddWork(&g_workQue, &g_work);
93 HdfCancelWorkSync(&g_work);
94 } else if (cnt % MSG_SEND_PERIOD == MSG_EVENT_AGAIN) {
95 HdfCancelDelayedWorkSync(&g_delayWork);
96 } else if (cnt % MSG_SEND_PERIOD == MSG_EVENT_AGAIN_CHECK) {
97 UT_TEST_CHECK_RET(g_osalDelayStatus == false, OSAL_DELAY_WORK_RUN_CHECK);
98 }
99 }
100
101 #define ATOMIC_INC_VALUE 2
OsalTestAtomic(void)102 static void OsalTestAtomic(void)
103 {
104 OsalAtomic atomic;
105 unsigned long testBits = 0;
106 int32_t value;
107
108 HDF_LOGE("%s test begin", __func__);
109
110 OsalAtomicSet(&atomic, 1);
111 value = OsalAtomicRead(&atomic);
112 UT_TEST_CHECK_RET(value != 1, OSAL_ATOMIC_SET);
113 UT_TEST_CHECK_RET(value != 1, OSAL_ATOMIC_READ);
114 HDF_LOGE("%s %d %d", __func__, __LINE__, value);
115
116 OsalAtomicInc(&atomic);
117 value = OsalAtomicRead(&atomic);
118 UT_TEST_CHECK_RET(value != ATOMIC_INC_VALUE, OSAL_ATOMIC_INC);
119 UT_TEST_CHECK_RET(value != ATOMIC_INC_VALUE, OSAL_ATOMIC_READ);
120 HDF_LOGE("%s %d %d", __func__, __LINE__, value);
121
122 OsalAtomicDec(&atomic);
123 value = OsalAtomicRead(&atomic);
124 UT_TEST_CHECK_RET(value != 1, OSAL_ATOMIC_DEC);
125 UT_TEST_CHECK_RET(value != 1, OSAL_ATOMIC_READ);
126
127 HDF_LOGE("%s %d %d", __func__, __LINE__, value);
128 value = OsalTestBit(1, &testBits);
129 UT_TEST_CHECK_RET(value != 0, OSAL_TEST_BIT);
130 HDF_LOGE("%s %d %d", __func__, __LINE__, value);
131
132 value = OsalTestSetBit(1, &testBits);
133 UT_TEST_CHECK_RET(value != 0, OSAL_TEST_SET_BIT);
134 HDF_LOGE("%s %d %d", __func__, __LINE__, value);
135
136 value = OsalTestBit(1, &testBits);
137 UT_TEST_CHECK_RET(value != 1, OSAL_TEST_BIT);
138 HDF_LOGE("%s %d %d", __func__, __LINE__, value);
139
140 value = OsalTestClearBit(1, &testBits);
141 UT_TEST_CHECK_RET(value != 1, OSAL_TEST_CLR_BIT);
142 HDF_LOGE("%s %d %d", __func__, __LINE__, value);
143
144 value = OsalTestBit(1, &testBits);
145 UT_TEST_CHECK_RET(value != 0, OSAL_TEST_BIT);
146 HDF_LOGE("%s %d %d", __func__, __LINE__, value);
147
148 OsalClearBit(1, &testBits);
149 value = OsalTestBit(1, &testBits);
150 UT_TEST_CHECK_RET(value != 0, OSAL_CLR_BIT);
151
152 HDF_LOGE("%s %d %d", __func__, __LINE__, value);
153 }
154
155 #define TEST_FILE_WRITE_CHAR 0xfe
156 #define TEST_FILE_OFFSET 10
157 #define TEST_FILE_LEN 72
OsalTestFile(int flag)158 static void OsalTestFile(int flag)
159 {
160 OsalFile file;
161 char buf[TEST_FILE_LEN];
162 int32_t len;
163
164 HDF_LOGE("%s test begin", __func__);
165 if (flag != 0) {
166 HDF_LOGE("%s file do not exist %d", __func__, flag);
167 return;
168 }
169 (void)memset_s(buf, sizeof(buf), 0, sizeof(buf));
170 UT_TEST_CHECK_RET(OsalFileOpen(&file, TEST_FILE_PATH_NAME, OSAL_O_RD_ONLY, OSAL_S_IREAD) != HDF_SUCCESS,
171 OSAL_FILE_OPEN_RD);
172 len = OsalFileRead(&file, buf, sizeof(buf));
173 UT_TEST_CHECK_RET(len != TEST_FILE_LEN, OSAL_FILE_READ_RD);
174 HDF_LOGE("%s %d %d", __func__, __LINE__, len);
175 len = OsalFileLseek(&file, 0, 0);
176 UT_TEST_CHECK_RET(len == -1, OSAL_FILE_SEEK_RD);
177 (void)memset_s(buf, sizeof(buf), TEST_FILE_WRITE_CHAR, sizeof(buf));
178 len = OsalFileWrite(&file, buf, sizeof(buf));
179 UT_TEST_CHECK_RET(len != -1, OSAL_FILE_WRITE_RD);
180 HDF_LOGE("%s %d %d", __func__, __LINE__, len);
181 len = OsalFileLseek(&file, TEST_FILE_OFFSET, 0);
182 UT_TEST_CHECK_RET(len != TEST_FILE_OFFSET, OSAL_FILE_SEEK_RD);
183 len = OsalFileRead(&file, buf, sizeof(buf));
184 UT_TEST_CHECK_RET(len != (TEST_FILE_LEN - TEST_FILE_OFFSET), OSAL_FILE_READ_RD);
185 HDF_LOGE("%s %d %d", __func__, __LINE__, len);
186 OsalFileClose(&file);
187 len = OsalFileRead(&file, buf, sizeof(buf));
188 UT_TEST_CHECK_RET(len >= 0, OSAL_FILE_READ_RD);
189 HDF_LOGE("%s %d %d", __func__, __LINE__, len);
190
191 (void)memset_s(buf, sizeof(buf), 0, sizeof(buf));
192 UT_TEST_CHECK_RET(OsalFileOpen(&file, TEST_FILE_PATH_NAME, OSAL_O_RDWR, OSAL_S_IREAD) != HDF_SUCCESS,
193 OSAL_FILE_OPEN_RDWR);
194 len = OsalFileRead(&file, buf, sizeof(buf));
195 UT_TEST_CHECK_RET(len != TEST_FILE_LEN, OSAL_FILE_READ_RDWR);
196 HDF_LOGE("%s %d %d", __func__, __LINE__, len);
197 len = OsalFileLseek(&file, 0, 0);
198 UT_TEST_CHECK_RET(len == -1, OSAL_FILE_SEEK_RDWR);
199 (void)memset_s(buf, sizeof(buf), TEST_FILE_WRITE_CHAR, sizeof(buf));
200 len = OsalFileWrite(&file, buf, sizeof(buf));
201 UT_TEST_CHECK_RET(len == -1, OSAL_FILE_WRITE_RDWR);
202 HDF_LOGE("%s %d %d", __func__, __LINE__, len);
203 len = OsalFileLseek(&file, TEST_FILE_OFFSET, 0);
204 UT_TEST_CHECK_RET(len != TEST_FILE_OFFSET, OSAL_FILE_SEEK_RDWR);
205 len = OsalFileRead(&file, buf, sizeof(buf));
206 UT_TEST_CHECK_RET(len != (TEST_FILE_LEN - TEST_FILE_OFFSET), OSAL_FILE_READ_RDWR);
207 HDF_LOGE("%s %d %d", __func__, __LINE__, len);
208 OsalFileClose(&file);
209 }
210
OsalTestWork(int flag)211 void OsalTestWork(int flag)
212 {
213 TestWorkInit();
214 OsalTestAtomic();
215 OsalTestFile(flag);
216 }
217
OsalTestWorkEnd(void)218 void OsalTestWorkEnd(void)
219 {
220 HdfCancelWorkSync(&g_work);
221 HdfWorkDestroy(&g_work);
222 HdfCancelDelayedWorkSync(&g_delayWork);
223 HdfDelayedWorkDestroy(&g_delayWork);
224 HdfWorkQueueDestroy(&g_workQue);
225 }