1 /*
2 * Copyright (c) 2024-2025 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 <cstdint>
17 #include <cstdlib>
18 #include <cstring>
19 #include <fcntl.h>
20
21 #include "gtest/gtest.h"
22 #include <gmock/gmock-actions.h>
23
24 #include "lnn_ohos_account_adapter.h"
25 #include "lnn_ohos_account_adapter_mock.h"
26 #include "softbus_adapter_mem.h"
27 #include "softbus_error_code.h"
28 #include "softbus_utils.h"
29
30 using namespace std;
31 using namespace testing::ext;
32
33 namespace OHOS::SoftBus {
34 #define DEFAULT_ACCOUNT_NAME "ohosAnonymousName"
35
36 constexpr char LNN_OHOS_ACCOUNT_ADAPTER_TEST_ID_LEN = 10;
37
38 class LnnOhosAccountAdapterTest : public testing::Test {
39 protected:
40 static void SetUpTestCase(void);
41 static void TearDownTestCase(void);
42 void SetUp();
43 void TearDown();
44 };
SetUpTestCase(void)45 void LnnOhosAccountAdapterTest::SetUpTestCase(void) { }
TearDownTestCase(void)46 void LnnOhosAccountAdapterTest::TearDownTestCase(void) { }
SetUp(void)47 void LnnOhosAccountAdapterTest::SetUp(void) { }
TearDown(void)48 void LnnOhosAccountAdapterTest::TearDown(void) { }
49
50 /**
51 * @tc.name: GetOsAccountId_001
52 * @tc.desc: GetOsAccountId
53 * @tc.type: FUN
54 * @tc.require: 1
55 */
56 HWTEST_F(LnnOhosAccountAdapterTest, GetOsAccountId_001, TestSize.Level1)
57 {
58 uint32_t len = 0;
59 char *accountInfo = (char *)SoftBusCalloc(LNN_OHOS_ACCOUNT_ADAPTER_TEST_ID_LEN * HEXIFY_UNIT_LEN);
60 ASSERT_NE(accountInfo, nullptr);
61 EXPECT_EQ(GetOsAccountId(nullptr, LNN_OHOS_ACCOUNT_ADAPTER_TEST_ID_LEN, &len), SOFTBUS_INVALID_PARAM);
62 EXPECT_EQ(GetOsAccountId(accountInfo, 0, &len), SOFTBUS_INVALID_PARAM);
63 EXPECT_EQ(GetOsAccountId(accountInfo, LNN_OHOS_ACCOUNT_ADAPTER_TEST_ID_LEN, nullptr), SOFTBUS_INVALID_PARAM);
64 if (accountInfo != nullptr) {
65 SoftBusFree(accountInfo);
66 }
67 }
68
69 /**
70 * @tc.name: GetOsAccountId_002
71 * @tc.desc: GetOsAccountId
72 * @tc.type: FUN
73 * @tc.require: 1
74 */
75 HWTEST_F(LnnOhosAccountAdapterTest, GetOsAccountId_002, TestSize.Level1)
76 {
77 uint32_t len = 0;
78 char *accountInfo = (char *)SoftBusCalloc(LNN_OHOS_ACCOUNT_ADAPTER_TEST_ID_LEN * HEXIFY_UNIT_LEN);
79 ASSERT_NE(accountInfo, nullptr);
80 AccountSA::OhosAccountKitsMock mock;
81 EXPECT_CALL(mock, IsSameAccountGroupDevice()).Times(1).WillOnce(testing::Return(false));
82 EXPECT_EQ(GetOsAccountId(accountInfo, LNN_OHOS_ACCOUNT_ADAPTER_TEST_ID_LEN, &len), SOFTBUS_AUTH_INNER_ERR);
83 if (accountInfo != nullptr) {
84 SoftBusFree(accountInfo);
85 }
86 }
87
88 /**
89 * @tc.name: GetOsAccountId_003
90 * @tc.desc: GetOsAccountId
91 * @tc.type: FUN
92 * @tc.require: 1
93 */
94 HWTEST_F(LnnOhosAccountAdapterTest, GetOsAccountId_003, TestSize.Level1)
95 {
96 char *accountInfo = (char *)SoftBusCalloc(LNN_OHOS_ACCOUNT_ADAPTER_TEST_ID_LEN * HEXIFY_UNIT_LEN);
97 ASSERT_NE(accountInfo, nullptr);
98 uint32_t len = 0;
99 OHOS::AccountSA::OhosAccountInfo oh_acc_info;
100 std::pair<bool, OHOS::AccountSA::OhosAccountInfo> oh_acc_info_pair = { false, oh_acc_info };
101 AccountSA::OhosAccountKitsMock mock;
102 EXPECT_CALL(mock, IsSameAccountGroupDevice()).Times(1).WillOnce(testing::Return(true));
103 EXPECT_CALL(mock, QueryOhosAccountInfo()).Times(1).WillOnce(testing::Return(oh_acc_info_pair));
104 EXPECT_EQ(GetOsAccountId(accountInfo, LNN_OHOS_ACCOUNT_ADAPTER_TEST_ID_LEN, &len),
105 SOFTBUS_NETWORK_GET_ACCOUNT_INFO_FAILED);
106 if (accountInfo != nullptr) {
107 SoftBusFree(accountInfo);
108 }
109 }
110
111 /**
112 * @tc.name: GetOsAccountId_004
113 * @tc.desc: GetOsAccountId
114 * @tc.type: FUN
115 * @tc.require: 1
116 */
117 HWTEST_F(LnnOhosAccountAdapterTest, GetOsAccountId_004, TestSize.Level1)
118 {
119 char *accountInfo = (char *)SoftBusCalloc(LNN_OHOS_ACCOUNT_ADAPTER_TEST_ID_LEN * HEXIFY_UNIT_LEN);
120 ASSERT_NE(accountInfo, nullptr);
121 uint32_t len = 0;
122 OHOS::AccountSA::OhosAccountInfo oh_acc_info;
123 oh_acc_info.name_ = "";
124 std::pair<bool, OHOS::AccountSA::OhosAccountInfo> oh_acc_info_pair = { true, oh_acc_info };
125 OHOS::AccountSA::OhosAccountKitsMock mock;
126 EXPECT_CALL(mock, IsSameAccountGroupDevice()).Times(1).WillOnce(testing::Return(true));
127 EXPECT_CALL(mock, QueryOhosAccountInfo()).Times(1).WillOnce(testing::Return(oh_acc_info_pair));
128 EXPECT_EQ(GetOsAccountId(accountInfo, LNN_OHOS_ACCOUNT_ADAPTER_TEST_ID_LEN, &len),
129 SOFTBUS_NETWORK_GET_ACCOUNT_INFO_FAILED);
130
131 if (accountInfo != nullptr) {
132 SoftBusFree(accountInfo);
133 }
134 }
135
136 /**
137 * @tc.name: GetCurrentAccount_001
138 * @tc.desc: GetCurrentAccount
139 * @tc.type: FUN
140 * @tc.require: 1
141 */
142 HWTEST_F(LnnOhosAccountAdapterTest, GetCurrentAccount_001, TestSize.Level1)
143 {
144 int64_t account = 10;
145 EXPECT_EQ(GetCurrentAccount(nullptr), SOFTBUS_INVALID_PARAM);
146 OHOS::AccountSA::OhosAccountKitsMock mock;
147 EXPECT_CALL(mock, IsSameAccountGroupDevice()).Times(1).WillOnce(testing::Return(false));
148 EXPECT_EQ(GetCurrentAccount(&account), SOFTBUS_AUTH_INNER_ERR);
149 }
150
151 /**
152 * @tc.name: GetCurrentAccount_002
153 * @tc.desc: GetCurrentAccount
154 * @tc.type: FUN
155 * @tc.require: 1
156 */
157 HWTEST_F(LnnOhosAccountAdapterTest, GetCurrentAccount_002, TestSize.Level1)
158 {
159 int64_t account = 10;
160 OHOS::AccountSA::OhosAccountInfo oh_acc_info;
161 std::pair<bool, OHOS::AccountSA::OhosAccountInfo> oh_acc_info_pair = { false, oh_acc_info };
162 OHOS::AccountSA::OhosAccountKitsMock mock;
163 EXPECT_CALL(mock, IsSameAccountGroupDevice()).Times(1).WillOnce(testing::Return(true));
164 EXPECT_CALL(mock, QueryOhosAccountInfo()).Times(1).WillOnce(testing::Return(oh_acc_info_pair));
165 EXPECT_EQ(GetCurrentAccount(&account), SOFTBUS_NETWORK_GET_ACCOUNT_INFO_FAILED);
166 }
167
168 /**
169 * @tc.name: GetCurrentAccount_003
170 * @tc.desc: GetCurrentAccount
171 * @tc.type: FUN
172 * @tc.require: 1
173 */
174 HWTEST_F(LnnOhosAccountAdapterTest, GetCurrentAccount_003, TestSize.Level1)
175 {
176 int64_t account = 10;
177 OHOS::AccountSA::OhosAccountInfo oh_acc_info;
178 oh_acc_info.name_ = "";
179 std::pair<bool, OHOS::AccountSA::OhosAccountInfo> oh_acc_info_pair = { true, oh_acc_info };
180 OHOS::AccountSA::OhosAccountKitsMock mock;
181 EXPECT_CALL(mock, IsSameAccountGroupDevice()).Times(1).WillOnce(testing::Return(true));
182 EXPECT_CALL(mock, QueryOhosAccountInfo()).Times(1).WillOnce(testing::Return(oh_acc_info_pair));
183 EXPECT_EQ(GetCurrentAccount(&account), SOFTBUS_OK);
184 }
185
186 /**
187 * @tc.name: GetCurrentAccount_004
188 * @tc.desc: GetCurrentAccount
189 * @tc.type: FUN
190 * @tc.require: 1
191 */
192 HWTEST_F(LnnOhosAccountAdapterTest, GetCurrentAccount_004, TestSize.Level1)
193 {
194 int64_t account = 10;
195 OHOS::AccountSA::OhosAccountInfo oh_acc_info;
196 oh_acc_info.name_ = DEFAULT_ACCOUNT_NAME;
197 std::pair<bool, OHOS::AccountSA::OhosAccountInfo> oh_acc_info_pair = { true, oh_acc_info };
198 OHOS::AccountSA::OhosAccountKitsMock mock;
199 EXPECT_CALL(mock, IsSameAccountGroupDevice()).Times(1).WillOnce(testing::Return(true));
200 EXPECT_CALL(mock, QueryOhosAccountInfo()).Times(1).WillOnce(testing::Return(oh_acc_info_pair));
201 EXPECT_EQ(GetCurrentAccount(&account), SOFTBUS_OK);
202 }
203
204 /**
205 * @tc.name: GetCurrentAccount_005
206 * @tc.desc: GetCurrentAccount
207 * @tc.type: FUN
208 * @tc.require: 1
209 */
210 HWTEST_F(LnnOhosAccountAdapterTest, GetCurrentAccount_005, TestSize.Level1)
211 {
212 int64_t account = 10;
213 OHOS::AccountSA::OhosAccountInfo oh_acc_info;
214 oh_acc_info.name_ = "ACCOUNT_NAME";
215 std::pair<bool, OHOS::AccountSA::OhosAccountInfo> oh_acc_info_pair = { true, oh_acc_info };
216 OHOS::AccountSA::OhosAccountKitsMock mock;
217 EXPECT_CALL(mock, IsSameAccountGroupDevice()).Times(1).WillOnce(testing::Return(true));
218 EXPECT_CALL(mock, QueryOhosAccountInfo()).Times(1).WillOnce(testing::Return(oh_acc_info_pair));
219 EXPECT_EQ(GetCurrentAccount(&account), SOFTBUS_OK);
220 }
221
222 /**
223 * @tc.name: GetCurrentAccount_006
224 * @tc.desc: GetCurrentAccount
225 * @tc.type: FUN
226 * @tc.require: 1
227 */
228 HWTEST_F(LnnOhosAccountAdapterTest, GetCurrentAccount_006, TestSize.Level1)
229 {
230 int64_t account = 10;
231 OHOS::AccountSA::OhosAccountInfo oh_acc_info;
232 oh_acc_info.name_ = "123456";
233 std::pair<bool, OHOS::AccountSA::OhosAccountInfo> oh_acc_info_pair = { true, oh_acc_info };
234 OHOS::AccountSA::OhosAccountKitsMock mock;
235 EXPECT_CALL(mock, IsSameAccountGroupDevice()).Times(1).WillOnce(testing::Return(true));
236 EXPECT_CALL(mock, QueryOhosAccountInfo()).Times(1).WillOnce(testing::Return(oh_acc_info_pair));
237 EXPECT_EQ(GetCurrentAccount(&account), SOFTBUS_OK);
238 }
239
240 /**
241 * @tc.name: GetOsAccountIdByUserId_InvalidParam01
242 * @tc.desc: GetOsAccountIdByUserId invalid param
243 * @tc.type: FUN
244 * @tc.require: 1
245 */
246 HWTEST_F(LnnOhosAccountAdapterTest, GetOsAccountIdByUserId_InvalidParam01, TestSize.Level1)
247 {
248 int32_t userId = 100;
249 uint32_t len = 10;
250 int32_t ret = GetOsAccountIdByUserId(userId, nullptr, &len);
251 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
252 }
253
254 /**
255 * @tc.name: GetOsAccountIdByUserId_InvalidParam02
256 * @tc.desc: GetOsAccountIdByUserId invalid param
257 * @tc.type: FUN
258 * @tc.require: 1
259 */
260 HWTEST_F(LnnOhosAccountAdapterTest, GetOsAccountIdByUserId_InvalidParam02, TestSize.Level1)
261 {
262 int32_t userId = 100;
263 char *id = nullptr;
264 int32_t ret = GetOsAccountIdByUserId(userId, &id, nullptr);
265 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
266 }
267
268 /**
269 * @tc.name: GetOsAccountIdByUserId_InvalidParam03
270 * @tc.desc: GetOsAccountIdByUserId invalid param
271 * @tc.type: FUN
272 * @tc.require: 1
273 */
274 HWTEST_F(LnnOhosAccountAdapterTest, GetOsAccountIdByUserId_InvalidParam03, TestSize.Level1)
275 {
276 int32_t userId = 0;
277 uint32_t len = 10;
278 char *id = nullptr;
279 int32_t ret = GetOsAccountIdByUserId(userId, &id, &len);
280 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
281 }
282
283 /**
284 * @tc.name: GetOsAccountUid_InvalidParam01
285 * @tc.desc: GetOsAccountUid invalid param
286 * @tc.type: FUN
287 * @tc.require: 1
288 */
289 HWTEST_F(LnnOhosAccountAdapterTest, GetOsAccountUid_InvalidParam01, TestSize.Level1)
290 {
291 uint32_t idLen = ACCOUNT_UID_STR_LEN;
292 uint32_t len = 0;
293 int32_t ret = GetOsAccountUid(nullptr, idLen, &len);
294 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
295 }
296
297 /**
298 * @tc.name: GetOsAccountUid_InvalidParam02
299 * @tc.desc: GetOsAccountUid invalid param
300 * @tc.type: FUN
301 * @tc.require: 1
302 */
303 HWTEST_F(LnnOhosAccountAdapterTest, GetOsAccountUid_InvalidParam02, TestSize.Level1)
304 {
305 char accountUid[ACCOUNT_UID_STR_LEN] = { 0 };
306 uint32_t idLen = ACCOUNT_UID_STR_LEN;
307 int32_t ret = GetOsAccountUid(accountUid, idLen, nullptr);
308 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
309 }
310
311 /**
312 * @tc.name: GetOsAccountUid_InvalidParam03
313 * @tc.desc: GetOsAccountUid invalid param
314 * @tc.type: FUN
315 * @tc.require: 1
316 */
317 HWTEST_F(LnnOhosAccountAdapterTest, GetOsAccountUid_InvalidParam03, TestSize.Level1)
318 {
319 char accountUid[ACCOUNT_UID_STR_LEN] = { 0 };
320 uint32_t idLen = 0;
321 uint32_t len = 0;
322 int32_t ret = GetOsAccountUid(accountUid, idLen, &len);
323 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
324
325 idLen = ACCOUNT_UID_STR_LEN;
326 ret = GetOsAccountUid(accountUid, idLen, &len);
327 EXPECT_NE(ret, SOFTBUS_INVALID_PARAM);
328 }
329
330 /**
331 * @tc.name: GetOsAccountUidByUserId_InvalidParam01
332 * @tc.desc: GetOsAccountUidByUserId invalid param
333 * @tc.type: FUN
334 * @tc.require: 1
335 */
336 HWTEST_F(LnnOhosAccountAdapterTest, GetOsAccountUidByUserId_InvalidParam01, TestSize.Level1)
337 {
338 uint32_t idLen = ACCOUNT_UID_STR_LEN;
339 uint32_t len = 0;
340 int32_t userId = 100;
341 int32_t ret = GetOsAccountUidByUserId(nullptr, idLen, &len, userId);
342 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
343 }
344
345 /**
346 * @tc.name: GetOsAccountUidByUserId_InvalidParam02
347 * @tc.desc: GetOsAccountUidByUserId invalid param
348 * @tc.type: FUN
349 * @tc.require: 1
350 */
351 HWTEST_F(LnnOhosAccountAdapterTest, GetOsAccountUidByUserId_InvalidParam02, TestSize.Level1)
352 {
353 char accountid[ACCOUNT_UID_STR_LEN] = { 0 };
354 uint32_t idLen = ACCOUNT_UID_STR_LEN;
355 int32_t userId = 100;
356 int32_t ret = GetOsAccountUidByUserId(accountid, idLen, nullptr, userId);
357 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
358 }
359
360 /**
361 * @tc.name: GetOsAccountUidByUserId_InvalidParam03
362 * @tc.desc: GetOsAccountUidByUserId invalid param
363 * @tc.type: FUN
364 * @tc.require: 1
365 */
366 HWTEST_F(LnnOhosAccountAdapterTest, GetOsAccountUidByUserId_InvalidParam03, TestSize.Level1)
367 {
368 char accountid[ACCOUNT_UID_STR_LEN] = { 0 };
369 uint32_t idLen = 0;
370 uint32_t len = 0;
371 int32_t userId = 100;
372 int32_t ret = GetOsAccountUidByUserId(accountid, idLen, &len, userId);
373 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
374 }
375
376 /**
377 * @tc.name: GetOsAccountUidByUserId_InvalidParam04
378 * @tc.desc: GetOsAccountUidByUserId invalid param
379 * @tc.type: FUN
380 * @tc.require: 1
381 */
382 HWTEST_F(LnnOhosAccountAdapterTest, GetOsAccountUidByUserId_InvalidParam04, TestSize.Level1)
383 {
384 char accountid[ACCOUNT_UID_STR_LEN] = { 0 };
385 uint32_t idLen = ACCOUNT_UID_STR_LEN;
386 uint32_t len = 0;
387 int32_t userId = 0;
388 int32_t ret = GetOsAccountUidByUserId(accountid, idLen, &len, userId);
389 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
390 }
391
392 /**
393 * @tc.name: GetOsAccountIdByUserId_001
394 * @tc.desc: GetOsAccountIdByUserId invalid param
395 * @tc.type: FUN
396 * @tc.require: 1
397 */
398 HWTEST_F(LnnOhosAccountAdapterTest, GetOsAccountIdByUserId_001, TestSize.Level1)
399 {
400 int32_t userId = 0;
401 uint32_t len = 0;
402 char *id = (char *)SoftBusCalloc(LNN_OHOS_ACCOUNT_ADAPTER_TEST_ID_LEN * HEXIFY_UNIT_LEN);
403 EXPECT_EQ(GetOsAccountIdByUserId(userId, &id, &len), SOFTBUS_INVALID_PARAM);
404 if (id != nullptr) {
405 SoftBusFree(id);
406 }
407 }
408
409 /**
410 * @tc.name: GetOsAccountIdByUserId_002
411 * @tc.desc: GetOsAccountIdByUserId invalid param
412 * @tc.type: FUN
413 * @tc.require: 1
414 */
415 HWTEST_F(LnnOhosAccountAdapterTest, GetOsAccountIdByUserId_002, TestSize.Level1)
416 {
417 int32_t userId = 123456;
418 uint32_t len = 0;
419 EXPECT_EQ(GetOsAccountIdByUserId(userId, nullptr, &len), SOFTBUS_INVALID_PARAM);
420 }
421
422 /**
423 * @tc.name: GetOsAccountIdByUserId_003
424 * @tc.desc: GetOsAccountIdByUserId Get Account Info FailInfo
425 * @tc.type: FUN
426 * @tc.require: 1
427 */
428 HWTEST_F(LnnOhosAccountAdapterTest, GetOsAccountIdByUserId_003, TestSize.Level1)
429 {
430 int32_t userId = 123456;
431 uint32_t len = 10;
432 char *iD = (char *)SoftBusCalloc(LNN_OHOS_ACCOUNT_ADAPTER_TEST_ID_LEN * HEXIFY_UNIT_LEN);
433 ASSERT_NE(iD, nullptr);
434 EXPECT_EQ(GetOsAccountIdByUserId(userId, &iD, &len), SOFTBUS_NETWORK_GET_ACCOUNT_INFO_FAILED);
435 if (iD != nullptr) {
436 SoftBusFree(iD);
437 }
438 }
439
440 /**
441 * @tc.name: GetOsAccountId_005
442 * @tc.desc: GetOsAccountId Fail
443 * @tc.type: FUN
444 * @tc.require: 1
445 */
446 HWTEST_F(LnnOhosAccountAdapterTest, GetOsAccountId_005, TestSize.Level1)
447 {
448 char *accountInfo = (char *)SoftBusCalloc(LNN_OHOS_ACCOUNT_ADAPTER_TEST_ID_LEN * HEXIFY_UNIT_LEN);
449 ASSERT_NE(accountInfo, nullptr);
450 uint32_t len = 17;
451 OHOS::AccountSA::OhosAccountInfo oh_acc_info;
452 oh_acc_info.name_ = "ohosAnonymousName";
453 std::pair<bool, OHOS::AccountSA::OhosAccountInfo> oh_acc_info_pair = { true, oh_acc_info };
454 OHOS::AccountSA::OhosAccountKitsMock mock;
455 EXPECT_CALL(mock, IsSameAccountGroupDevice()).Times(1).WillOnce(testing::Return(true));
456 EXPECT_CALL(mock, QueryOhosAccountInfo()).Times(1).WillOnce(testing::Return(oh_acc_info_pair));
457 EXPECT_EQ(GetOsAccountId(accountInfo, LNN_OHOS_ACCOUNT_ADAPTER_TEST_ID_LEN, &len),
458 SOFTBUS_MEM_ERR);
459
460 if (accountInfo != nullptr) {
461 SoftBusFree(accountInfo);
462 }
463 }
464
465 /**
466 * @tc.name: GetOsAccountUidByUserId_001
467 * @tc.desc: GetOsAccountUidByUserId Invalid Param
468 * @tc.type: FUN
469 * @tc.require: 1
470 */
471 HWTEST_F(LnnOhosAccountAdapterTest, GetOsAccountUidByUserId_001, TestSize.Level1)
472 {
473 int32_t userId = 123456;
474 uint32_t len = LNN_OHOS_ACCOUNT_ADAPTER_TEST_ID_LEN;
475 uint32_t idLen = 0;
476 char *accountInfo = (char *)SoftBusCalloc(LNN_OHOS_ACCOUNT_ADAPTER_TEST_ID_LEN * HEXIFY_UNIT_LEN);
477 ASSERT_NE(accountInfo, nullptr);
478 EXPECT_EQ(GetOsAccountUidByUserId(accountInfo, idLen, &len, userId), SOFTBUS_INVALID_PARAM);
479 if (accountInfo != nullptr) {
480 SoftBusFree(accountInfo);
481 }
482 }
483
484 /**
485 * @tc.name: GetOsAccountUidByUserId_002
486 * @tc.desc: GetOsAccountUidByUserId Failed
487 * @tc.type: FUN
488 * @tc.require: 1
489 */
490 HWTEST_F(LnnOhosAccountAdapterTest, GetOsAccountUidByUserId_002, TestSize.Level1)
491 {
492 int32_t userId = 123456;
493 uint32_t len = LNN_OHOS_ACCOUNT_ADAPTER_TEST_ID_LEN;
494 uint32_t idLen = LNN_OHOS_ACCOUNT_ADAPTER_TEST_ID_LEN * HEXIFY_UNIT_LEN;
495 char *accountInfo = (char *)SoftBusCalloc(LNN_OHOS_ACCOUNT_ADAPTER_TEST_ID_LEN * HEXIFY_UNIT_LEN);
496 ASSERT_NE(accountInfo, nullptr);
497 OHOS::AccountSA::OhosAccountInfo oh_acc_info;
498 oh_acc_info.name_ = "teatsa";
499 EXPECT_EQ(GetOsAccountUidByUserId(accountInfo, idLen, &len, userId), SOFTBUS_NETWORK_GET_ACCOUNT_INFO_FAILED);
500 if (accountInfo != nullptr) {
501 SoftBusFree(accountInfo);
502 }
503 }
504
505 /**
506 * @tc.name: GetOsAccountUidByUserId_003
507 * @tc.desc: GetOsAccountUidByUserId Failed
508 * @tc.type: FUN
509 * @tc.require: 1
510 */
511 HWTEST_F(LnnOhosAccountAdapterTest, GetOsAccountUidByUserId_003, TestSize.Level1)
512 {
513 int32_t userId = 123456;
514 uint32_t len = LNN_OHOS_ACCOUNT_ADAPTER_TEST_ID_LEN;
515 uint32_t idLen = LNN_OHOS_ACCOUNT_ADAPTER_TEST_ID_LEN;
516 char *accountInfo = (char *)SoftBusCalloc(LNN_OHOS_ACCOUNT_ADAPTER_TEST_ID_LEN * HEXIFY_UNIT_LEN);
517 ASSERT_NE(accountInfo, nullptr);
518 OHOS::AccountSA::OhosAccountInfo oh_acc_info;
519 oh_acc_info.name_ = "ohosAnonymousName";
520 EXPECT_EQ(GetOsAccountUidByUserId(accountInfo, idLen, &len, userId), SOFTBUS_NETWORK_GET_ACCOUNT_INFO_FAILED);
521 if (accountInfo != nullptr) {
522 SoftBusFree(accountInfo);
523 }
524 }
525 } // namespace OHOS::SoftBus