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
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 #include <unistd.h>
28 #define TEST_INDEX_0 0
29 #define TEST_INDEX_1 1
30 #define TEST_INDEX_2 2
31 #define TEST_INDEX_3 3
32 #define TEST_INDEX_4 4
33 #define TEST_TASK_STACK_SIZE 0x2000
34 #define WAIT_TO_TEST_DONE 4
35
36 static osPriority_t g_setPriority;
37
38 /*
39 * @tc.register: register a test suit named "CalcMultiTest"
40 * @param: test subsystem name
41 * @param: c_example module name
42 * @param: CalcMultiTest test suit name
43 */
44 LITE_TEST_SUIT(security, securityData, HksCipherTest);
45
ExecHksInitialize(void const * argument)46 static void ExecHksInitialize(void const *argument)
47 {
48 LiteTestPrint("HksInitialize Begin!\n");
49 TEST_ASSERT_TRUE(HksInitialize() == 0);
50 LiteTestPrint("HksInitialize End!\n");
51 osThreadExit();
52 }
53
54 /**
55 * @tc.setup: define a setup for test suit, format:"CalcMultiTest + SetUp"
56 * @return: true——setup success
57 */
HksCipherTestSetUp()58 static BOOL HksCipherTestSetUp()
59 {
60 LiteTestPrint("setup\n");
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 return TRUE;
85 }
86
ExecHksCipherTest001(void const * argument)87 static void ExecHksCipherTest001(void const *argument)
88 {
89 LiteTestPrint("HksCipherTest001 Begin!\n");
90 TEST_ASSERT_TRUE(BaseTestCipher(1, TEST_INDEX_0, 1) == 0);
91 LiteTestPrint("HksCipherTest001 End!\n");
92 osThreadExit();
93 }
94
ExecHksCipherTest002(void const * argument)95 static void ExecHksCipherTest002(void const *argument)
96 {
97 LiteTestPrint("HksCipherTest002 Begin!\n");
98 TEST_ASSERT_TRUE(BaseTestCipher(1, TEST_INDEX_0, 1) == 0);
99 LiteTestPrint("HksCipherTest002 End!\n");
100 osThreadExit();
101 }
102
ExecHksCipherTest003(void const * argument)103 static void ExecHksCipherTest003(void const *argument)
104 {
105 LiteTestPrint("HksCipherTest003 Begin!\n");
106 TEST_ASSERT_TRUE(BaseTestEncrypt(1, TEST_INDEX_0, 1) == 0);
107 LiteTestPrint("HksCipherTest003 End!\n");
108 osThreadExit();
109 }
110
ExecHksCipherTest004(void const * argument)111 static void ExecHksCipherTest004(void const *argument)
112 {
113 LiteTestPrint("HksCipherTest004 Begin!\n");
114 TEST_ASSERT_TRUE(BaseTestEncrypt(1, TEST_INDEX_1, 1) == 0);
115 LiteTestPrint("HksCipherTest004 End!\n");
116 osThreadExit();
117 }
118
ExecHksCipherTest005(void const * argument)119 static void ExecHksCipherTest005(void const *argument)
120 {
121 LiteTestPrint("HksCipherTest005 Begin!\n");
122 TEST_ASSERT_TRUE(BaseTestEncrypt(1, TEST_INDEX_2, 1) == 0);
123 LiteTestPrint("HksCipherTest005 End!\n");
124 osThreadExit();
125 }
126
ExecHksCipherTest006(void const * argument)127 static void ExecHksCipherTest006(void const *argument)
128 {
129 LiteTestPrint("HksCipherTest006 Begin!\n");
130 TEST_ASSERT_TRUE(BaseTestEncrypt(1, TEST_INDEX_3, 1) == 0);
131 LiteTestPrint("HksCipherTest006 End!\n");
132 osThreadExit();
133 }
134
ExecHksCipherTest007(void const * argument)135 static void ExecHksCipherTest007(void const *argument)
136 {
137 LiteTestPrint("HksCipherTest007 Begin!\n");
138 TEST_ASSERT_TRUE(BaseTestEncrypt(1, TEST_INDEX_4, 1) == 0);
139 LiteTestPrint("HksCipherTest007 End!\n");
140 osThreadExit();
141 }
142
ExecHksCipherTest008(void const * argument)143 static void ExecHksCipherTest008(void const *argument)
144 {
145 LiteTestPrint("HksCipherTest008 Begin!\n");
146 TEST_ASSERT_TRUE(BaseTestDecrypt(1, TEST_INDEX_0, 1) == 0);
147 LiteTestPrint("HksCipherTest008 End!\n");
148 osThreadExit();
149 }
150
ExecHksCipherTest009(void const * argument)151 static void ExecHksCipherTest009(void const *argument)
152 {
153 LiteTestPrint("HksCipherTest009 Begin!\n");
154 TEST_ASSERT_TRUE(BaseTestDecrypt(1, TEST_INDEX_1, 1) == 0);
155 LiteTestPrint("HksCipherTest009 End!\n");
156 osThreadExit();
157 }
158
ExecHksCipherTest010(void const * argument)159 static void ExecHksCipherTest010(void const *argument)
160 {
161 LiteTestPrint("HksCipherTest010 Begin!\n");
162 TEST_ASSERT_TRUE(BaseTestDecrypt(1, TEST_INDEX_2, 1) == 0);
163 LiteTestPrint("HksCipherTest010 End!\n");
164 osThreadExit();
165 }
166
ExecHksCipherTest011(void const * argument)167 static void ExecHksCipherTest011(void const *argument)
168 {
169 LiteTestPrint("HksCipherTest011 Begin!\n");
170 TEST_ASSERT_TRUE(BaseTestDecrypt(1, TEST_INDEX_3, 1) == 0);
171 LiteTestPrint("HksCipherTest011 End!\n");
172 osThreadExit();
173 }
174
ExecHksCipherTest012(void const * argument)175 static void ExecHksCipherTest012(void const *argument)
176 {
177 LiteTestPrint("HksCipherTest012 Begin!\n");
178 TEST_ASSERT_TRUE(BaseTestDecrypt(1, TEST_INDEX_4, 1) == 0);
179 LiteTestPrint("HksCipherTest012 End!\n");
180 osThreadExit();
181 }
182
183
184 /**
185 * @tc.name: HksCipherTest.HksCipherTest001
186 * @tc.desc: The static function will return true;
187 * @tc.type: FUNC
188 */
LITE_TEST_CASE(HksCipherTest,HksCipherTest001,Level1)189 LITE_TEST_CASE(HksCipherTest, HksCipherTest001, Level1)
190 {
191 osThreadId_t id;
192 osThreadAttr_t attr;
193 g_setPriority = osPriorityAboveNormal6;
194 attr.name = "test";
195 attr.attr_bits = 0U;
196 attr.cb_mem = NULL;
197 attr.cb_size = 0U;
198 attr.stack_mem = NULL;
199 attr.stack_size = TEST_TASK_STACK_SIZE;
200 attr.priority = g_setPriority;
201 id = osThreadNew((osThreadFunc_t)ExecHksCipherTest001, NULL, &attr);
202 sleep(WAIT_TO_TEST_DONE);
203 LiteTestPrint("HksCipherTest001 End2!\n");
204 }
205
206 #ifndef _CUT_AUTHENTICATE_
207
LITE_TEST_CASE(HksCipherTest,HksCipherTest002,Level1)208 LITE_TEST_CASE(HksCipherTest, HksCipherTest002, Level1)
209 {
210 osThreadId_t id;
211 osThreadAttr_t attr;
212 g_setPriority = osPriorityAboveNormal6;
213 attr.name = "test";
214 attr.attr_bits = 0U;
215 attr.cb_mem = NULL;
216 attr.cb_size = 0U;
217 attr.stack_mem = NULL;
218 attr.stack_size = TEST_TASK_STACK_SIZE;
219 attr.priority = g_setPriority;
220 id = osThreadNew((osThreadFunc_t)ExecHksCipherTest002, NULL, &attr);
221 sleep(WAIT_TO_TEST_DONE);
222 LiteTestPrint("HksCipherTest002 End2!\n");
223
224 }
225
LITE_TEST_CASE(HksCipherTest,HksCipherTest003,Level1)226 LITE_TEST_CASE(HksCipherTest, HksCipherTest003, Level1)
227 {
228 osThreadId_t id;
229 osThreadAttr_t attr;
230 g_setPriority = osPriorityAboveNormal6;
231 attr.name = "test";
232 attr.attr_bits = 0U;
233 attr.cb_mem = NULL;
234 attr.cb_size = 0U;
235 attr.stack_mem = NULL;
236 attr.stack_size = TEST_TASK_STACK_SIZE;
237 attr.priority = g_setPriority;
238 id = osThreadNew((osThreadFunc_t)ExecHksCipherTest003, NULL, &attr);
239 sleep(WAIT_TO_TEST_DONE);
240 LiteTestPrint("HksCipherTest003 End2!\n");
241 }
242
LITE_TEST_CASE(HksCipherTest,HksCipherTest004,Level1)243 LITE_TEST_CASE(HksCipherTest, HksCipherTest004, Level1)
244 {
245 osThreadId_t id;
246 osThreadAttr_t attr;
247 g_setPriority = osPriorityAboveNormal6;
248 attr.name = "test";
249 attr.attr_bits = 0U;
250 attr.cb_mem = NULL;
251 attr.cb_size = 0U;
252 attr.stack_mem = NULL;
253 attr.stack_size = TEST_TASK_STACK_SIZE;
254 attr.priority = g_setPriority;
255 id = osThreadNew((osThreadFunc_t)ExecHksCipherTest004, NULL, &attr);
256 sleep(WAIT_TO_TEST_DONE);
257 LiteTestPrint("HksCipherTest004 End2!\n");
258 }
259
LITE_TEST_CASE(HksCipherTest,HksCipherTest005,Level1)260 LITE_TEST_CASE(HksCipherTest, HksCipherTest005, Level1)
261 {
262 osThreadId_t id;
263 osThreadAttr_t attr;
264 g_setPriority = osPriorityAboveNormal6;
265 attr.name = "test";
266 attr.attr_bits = 0U;
267 attr.cb_mem = NULL;
268 attr.cb_size = 0U;
269 attr.stack_mem = NULL;
270 attr.stack_size = TEST_TASK_STACK_SIZE;
271 attr.priority = g_setPriority;
272 id = osThreadNew((osThreadFunc_t)ExecHksCipherTest005, NULL, &attr);
273 sleep(WAIT_TO_TEST_DONE);
274 LiteTestPrint("HksCipherTest005 End2!\n");
275 }
276
LITE_TEST_CASE(HksCipherTest,HksCipherTest006,Level1)277 LITE_TEST_CASE(HksCipherTest, HksCipherTest006, Level1)
278 {
279 osThreadId_t id;
280 osThreadAttr_t attr;
281 g_setPriority = osPriorityAboveNormal6;
282 attr.name = "test";
283 attr.attr_bits = 0U;
284 attr.cb_mem = NULL;
285 attr.cb_size = 0U;
286 attr.stack_mem = NULL;
287 attr.stack_size = TEST_TASK_STACK_SIZE;
288 attr.priority = g_setPriority;
289 id = osThreadNew((osThreadFunc_t)ExecHksCipherTest006, NULL, &attr);
290 sleep(WAIT_TO_TEST_DONE);
291 LiteTestPrint("HksCipherTest006 End2!\n");
292 }
293
LITE_TEST_CASE(HksCipherTest,HksCipherTest007,Level1)294 LITE_TEST_CASE(HksCipherTest, HksCipherTest007, Level1)
295 {
296 osThreadId_t id;
297 osThreadAttr_t attr;
298 g_setPriority = osPriorityAboveNormal6;
299 attr.name = "test";
300 attr.attr_bits = 0U;
301 attr.cb_mem = NULL;
302 attr.cb_size = 0U;
303 attr.stack_mem = NULL;
304 attr.stack_size = TEST_TASK_STACK_SIZE;
305 attr.priority = g_setPriority;
306 id = osThreadNew((osThreadFunc_t)ExecHksCipherTest007, NULL, &attr);
307 sleep(WAIT_TO_TEST_DONE);
308 LiteTestPrint("HksCipherTest007 End2!\n");
309 }
310
LITE_TEST_CASE(HksCipherTest,HksCipherTest008,Level1)311 LITE_TEST_CASE(HksCipherTest, HksCipherTest008, Level1)
312 {
313 osThreadId_t id;
314 osThreadAttr_t attr;
315 g_setPriority = osPriorityAboveNormal6;
316 attr.name = "test";
317 attr.attr_bits = 0U;
318 attr.cb_mem = NULL;
319 attr.cb_size = 0U;
320 attr.stack_mem = NULL;
321 attr.stack_size = TEST_TASK_STACK_SIZE;
322 attr.priority = g_setPriority;
323 id = osThreadNew((osThreadFunc_t)ExecHksCipherTest008, NULL, &attr);
324 sleep(WAIT_TO_TEST_DONE);
325 LiteTestPrint("HksCipherTest008 End2!\n");
326 }
327
LITE_TEST_CASE(HksCipherTest,HksCipherTest009,Level1)328 LITE_TEST_CASE(HksCipherTest, HksCipherTest009, Level1)
329 {
330 osThreadId_t id;
331 osThreadAttr_t attr;
332 g_setPriority = osPriorityAboveNormal6;
333 attr.name = "test";
334 attr.attr_bits = 0U;
335 attr.cb_mem = NULL;
336 attr.cb_size = 0U;
337 attr.stack_mem = NULL;
338 attr.stack_size = TEST_TASK_STACK_SIZE;
339 attr.priority = g_setPriority;
340 id = osThreadNew((osThreadFunc_t)ExecHksCipherTest009, NULL, &attr);
341 sleep(WAIT_TO_TEST_DONE);
342 LiteTestPrint("HksCipherTest009 End2!\n");
343 }
344
LITE_TEST_CASE(HksCipherTest,HksCipherTest010,Level1)345 LITE_TEST_CASE(HksCipherTest, HksCipherTest010, Level1)
346 {
347 osThreadId_t id;
348 osThreadAttr_t attr;
349 g_setPriority = osPriorityAboveNormal6;
350 attr.name = "test";
351 attr.attr_bits = 0U;
352 attr.cb_mem = NULL;
353 attr.cb_size = 0U;
354 attr.stack_mem = NULL;
355 attr.stack_size = TEST_TASK_STACK_SIZE;
356 attr.priority = g_setPriority;
357 id = osThreadNew((osThreadFunc_t)ExecHksCipherTest010, NULL, &attr);
358 sleep(WAIT_TO_TEST_DONE);
359 LiteTestPrint("HksCipherTest010 End2!\n");
360 }
361
LITE_TEST_CASE(HksCipherTest,HksCipherTest011,Level1)362 LITE_TEST_CASE(HksCipherTest, HksCipherTest011, Level1)
363 {
364 osThreadId_t id;
365 osThreadAttr_t attr;
366 g_setPriority = osPriorityAboveNormal6;
367 attr.name = "test";
368 attr.attr_bits = 0U;
369 attr.cb_mem = NULL;
370 attr.cb_size = 0U;
371 attr.stack_mem = NULL;
372 attr.stack_size = TEST_TASK_STACK_SIZE;
373 attr.priority = g_setPriority;
374 id = osThreadNew((osThreadFunc_t)ExecHksCipherTest011, NULL, &attr);
375 sleep(WAIT_TO_TEST_DONE);
376 LiteTestPrint("HksCipherTest011 End2!\n");
377 }
378
LITE_TEST_CASE(HksCipherTest,HksCipherTest012,Level1)379 LITE_TEST_CASE(HksCipherTest, HksCipherTest012, Level1)
380 {
381 osThreadId_t id;
382 osThreadAttr_t attr;
383 g_setPriority = osPriorityAboveNormal6;
384 attr.name = "test";
385 attr.attr_bits = 0U;
386 attr.cb_mem = NULL;
387 attr.cb_size = 0U;
388 attr.stack_mem = NULL;
389 attr.stack_size = TEST_TASK_STACK_SIZE;
390 attr.priority = g_setPriority;
391 id = osThreadNew((osThreadFunc_t)ExecHksCipherTest012, NULL, &attr);
392 sleep(WAIT_TO_TEST_DONE);
393 LiteTestPrint("HksCipherTest012 End2!\n");
394 }
395 #endif /* _CUT_AUTHENTICATE_ */
396
397 RUN_TEST_SUITE(HksCipherTest);
398