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 DestroyPakeAuthParams(params);
341 DestroyTokenManager();
342 }
343
344 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest108, TestSize.Level0)
345 {
346 PakeAuthParams *params = nullptr;
347 CJson *in = nullptr;
348 InitTokenManager();
349 int32_t ret = ExtractPakePeerId(params, in);
350 EXPECT_NE(ret, 0);
351 DestroyTokenManager();
352 }
353
354 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest109, TestSize.Level0)
355 {
356 PakeAuthParams params;
357 CJson *in = nullptr;
358 InitTokenManager();
359 int32_t ret = ExtractPakePeerId(¶ms, in);
360 EXPECT_NE(ret, 0);
361 DestroyPakeAuthParams(¶ms);
362 DestroyTokenManager();
363 }
364
365 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest110, TestSize.Level0)
366 {
367 PakeAuthParams params;
368 CJson *in = CreateJson();
369 InitTokenManager();
370 int32_t ret = ExtractPakePeerId(¶ms, in);
371 EXPECT_NE(ret, 0);
372 FreeJson(in);
373 DestroyPakeAuthParams(¶ms);
374 DestroyTokenManager();
375 }
376
377 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest111, TestSize.Level0)
378 {
379 PakeAuthParams *params = nullptr;
380 InitTokenManager();
381 int32_t ret = ExtractPakeSelfId(params);
382 EXPECT_NE(ret, 0);
383 DestroyTokenManager();
384 }
385
386 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest112, TestSize.Level0)
387 {
388 PakeAuthParams params;
389 InitTokenManager();
390 int32_t ret = ExtractPakeSelfId(¶ms);
391 EXPECT_NE(ret, 0);
392 DestroyPakeAuthParams(¶ms);
393 DestroyTokenManager();
394 }
395
396 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest113, TestSize.Level0)
397 {
398 PakeAuthParams *params = nullptr;
399 CJson *in = nullptr;
400 InitTokenManager();
401 int32_t ret = ExtractPeerDeviceId(params, in);
402 EXPECT_NE(ret, 0);
403 DestroyTokenManager();
404 }
405
406 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest114, TestSize.Level0)
407 {
408 PakeAuthParams params;
409 CJson *in = nullptr;
410 InitTokenManager();
411 int32_t ret = ExtractPeerDeviceId(¶ms, in);
412 EXPECT_NE(ret, 0);
413 DestroyPakeAuthParams(¶ms);
414 DestroyTokenManager();
415 }
416
417 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest115, TestSize.Level0)
418 {
419 PakeAuthParams params;
420 CJson *in = CreateJson();
421 InitTokenManager();
422 int32_t ret = ExtractPeerDeviceId(¶ms, in);
423 EXPECT_NE(ret, 0);
424 ret = AddStringToJson(in, FIELD_DEVICE_ID, "device_id_unit_test");
425 EXPECT_EQ(ret, 0);
426 ret = ExtractPeerDeviceId(¶ms, in);
427 EXPECT_EQ(ret, 0);
428 FreeJson(in);
429 DestroyPakeAuthParams(¶ms);
430 DestroyTokenManager();
431 }
432
433 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest116, TestSize.Level0)
434 {
435 PakeAuthParams *params = nullptr;
436 CJson *in = nullptr;
437 InitTokenManager();
438 int32_t ret = ExtractPeerDevId(params, in);
439 EXPECT_NE(ret, 0);
440 DestroyTokenManager();
441 }
442
443 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest117, TestSize.Level0)
444 {
445 PakeAuthParams params;
446 CJson *in = nullptr;
447 InitTokenManager();
448 int32_t ret = ExtractPeerDevId(¶ms, in);
449 EXPECT_NE(ret, 0);
450 DestroyPakeAuthParams(¶ms);
451 DestroyTokenManager();
452 }
453
454 HWTEST_F(PakeV2AuthTaskCommonTest, PakeV2AuthTaskCommonTest118, TestSize.Level0)
455 {
456 PakeAuthParams params;
457 CJson *in = CreateJson();
458 InitTokenManager();
459 int32_t ret = ExtractPeerDevId(¶ms, in);
460 EXPECT_NE(ret, 0);
461 ret = AddStringToJson(in, FIELD_DEV_ID, "dev_id_unit_test");
462 EXPECT_EQ(ret, 0);
463 ret = ExtractPeerDevId(¶ms, in);
464 EXPECT_EQ(ret, 0);
465 FreeJson(in);
466 DestroyPakeAuthParams(¶ms);
467 DestroyTokenManager();
468 }
469
470 // Ending for pake_v2_auth_task_common.c test.
471 } // NAMESPACE