1 /*
2 * Copyright (C) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "hks_cipher_test.h"
17
18 #include "hctest.h"
19 #include "iot_watchdog.h"
20 #include "hks_api.h"
21 #include "hks_param.h"
22 #include "hks_test_cipher.h"
23 #include "securec.h"
24 #include "cmsis_os2.h"
25 #include "ohos_types.h"
26
27 #define TEST_INDEX_0 0
28 #define TEST_INDEX_1 1
29 #define TEST_INDEX_2 2
30 #define TEST_INDEX_3 3
31 #define TEST_INDEX_4 4
32 #define TEST_TASK_STACK_SIZE 0x2000
33 #define WAIT_TO_TEST_DONE 4
34
35 static osPriority_t g_setPriority;
36
37 /*
38 * @tc.register: register a test suit named "CalcMultiTest"
39 * @param: test subsystem name
40 * @param: c_example module name
41 * @param: CalcMultiTest test suit name
42 */
43 LITE_TEST_SUIT(security, securityData, HksCipherTest);
44
ExecHksInitialize(void const * argument)45 static void ExecHksInitialize(void const *argument)
46 {
47 LiteTestPrint("HksInitialize Begin!\n");
48 TEST_ASSERT_TRUE(HksInitialize() == 0);
49 LiteTestPrint("HksInitialize End!\n");
50 osThreadExit();
51 }
52
53 /**
54 * @tc.setup: define a setup for test suit, format:"CalcMultiTest + SetUp"
55 * @return: true——setup success
56 */
HksCipherTestSetUp()57 static BOOL HksCipherTestSetUp()
58 {
59 LiteTestPrint("setup\n");
60 IoTWatchDogDisable();
61 osThreadId_t id;
62 osThreadAttr_t attr;
63 g_setPriority = osPriorityAboveNormal6;
64 attr.name = "test";
65 attr.attr_bits = 0U;
66 attr.cb_mem = NULL;
67 attr.cb_size = 0U;
68 attr.stack_mem = NULL;
69 attr.stack_size = TEST_TASK_STACK_SIZE;
70 attr.priority = g_setPriority;
71 id = osThreadNew((osThreadFunc_t)ExecHksInitialize, NULL, &attr);
72 sleep(WAIT_TO_TEST_DONE);
73 LiteTestPrint("HksCipherTestSetUp End2!\n");
74 return TRUE;
75 }
76
77 /**
78 * @tc.teardown: define a setup for test suit, format:"CalcMultiTest + TearDown"
79 * @return: true——teardown success
80 */
HksCipherTestTearDown()81 static BOOL HksCipherTestTearDown()
82 {
83 LiteTestPrint("tearDown\n");
84 IoTWatchDogEnable();
85 return TRUE;
86 }
87
ExecHksCipherTest001(void const * argument)88 static void ExecHksCipherTest001(void const *argument)
89 {
90 LiteTestPrint("HksCipherTest001 Begin!\n");
91 TEST_ASSERT_TRUE(BaseTestCipher(1, TEST_INDEX_0, 1) == 0);
92 LiteTestPrint("HksCipherTest001 End!\n");
93 osThreadExit();
94 }
95
ExecHksCipherTest002(void const * argument)96 static void ExecHksCipherTest002(void const *argument)
97 {
98 LiteTestPrint("HksCipherTest002 Begin!\n");
99 TEST_ASSERT_TRUE(BaseTestCipher(1, TEST_INDEX_0, 1) == 0);
100 LiteTestPrint("HksCipherTest002 End!\n");
101 osThreadExit();
102 }
103
ExecHksCipherTest003(void const * argument)104 static void ExecHksCipherTest003(void const *argument)
105 {
106 LiteTestPrint("HksCipherTest003 Begin!\n");
107 TEST_ASSERT_TRUE(BaseTestEncrypt(1, TEST_INDEX_0, 1) == 0);
108 LiteTestPrint("HksCipherTest003 End!\n");
109 osThreadExit();
110 }
111
ExecHksCipherTest004(void const * argument)112 static void ExecHksCipherTest004(void const *argument)
113 {
114 LiteTestPrint("HksCipherTest004 Begin!\n");
115 TEST_ASSERT_TRUE(BaseTestEncrypt(1, TEST_INDEX_1, 1) == 0);
116 LiteTestPrint("HksCipherTest004 End!\n");
117 osThreadExit();
118 }
119
ExecHksCipherTest005(void const * argument)120 static void ExecHksCipherTest005(void const *argument)
121 {
122 LiteTestPrint("HksCipherTest005 Begin!\n");
123 TEST_ASSERT_TRUE(BaseTestEncrypt(1, TEST_INDEX_2, 1) == 0);
124 LiteTestPrint("HksCipherTest005 End!\n");
125 osThreadExit();
126 }
127
ExecHksCipherTest006(void const * argument)128 static void ExecHksCipherTest006(void const *argument)
129 {
130 LiteTestPrint("HksCipherTest006 Begin!\n");
131 TEST_ASSERT_TRUE(BaseTestEncrypt(1, TEST_INDEX_3, 1) == 0);
132 LiteTestPrint("HksCipherTest006 End!\n");
133 osThreadExit();
134 }
135
ExecHksCipherTest007(void const * argument)136 static void ExecHksCipherTest007(void const *argument)
137 {
138 LiteTestPrint("HksCipherTest007 Begin!\n");
139 TEST_ASSERT_TRUE(BaseTestEncrypt(1, TEST_INDEX_4, 1) == 0);
140 LiteTestPrint("HksCipherTest007 End!\n");
141 osThreadExit();
142 }
143
ExecHksCipherTest008(void const * argument)144 static void ExecHksCipherTest008(void const *argument)
145 {
146 LiteTestPrint("HksCipherTest008 Begin!\n");
147 TEST_ASSERT_TRUE(BaseTestDecrypt(1, TEST_INDEX_0, 1) == 0);
148 LiteTestPrint("HksCipherTest008 End!\n");
149 osThreadExit();
150 }
151
ExecHksCipherTest009(void const * argument)152 static void ExecHksCipherTest009(void const *argument)
153 {
154 LiteTestPrint("HksCipherTest009 Begin!\n");
155 TEST_ASSERT_TRUE(BaseTestDecrypt(1, TEST_INDEX_1, 1) == 0);
156 LiteTestPrint("HksCipherTest009 End!\n");
157 osThreadExit();
158 }
159
ExecHksCipherTest010(void const * argument)160 static void ExecHksCipherTest010(void const *argument)
161 {
162 LiteTestPrint("HksCipherTest010 Begin!\n");
163 TEST_ASSERT_TRUE(BaseTestDecrypt(1, TEST_INDEX_2, 1) == 0);
164 LiteTestPrint("HksCipherTest010 End!\n");
165 osThreadExit();
166 }
167
ExecHksCipherTest011(void const * argument)168 static void ExecHksCipherTest011(void const *argument)
169 {
170 LiteTestPrint("HksCipherTest011 Begin!\n");
171 TEST_ASSERT_TRUE(BaseTestDecrypt(1, TEST_INDEX_3, 1) == 0);
172 LiteTestPrint("HksCipherTest011 End!\n");
173 osThreadExit();
174 }
175
ExecHksCipherTest012(void const * argument)176 static void ExecHksCipherTest012(void const *argument)
177 {
178 LiteTestPrint("HksCipherTest012 Begin!\n");
179 TEST_ASSERT_TRUE(BaseTestDecrypt(1, TEST_INDEX_4, 1) == 0);
180 LiteTestPrint("HksCipherTest012 End!\n");
181 osThreadExit();
182 }
183
184
185 /**
186 * @tc.name: HksCipherTest.HksCipherTest001
187 * @tc.desc: The static function will return true;
188 * @tc.type: FUNC
189 */
LITE_TEST_CASE(HksCipherTest,HksCipherTest001,Level1)190 LITE_TEST_CASE(HksCipherTest, HksCipherTest001, Level1)
191 {
192 osThreadId_t id;
193 osThreadAttr_t attr;
194 g_setPriority = osPriorityAboveNormal6;
195 attr.name = "test";
196 attr.attr_bits = 0U;
197 attr.cb_mem = NULL;
198 attr.cb_size = 0U;
199 attr.stack_mem = NULL;
200 attr.stack_size = TEST_TASK_STACK_SIZE;
201 attr.priority = g_setPriority;
202 id = osThreadNew((osThreadFunc_t)ExecHksCipherTest001, NULL, &attr);
203 sleep(WAIT_TO_TEST_DONE);
204 LiteTestPrint("HksCipherTest001 End2!\n");
205 }
206
207 #ifndef _CUT_AUTHENTICATE_
208
LITE_TEST_CASE(HksCipherTest,HksCipherTest002,Level1)209 LITE_TEST_CASE(HksCipherTest, HksCipherTest002, Level1)
210 {
211 osThreadId_t id;
212 osThreadAttr_t attr;
213 g_setPriority = osPriorityAboveNormal6;
214 attr.name = "test";
215 attr.attr_bits = 0U;
216 attr.cb_mem = NULL;
217 attr.cb_size = 0U;
218 attr.stack_mem = NULL;
219 attr.stack_size = TEST_TASK_STACK_SIZE;
220 attr.priority = g_setPriority;
221 id = osThreadNew((osThreadFunc_t)ExecHksCipherTest002, NULL, &attr);
222 sleep(WAIT_TO_TEST_DONE);
223 LiteTestPrint("HksCipherTest002 End2!\n");
224
225 }
226
LITE_TEST_CASE(HksCipherTest,HksCipherTest003,Level1)227 LITE_TEST_CASE(HksCipherTest, HksCipherTest003, Level1)
228 {
229 osThreadId_t id;
230 osThreadAttr_t attr;
231 g_setPriority = osPriorityAboveNormal6;
232 attr.name = "test";
233 attr.attr_bits = 0U;
234 attr.cb_mem = NULL;
235 attr.cb_size = 0U;
236 attr.stack_mem = NULL;
237 attr.stack_size = TEST_TASK_STACK_SIZE;
238 attr.priority = g_setPriority;
239 id = osThreadNew((osThreadFunc_t)ExecHksCipherTest003, NULL, &attr);
240 sleep(WAIT_TO_TEST_DONE);
241 LiteTestPrint("HksCipherTest003 End2!\n");
242 }
243
LITE_TEST_CASE(HksCipherTest,HksCipherTest004,Level1)244 LITE_TEST_CASE(HksCipherTest, HksCipherTest004, Level1)
245 {
246 osThreadId_t id;
247 osThreadAttr_t attr;
248 g_setPriority = osPriorityAboveNormal6;
249 attr.name = "test";
250 attr.attr_bits = 0U;
251 attr.cb_mem = NULL;
252 attr.cb_size = 0U;
253 attr.stack_mem = NULL;
254 attr.stack_size = TEST_TASK_STACK_SIZE;
255 attr.priority = g_setPriority;
256 id = osThreadNew((osThreadFunc_t)ExecHksCipherTest004, NULL, &attr);
257 sleep(WAIT_TO_TEST_DONE);
258 LiteTestPrint("HksCipherTest004 End2!\n");
259 }
260
LITE_TEST_CASE(HksCipherTest,HksCipherTest005,Level1)261 LITE_TEST_CASE(HksCipherTest, HksCipherTest005, Level1)
262 {
263 osThreadId_t id;
264 osThreadAttr_t attr;
265 g_setPriority = osPriorityAboveNormal6;
266 attr.name = "test";
267 attr.attr_bits = 0U;
268 attr.cb_mem = NULL;
269 attr.cb_size = 0U;
270 attr.stack_mem = NULL;
271 attr.stack_size = TEST_TASK_STACK_SIZE;
272 attr.priority = g_setPriority;
273 id = osThreadNew((osThreadFunc_t)ExecHksCipherTest005, NULL, &attr);
274 sleep(WAIT_TO_TEST_DONE);
275 LiteTestPrint("HksCipherTest005 End2!\n");
276 }
277
LITE_TEST_CASE(HksCipherTest,HksCipherTest006,Level1)278 LITE_TEST_CASE(HksCipherTest, HksCipherTest006, Level1)
279 {
280 osThreadId_t id;
281 osThreadAttr_t attr;
282 g_setPriority = osPriorityAboveNormal6;
283 attr.name = "test";
284 attr.attr_bits = 0U;
285 attr.cb_mem = NULL;
286 attr.cb_size = 0U;
287 attr.stack_mem = NULL;
288 attr.stack_size = TEST_TASK_STACK_SIZE;
289 attr.priority = g_setPriority;
290 id = osThreadNew((osThreadFunc_t)ExecHksCipherTest006, NULL, &attr);
291 sleep(WAIT_TO_TEST_DONE);
292 LiteTestPrint("HksCipherTest006 End2!\n");
293 }
294
LITE_TEST_CASE(HksCipherTest,HksCipherTest007,Level1)295 LITE_TEST_CASE(HksCipherTest, HksCipherTest007, Level1)
296 {
297 osThreadId_t id;
298 osThreadAttr_t attr;
299 g_setPriority = osPriorityAboveNormal6;
300 attr.name = "test";
301 attr.attr_bits = 0U;
302 attr.cb_mem = NULL;
303 attr.cb_size = 0U;
304 attr.stack_mem = NULL;
305 attr.stack_size = TEST_TASK_STACK_SIZE;
306 attr.priority = g_setPriority;
307 id = osThreadNew((osThreadFunc_t)ExecHksCipherTest007, NULL, &attr);
308 sleep(WAIT_TO_TEST_DONE);
309 LiteTestPrint("HksCipherTest007 End2!\n");
310 }
311
LITE_TEST_CASE(HksCipherTest,HksCipherTest008,Level1)312 LITE_TEST_CASE(HksCipherTest, HksCipherTest008, Level1)
313 {
314 osThreadId_t id;
315 osThreadAttr_t attr;
316 g_setPriority = osPriorityAboveNormal6;
317 attr.name = "test";
318 attr.attr_bits = 0U;
319 attr.cb_mem = NULL;
320 attr.cb_size = 0U;
321 attr.stack_mem = NULL;
322 attr.stack_size = TEST_TASK_STACK_SIZE;
323 attr.priority = g_setPriority;
324 id = osThreadNew((osThreadFunc_t)ExecHksCipherTest008, NULL, &attr);
325 sleep(WAIT_TO_TEST_DONE);
326 LiteTestPrint("HksCipherTest008 End2!\n");
327 }
328
LITE_TEST_CASE(HksCipherTest,HksCipherTest009,Level1)329 LITE_TEST_CASE(HksCipherTest, HksCipherTest009, Level1)
330 {
331 osThreadId_t id;
332 osThreadAttr_t attr;
333 g_setPriority = osPriorityAboveNormal6;
334 attr.name = "test";
335 attr.attr_bits = 0U;
336 attr.cb_mem = NULL;
337 attr.cb_size = 0U;
338 attr.stack_mem = NULL;
339 attr.stack_size = TEST_TASK_STACK_SIZE;
340 attr.priority = g_setPriority;
341 id = osThreadNew((osThreadFunc_t)ExecHksCipherTest009, NULL, &attr);
342 sleep(WAIT_TO_TEST_DONE);
343 LiteTestPrint("HksCipherTest009 End2!\n");
344 }
345
LITE_TEST_CASE(HksCipherTest,HksCipherTest010,Level1)346 LITE_TEST_CASE(HksCipherTest, HksCipherTest010, Level1)
347 {
348 osThreadId_t id;
349 osThreadAttr_t attr;
350 g_setPriority = osPriorityAboveNormal6;
351 attr.name = "test";
352 attr.attr_bits = 0U;
353 attr.cb_mem = NULL;
354 attr.cb_size = 0U;
355 attr.stack_mem = NULL;
356 attr.stack_size = TEST_TASK_STACK_SIZE;
357 attr.priority = g_setPriority;
358 id = osThreadNew((osThreadFunc_t)ExecHksCipherTest010, NULL, &attr);
359 sleep(WAIT_TO_TEST_DONE);
360 LiteTestPrint("HksCipherTest010 End2!\n");
361 }
362
LITE_TEST_CASE(HksCipherTest,HksCipherTest011,Level1)363 LITE_TEST_CASE(HksCipherTest, HksCipherTest011, Level1)
364 {
365 osThreadId_t id;
366 osThreadAttr_t attr;
367 g_setPriority = osPriorityAboveNormal6;
368 attr.name = "test";
369 attr.attr_bits = 0U;
370 attr.cb_mem = NULL;
371 attr.cb_size = 0U;
372 attr.stack_mem = NULL;
373 attr.stack_size = TEST_TASK_STACK_SIZE;
374 attr.priority = g_setPriority;
375 id = osThreadNew((osThreadFunc_t)ExecHksCipherTest011, NULL, &attr);
376 sleep(WAIT_TO_TEST_DONE);
377 LiteTestPrint("HksCipherTest011 End2!\n");
378 }
379
LITE_TEST_CASE(HksCipherTest,HksCipherTest012,Level1)380 LITE_TEST_CASE(HksCipherTest, HksCipherTest012, Level1)
381 {
382 osThreadId_t id;
383 osThreadAttr_t attr;
384 g_setPriority = osPriorityAboveNormal6;
385 attr.name = "test";
386 attr.attr_bits = 0U;
387 attr.cb_mem = NULL;
388 attr.cb_size = 0U;
389 attr.stack_mem = NULL;
390 attr.stack_size = TEST_TASK_STACK_SIZE;
391 attr.priority = g_setPriority;
392 id = osThreadNew((osThreadFunc_t)ExecHksCipherTest012, NULL, &attr);
393 sleep(WAIT_TO_TEST_DONE);
394 LiteTestPrint("HksCipherTest012 End2!\n");
395 }
396 #endif /* _CUT_AUTHENTICATE_ */
397
398 RUN_TEST_SUITE(HksCipherTest);
399