1 /*
2 * Copyright (C) 2021-2022 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 "pake_v2_auth_task_test.h"
17 #include <cinttypes>
18 #include <unistd.h>
19 #include <gtest/gtest.h>
20
21 using namespace std;
22 using namespace testing::ext;
23
24 namespace {
25 // Beginning for pake_v2_auth_client_task.c test.
26 class PakeV2AuthClientTaskTest : public testing::Test {
27 public:
28 static void SetUpTestCase();
29 static void TearDownTestCase();
30 void SetUp();
31 void TearDown();
32 };
33
SetUpTestCase()34 void PakeV2AuthClientTaskTest::SetUpTestCase() {}
35
TearDownTestCase()36 void PakeV2AuthClientTaskTest::TearDownTestCase() {}
37
SetUp()38 void PakeV2AuthClientTaskTest::SetUp() {}
39
TearDown()40 void PakeV2AuthClientTaskTest::TearDown() {}
41
42 HWTEST_F(PakeV2AuthClientTaskTest, PakeV2AuthClientTaskTest001, TestSize.Level0)
43 {
44 CJson *in = nullptr;
45 CJson *out = nullptr;
46 AccountVersionInfo *verInfo = nullptr;
47 TaskBase *retPtr = CreatePakeV2AuthClientTask(in, out, verInfo);
48 EXPECT_EQ(retPtr, nullptr);
49 }
50
51 HWTEST_F(PakeV2AuthClientTaskTest, PakeV2AuthClientTaskTest002, TestSize.Level0)
52 {
53 CJson *in = CreateJson();
54 CJson *out = nullptr;
55 AccountVersionInfo *verInfo = nullptr;
56 TaskBase *retPtr = CreatePakeV2AuthClientTask(in, out, verInfo);
57 EXPECT_EQ(retPtr, nullptr);
58 FreeJson(in);
59 }
60
61 HWTEST_F(PakeV2AuthClientTaskTest, PakeV2AuthClientTaskTest003, TestSize.Level0)
62 {
63 CJson *in = CreateJson();
64 CJson *out = CreateJson();
65 AccountVersionInfo *verInfo = nullptr;
66 TaskBase *retPtr = CreatePakeV2AuthClientTask(in, out, verInfo);
67 EXPECT_EQ(retPtr, nullptr);
68 FreeJson(in);
69 FreeJson(out);
70 }
71
72 HWTEST_F(PakeV2AuthClientTaskTest, PakeV2AuthClientTaskTest004, TestSize.Level0)
73 {
74 CJson *in = CreateJson();
75 CJson *out = CreateJson();
76 AccountVersionInfo verInfo;
77 TaskBase *retPtr = CreatePakeV2AuthClientTask(in, out, &verInfo);
78 EXPECT_EQ(retPtr, nullptr);
79 FreeJson(in);
80 FreeJson(out);
81 }
82 // Ending for pake_v2_auth_client_task.c test.
83
84 // Beginning for pake_v2_auth_server_task.c test.
85 class PakeV2AuthServerTaskTest : public testing::Test {
86 public:
87 static void SetUpTestCase();
88 static void TearDownTestCase();
89 void SetUp();
90 void TearDown();
91 };
92
SetUpTestCase()93 void PakeV2AuthServerTaskTest::SetUpTestCase() {}
94
TearDownTestCase()95 void PakeV2AuthServerTaskTest::TearDownTestCase() {}
96
SetUp()97 void PakeV2AuthServerTaskTest::SetUp() {}
98
TearDown()99 void PakeV2AuthServerTaskTest::TearDown() {}
100
101 HWTEST_F(PakeV2AuthServerTaskTest, PakeV2AuthServerTaskTest001, TestSize.Level0)
102 {
103 CJson *in = nullptr;
104 CJson *out = nullptr;
105 AccountVersionInfo *verInfo = nullptr;
106 TaskBase *retPtr = CreatePakeV2AuthServerTask(in, out, verInfo);
107 EXPECT_EQ(retPtr, nullptr);
108 }
109
110 HWTEST_F(PakeV2AuthServerTaskTest, PakeV2AuthServerTaskTest002, TestSize.Level0)
111 {
112 CJson *in = CreateJson();
113 CJson *out = nullptr;
114 AccountVersionInfo *verInfo = nullptr;
115 TaskBase *retPtr = CreatePakeV2AuthServerTask(in, out, verInfo);
116 EXPECT_EQ(retPtr, nullptr);
117 FreeJson(in);
118 }
119
120 HWTEST_F(PakeV2AuthServerTaskTest, PakeV2AuthServerTaskTest003, TestSize.Level0)
121 {
122 CJson *in = CreateJson();
123 CJson *out = CreateJson();
124 AccountVersionInfo *verInfo = nullptr;
125 TaskBase *retPtr = CreatePakeV2AuthServerTask(in, out, verInfo);
126 EXPECT_EQ(retPtr, nullptr);
127 FreeJson(in);
128 FreeJson(out);
129 }
130
131 HWTEST_F(PakeV2AuthServerTaskTest, PakeV2AuthServerTaskTest004, TestSize.Level0)
132 {
133 CJson *in = CreateJson();
134 CJson *out = CreateJson();
135 AccountVersionInfo verInfo;
136 TaskBase *retPtr = CreatePakeV2AuthServerTask(in, out, &verInfo);
137 EXPECT_EQ(retPtr, nullptr);
138 FreeJson(in);
139 FreeJson(out);
140 }
141 // Ending for pake_v2_auth_server_task.c test.
142
143 // Beginning for pake_v2_auth_task_common.c test.
144 class PakeV2AuthTaskCommonTest : public testing::Test {
145 public:
146 static void SetUpTestCase();
147 static void TearDownTestCase();
148 void SetUp();
149 void TearDown();
150 };
151
SetUpTestCase()152 void PakeV2AuthTaskCommonTest::SetUpTestCase() {}
153
TearDownTestCase()154 void PakeV2AuthTaskCommonTest::TearDownTestCase() {}
155
SetUp()156 void PakeV2AuthTaskCommonTest::SetUp() {}
157
TearDown()158 void PakeV2AuthTaskCommonTest::TearDown() {}
159
160 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest001, TestSize.Level0)
161 {
162 CJson *in = nullptr;
163 PakeAuthParams *params = nullptr;
164 AccountVersionInfo *verInfo = nullptr;
165 int32_t ret = InitPakeAuthParams(in, params, verInfo);
166 EXPECT_NE(ret, 0);
167 }
168
169 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest002, TestSize.Level0)
170 {
171 CJson *in = CreateJson();
172 PakeAuthParams *params = nullptr;
173 AccountVersionInfo *verInfo = nullptr;
174 int32_t ret = InitPakeAuthParams(in, params, verInfo);
175 EXPECT_NE(ret, 0);
176 FreeJson(in);
177 }
178
179 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest003, TestSize.Level0)
180 {
181 CJson *in = CreateJson();
182 PakeAuthParams params;
183 AccountVersionInfo *verInfo = nullptr;
184 int32_t ret = InitPakeAuthParams(in, ¶ms, verInfo);
185 EXPECT_NE(ret, 0);
186 FreeJson(in);
187 }
188
189 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest004, TestSize.Level0)
190 {
191 CJson *in = CreateJson();
192 PakeAuthParams params;
193 AccountVersionInfo verInfo;
194 int32_t ret = InitPakeAuthParams(in, ¶ms, &verInfo);
195 EXPECT_NE(ret, 0);
196 FreeJson(in);
197 }
198
199 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest005, TestSize.Level0)
200 {
201 CJson *in = CreateJson();
202 PakeAuthParams params;
203 AccountVersionInfo verInfo;
204 int32_t ret = AddStringToJson(in, FIELD_SELF_DEVICE_ID, "device_id_unit_test");
205 EXPECT_EQ(ret, 0);
206 ret = InitPakeAuthParams(in, ¶ms, &verInfo);
207 EXPECT_NE(ret, 0);
208 FreeJson(in);
209 }
210
211 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest006, TestSize.Level0)
212 {
213 CJson *in = CreateJson();
214 PakeAuthParams params;
215 AccountVersionInfo verInfo;
216 int32_t ret = AddStringToJson(in, FIELD_SELF_DEVICE_ID, "device_id_unit_test");
217 EXPECT_EQ(ret, 0);
218 ret = AddIntToJson(in, FIELD_OS_ACCOUNT_ID, 0);
219 EXPECT_EQ(ret, 0);
220 ret = InitPakeAuthParams(in, ¶ms, &verInfo);
221 EXPECT_NE(ret, 0);
222 FreeJson(in);
223 DestroyPakeAuthParams(¶ms);
224 }
225
226 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest007, TestSize.Level0)
227 {
228 CJson *in = CreateJson();
229 PakeAuthParams params;
230 AccountVersionInfo verInfo;
231 int32_t ret = AddStringToJson(in, FIELD_SELF_DEVICE_ID, "device_id_unit_test");
232 EXPECT_EQ(ret, 0);
233 ret = AddIntToJson(in, FIELD_OS_ACCOUNT_ID, 0);
234 EXPECT_EQ(ret, 0);
235 ret = AddStringToJson(in, FIELD_SELF_USER_ID, "self_user_id_unit_test");
236 EXPECT_EQ(ret, 0);
237 ret = InitPakeAuthParams(in, ¶ms, &verInfo);
238 EXPECT_NE(ret, 0);
239 FreeJson(in);
240 DestroyPakeAuthParams(¶ms);
241 }
242
243 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest008, TestSize.Level0)
244 {
245 CJson *in = CreateJson();
246 PakeAuthParams params;
247 AccountVersionInfo verInfo;
248 int32_t ret = AddStringToJson(in, FIELD_SELF_DEVICE_ID, "device_id_unit_test");
249 EXPECT_EQ(ret, 0);
250 ret = AddIntToJson(in, FIELD_OS_ACCOUNT_ID, 0);
251 EXPECT_EQ(ret, 0);
252 ret = AddStringToJson(in, FIELD_SELF_USER_ID, "self_user_id_unit_test");
253 EXPECT_EQ(ret, 0);
254 ret = AddBoolToJson(in, FIELD_IS_CLIENT, true);
255 EXPECT_EQ(ret, 0);
256 ret = InitPakeAuthParams(in, ¶ms, &verInfo);
257 EXPECT_NE(ret, 0);
258 FreeJson(in);
259 DestroyPakeAuthParams(¶ms);
260 }
261
262 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest100, TestSize.Level0)
263 {
264 bool ret = IsPakeV2AuthTaskSupported();
265 EXPECT_EQ(ret, true);
266 }
267
268 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest101, TestSize.Level0)
269 {
270 CJson *in = nullptr;
271 CJson *out = nullptr;
272 AccountVersionInfo *verInfo = nullptr;
273 TaskBase *retPtr = CreatePakeV2AuthTask(in, out, verInfo);
274 EXPECT_EQ(retPtr, nullptr);
275 }
276
277 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest102, TestSize.Level0)
278 {
279 CJson *in = CreateJson();
280 int32_t ret = AddBoolToJson(in, FIELD_IS_CLIENT, true);
281 EXPECT_EQ(ret, 0);
282 CJson *out = nullptr;
283 AccountVersionInfo *verInfo = nullptr;
284 TaskBase *retPtr = CreatePakeV2AuthTask(in, out, verInfo);
285 EXPECT_EQ(retPtr, nullptr);
286 FreeJson(in);
287 }
288
289 // This test is blocked by no token.
290 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest103, TestSize.Level0)
291 {
292 PakeAuthParams params;
293 InitTokenManager();
294 int32_t ret = VerifyPkSignPeer(¶ms);
295 EXPECT_NE(ret, 0);
296 DestroyTokenManager();
297 }
298
299 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest104, TestSize.Level0)
300 {
301 PakeAuthParams params;
302 InitTokenManager();
303 int32_t ret = GenerateEcdhSharedKey(¶ms);
304 EXPECT_NE(ret, 0);
305 DestroyTokenManager();
306 }
307
308 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest105, TestSize.Level0)
309 {
310 PakeAuthParams *params = nullptr;
311 CJson *in = nullptr;
312 InitTokenManager();
313 int32_t ret = GetPkInfoPeer(params, in);
314 EXPECT_NE(ret, 0);
315 DestroyTokenManager();
316 }
317
318 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest106, TestSize.Level0)
319 {
320 PakeAuthParams params;
321 CJson *in = nullptr;
322 InitTokenManager();
323 int32_t ret = GetPkInfoPeer(¶ms, in);
324 EXPECT_NE(ret, 0);
325 in = CreateJson();
326 ret = GetPkInfoPeer(¶ms, in);
327 EXPECT_NE(ret, 0);
328 ret = AddStringToJson(in, FIELD_AUTH_PK_INFO, "auth_pk_info");
329 ret = GetPkInfoPeer(¶ms, in);
330 EXPECT_NE(ret, 0);
331 FreeJson(in);
332 DestroyPakeAuthParams(¶ms);
333 DestroyTokenManager();
334 }
335
336 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest107, TestSize.Level0)
337 {
338 PakeAuthParams *params = nullptr;
339 InitTokenManager();
340 CJson *in = CreateJson();
341 int32_t ret = AddStringToJson(in, FIELD_AUTH_PK_INFO, "auth_pk_info");
342 DestroyPakeAuthParams(params);
343 DestroyTokenManager();
344 FreeJson(in);
345 EXPECT_EQ(ret, HC_SUCCESS);
346 }
347
348 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest108, TestSize.Level0)
349 {
350 PakeAuthParams *params = nullptr;
351 CJson *in = nullptr;
352 InitTokenManager();
353 int32_t ret = ExtractPakePeerId(params, in);
354 EXPECT_NE(ret, 0);
355 DestroyTokenManager();
356 }
357
358 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest109, TestSize.Level0)
359 {
360 PakeAuthParams params;
361 CJson *in = nullptr;
362 InitTokenManager();
363 int32_t ret = ExtractPakePeerId(¶ms, in);
364 EXPECT_NE(ret, 0);
365 DestroyPakeAuthParams(¶ms);
366 DestroyTokenManager();
367 }
368
369 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest110, TestSize.Level0)
370 {
371 PakeAuthParams params;
372 CJson *in = CreateJson();
373 InitTokenManager();
374 int32_t ret = ExtractPakePeerId(¶ms, in);
375 EXPECT_NE(ret, 0);
376 FreeJson(in);
377 DestroyPakeAuthParams(¶ms);
378 DestroyTokenManager();
379 }
380
381 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest111, TestSize.Level0)
382 {
383 PakeAuthParams *params = nullptr;
384 InitTokenManager();
385 int32_t ret = ExtractPakeSelfId(params);
386 EXPECT_NE(ret, 0);
387 DestroyTokenManager();
388 }
389
390 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest112, TestSize.Level0)
391 {
392 PakeAuthParams params;
393 InitTokenManager();
394 int32_t ret = ExtractPakeSelfId(¶ms);
395 EXPECT_NE(ret, 0);
396 DestroyPakeAuthParams(¶ms);
397 DestroyTokenManager();
398 }
399
400 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest113, TestSize.Level0)
401 {
402 PakeAuthParams *params = nullptr;
403 CJson *in = nullptr;
404 InitTokenManager();
405 int32_t ret = ExtractPeerDeviceId(params, in);
406 EXPECT_NE(ret, 0);
407 DestroyTokenManager();
408 }
409
410 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest114, TestSize.Level0)
411 {
412 PakeAuthParams params;
413 CJson *in = nullptr;
414 InitTokenManager();
415 int32_t ret = ExtractPeerDeviceId(¶ms, in);
416 EXPECT_NE(ret, 0);
417 DestroyPakeAuthParams(¶ms);
418 DestroyTokenManager();
419 }
420
421 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest115, TestSize.Level0)
422 {
423 PakeAuthParams params;
424 CJson *in = CreateJson();
425 InitTokenManager();
426 int32_t ret = ExtractPeerDeviceId(¶ms, in);
427 EXPECT_NE(ret, 0);
428 ret = AddStringToJson(in, FIELD_DEVICE_ID, "device_id_unit_test");
429 EXPECT_EQ(ret, 0);
430 ret = ExtractPeerDeviceId(¶ms, in);
431 EXPECT_EQ(ret, 0);
432 FreeJson(in);
433 DestroyPakeAuthParams(¶ms);
434 DestroyTokenManager();
435 }
436
437 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest116, TestSize.Level0)
438 {
439 PakeAuthParams *params = nullptr;
440 CJson *in = nullptr;
441 InitTokenManager();
442 int32_t ret = ExtractPeerDevId(params, in);
443 EXPECT_NE(ret, 0);
444 DestroyTokenManager();
445 }
446
447 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest117, TestSize.Level0)
448 {
449 PakeAuthParams params;
450 CJson *in = nullptr;
451 InitTokenManager();
452 int32_t ret = ExtractPeerDevId(¶ms, in);
453 EXPECT_NE(ret, 0);
454 DestroyPakeAuthParams(¶ms);
455 DestroyTokenManager();
456 }
457
458 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest118, TestSize.Level0)
459 {
460 PakeAuthParams params;
461 CJson *in = CreateJson();
462 InitTokenManager();
463 int32_t ret = ExtractPeerDevId(¶ms, in);
464 EXPECT_NE(ret, 0);
465 ret = AddStringToJson(in, FIELD_DEV_ID, "dev_id_unit_test");
466 EXPECT_EQ(ret, 0);
467 ret = ExtractPeerDevId(¶ms, in);
468 EXPECT_EQ(ret, 0);
469 FreeJson(in);
470 DestroyPakeAuthParams(¶ms);
471 DestroyTokenManager();
472 }
473
474 // Ending for pake_v2_auth_task_common.c test.
475 } // NAMESPACE