1 /*
2  * Copyright (c) 2023 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 <cerrno>
17 #include <gtest/gtest.h>
18 #include <thread>
19 #include "account_log_wrapper.h"
20 #define private public
21 #include "app_account_authenticator_callback_stub.h"
22 #include "app_account_manager_service.h"
23 #include "app_account_stub.h"
24 #undef private
25 #include "parcel.h"
26 #include "want.h"
27 using namespace testing;
28 using namespace testing::ext;
29 using namespace OHOS;
30 using namespace OHOS::AccountSA;
31 
32 namespace {
33 DECLARE_INTERFACE_DESCRIPTOR(u"ohos.accountfwk.IAppAccount");
34 const std::string STRING_NAME = "name";
35 const int32_t LIMIT_CODE = 42;
36 const int32_t CLEAR_OAUTH_TOKEN = 29;
37 const int32_t SUBSCRIBE_ACCOUNT = 33;
38 const int32_t GET_ALL_ACCESSIBLE_ACCOUNTS = 31;
39 const int32_t QUERY_ALL_ACCESSIBLE_ACCOUNTS = 32;
40 const int32_t UNSUBSCRIBE_ACCOUNT = 34;
41 sptr<AppAccountManagerService> g_servicePtr;
42 } // namespace
43 
44 class MockAuthenticatorCallback final : public AccountSA::AppAccountAuthenticatorCallbackStub {
45 public:
OnResult(int32_t resultCode,const AAFwk::Want & result)46     void OnResult(int32_t resultCode, const AAFwk::Want &result)
47     {}
OnRequestRedirected(AAFwk::Want & request)48     void OnRequestRedirected(AAFwk::Want &request)
49     {}
OnRequestContinued()50     void OnRequestContinued()
51     {}
52 };
53 
54 class AppAccountStubModuleTest : public testing::Test {
55 public:
56     static void SetUpTestCase(void);
57     static void TearDownTestCase(void);
58     void SetUp();
59     void TearDown();
60 };
61 
SetUpTestCase(void)62 void AppAccountStubModuleTest::SetUpTestCase(void)
63 {
64     g_servicePtr = new (std::nothrow) AppAccountManagerService();
65     ASSERT_NE(g_servicePtr, nullptr);
66 }
67 
TearDownTestCase(void)68 void AppAccountStubModuleTest::TearDownTestCase(void)
69 {}
70 
SetUp(void)71 void AppAccountStubModuleTest::SetUp(void) __attribute__((no_sanitize("cfi")))
72 {
73     testing::UnitTest *test = testing::UnitTest::GetInstance();
74     ASSERT_NE(test, nullptr);
75     const testing::TestInfo *testinfo = test->current_test_info();
76     ASSERT_NE(testinfo, nullptr);
77     string testCaseName = string(testinfo->name());
78     ACCOUNT_LOGI("[SetUp] %{public}s start", testCaseName.c_str());
79 }
80 
TearDown(void)81 void AppAccountStubModuleTest::TearDown(void)
82 {}
83 
84 /**
85  * @tc.name: AppAccountStubModuleTest_OnRemoteRequest_001
86  * @tc.desc: OnRemoteRequest with invalid code.
87  * @tc.type: FUNC
88  * @tc.require:
89  */
90 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_OnRemoteRequest_001, TestSize.Level0)
91 {
92     MessageParcel data;
93     MessageParcel reply;
94     MessageOption option;
95     EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
96     EXPECT_NE(g_servicePtr->OnRemoteRequest(-1, data, reply, option), ERR_NONE);
97 }
98 
99 /**
100  * @tc.name: AppAccountStubModuleTest_OnRemoteRequest_002
101  * @tc.desc: OnRemoteRequest with no interface token.
102  * @tc.type: FUNC
103  * @tc.require:
104  */
105 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_OnRemoteRequest_002, TestSize.Level0)
106 {
107     MessageParcel data;
108     MessageParcel reply;
109     MessageOption option;
110     EXPECT_NE(g_servicePtr->OnRemoteRequest(-1, data, reply, option), ERR_NONE);
111 }
112 
113 /**
114  * @tc.name: AppAccountStubModuleTest_OnRemoteRequest_003
115  * @tc.desc: OnRemoteRequest success.
116  * @tc.type: FUNC
117  * @tc.require:
118  */
119 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_OnRemoteRequest_003, TestSize.Level0)
120 {
121     for (int code = 0; code <= LIMIT_CODE; code++) {
122         MessageParcel data;
123         MessageParcel reply;
124         MessageOption option;
125         EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
126         if ((code == CLEAR_OAUTH_TOKEN) || (code == SUBSCRIBE_ACCOUNT) || (code == UNSUBSCRIBE_ACCOUNT)) {
127             EXPECT_NE(g_servicePtr->OnRemoteRequest(
128                 static_cast<uint32_t>(static_cast<uint32_t>(code)), data, reply, option), ERR_NONE);
129         } else {
130             EXPECT_EQ(g_servicePtr->OnRemoteRequest(
131                 static_cast<uint32_t>(static_cast<uint32_t>(code)), data, reply, option), ERR_NONE);
132         }
133     }
134 }
135 
136 /**
137  * @tc.name: AppAccountStubModuleTest_AppStubCov_001
138  * @tc.desc: ProcAddAccount success.
139  * @tc.type: FUNC
140  * @tc.require:
141  */
142 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_AppStubCov_001, TestSize.Level0)
143 {
144     MessageParcel data;
145     MessageParcel reply;
146     EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
147     EXPECT_NE(data.WriteString(STRING_NAME), false);
148     EXPECT_NE(data.WriteString(STRING_NAME), false);
149     EXPECT_EQ(g_servicePtr->ProcAddAccount(static_cast<uint32_t>(static_cast<uint32_t>(0)),
150         data, reply), ERR_NONE);
151 }
152 
153 /**
154  * @tc.name: AppAccountStubModuleTest_AppStubCov_002
155  * @tc.desc: ProcAddAccountImplicitly success.
156  * @tc.type: FUNC
157  * @tc.require:
158  */
159 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_AppStubCov_002, TestSize.Level0)
160 {
161     MessageParcel data;
162     MessageParcel reply;
163     EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
164     AAFwk::Want options;
165     sptr<IAppAccountAuthenticatorCallback> callback = new (std::nothrow) MockAuthenticatorCallback();
166     EXPECT_NE(callback, nullptr);
167     EXPECT_NE(data.WriteString(STRING_NAME), false);
168     EXPECT_NE(data.WriteString(STRING_NAME), false);
169     EXPECT_NE(data.WriteParcelable(&options), false);
170     EXPECT_NE(data.WriteRemoteObject(callback->AsObject()), false);
171     EXPECT_EQ(g_servicePtr->ProcAddAccountImplicitly(static_cast<uint32_t>(static_cast<uint32_t>(0)),
172         data, reply), ERR_NONE);
173 }
174 
175 /**
176  * @tc.name: AppAccountStubModuleTest_AppStubCov_003
177  * @tc.desc: CreateAccount success.
178  * @tc.type: FUNC
179  * @tc.require:
180  */
181 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_AppStubCov_003, TestSize.Level0)
182 {
183     MessageParcel data;
184     MessageParcel reply;
185     EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
186     AAFwk::Want options;
187     EXPECT_NE(data.WriteString(STRING_NAME), false);
188     EXPECT_NE(data.WriteParcelable(&options), false);
189     EXPECT_EQ(g_servicePtr->ProcCreateAccount(static_cast<uint32_t>(static_cast<uint32_t>(0)),
190         data, reply), ERR_NONE);
191 }
192 
193 /**
194  * @tc.name: AppAccountStubModuleTest_AppStubCov_004
195  * @tc.desc: ProcCreateAccountImplicitly success.
196  * @tc.type: FUNC
197  * @tc.require:
198  */
199 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_AppStubCov_004, TestSize.Level0)
200 {
201     MessageParcel data;
202     MessageParcel reply;
203     EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
204     AAFwk::Want options;
205     sptr<IAppAccountAuthenticatorCallback> callback = new (std::nothrow) MockAuthenticatorCallback();
206     EXPECT_NE(callback, nullptr);
207     EXPECT_NE(data.WriteString(STRING_NAME), false);
208     EXPECT_NE(data.WriteParcelable(&options), false);
209     EXPECT_NE(data.WriteRemoteObject(callback->AsObject()), false);
210     EXPECT_EQ(g_servicePtr->ProcCreateAccountImplicitly(static_cast<uint32_t>(static_cast<uint32_t>(0)),
211         data, reply), ERR_NONE);
212 }
213 
214 /**
215  * @tc.name: AppAccountStubModuleTest_AppStubCov_005
216  * @tc.desc: ProcDeleteAccount success.
217  * @tc.type: FUNC
218  * @tc.require:
219  */
220 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_AppStubCov_005, TestSize.Level0)
221 {
222     MessageParcel data;
223     MessageParcel reply;
224     EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
225     EXPECT_NE(data.WriteString(STRING_NAME), false);
226     EXPECT_EQ(g_servicePtr->ProcDeleteAccount(static_cast<uint32_t>(static_cast<uint32_t>(0)),
227         data, reply), ERR_NONE);
228 }
229 
230 /**
231  * @tc.name: AppAccountStubModuleTest_AppStubCov_006
232  * @tc.desc: ProcGetAccountExtraInfo success.
233  * @tc.type: FUNC
234  * @tc.require:
235  */
236 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_AppStubCov_006, TestSize.Level0)
237 {
238     MessageParcel data;
239     MessageParcel reply;
240     EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
241     EXPECT_NE(data.WriteString(STRING_NAME), false);
242     EXPECT_EQ(g_servicePtr->ProcGetAccountExtraInfo(static_cast<uint32_t>(static_cast<uint32_t>(0)),
243         data, reply), ERR_NONE);
244 }
245 
246 /**
247  * @tc.name: AppAccountStubModuleTest_AppStubCov_007
248  * @tc.desc: ProcSetAccountExtraInfo success.
249  * @tc.type: FUNC
250  * @tc.require:
251  */
252 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_AppStubCov_007, TestSize.Level0)
253 {
254     MessageParcel data;
255     MessageParcel reply;
256     EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
257     EXPECT_NE(data.WriteString(STRING_NAME), false);
258     EXPECT_NE(data.WriteString(STRING_NAME), false);
259     EXPECT_EQ(g_servicePtr->ProcSetAccountExtraInfo(static_cast<uint32_t>(static_cast<uint32_t>(0)),
260         data, reply), ERR_NONE);
261 }
262 
263 /**
264  * @tc.name: AppAccountStubModuleTest_AppStubCov_008
265  * @tc.desc: ProcSetAppAccess success.
266  * @tc.type: FUNC
267  * @tc.require:
268  */
269 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_AppStubCov_008, TestSize.Level0)
270 {
271     MessageParcel data;
272     MessageParcel reply;
273     EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
274     EXPECT_NE(data.WriteString(STRING_NAME), false);
275     EXPECT_NE(data.WriteString(STRING_NAME), false);
276     EXPECT_EQ(g_servicePtr->ProcSetAppAccess(static_cast<uint32_t>(static_cast<uint32_t>(0)),
277         data, reply), ERR_NONE);
278 }
279 
280 /**
281  * @tc.name: AppAccountStubModuleTest_AppStubCov_009
282  * @tc.desc: ProcCheckAppAccountSyncEnable success.
283  * @tc.type: FUNC
284  * @tc.require:
285  */
286 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_AppStubCov_009, TestSize.Level0)
287 {
288     MessageParcel data;
289     MessageParcel reply;
290     EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
291     EXPECT_NE(data.WriteString(STRING_NAME), false);
292     EXPECT_EQ(g_servicePtr->ProcCheckAppAccountSyncEnable(static_cast<uint32_t>(static_cast<uint32_t>(0)),
293         data, reply), ERR_NONE);
294 }
295 
296 /**
297  * @tc.name: AppAccountStubModuleTest_AppStubCov_010
298  * @tc.desc: ProcSetAppAccountSyncEnable success.
299  * @tc.type: FUNC
300  * @tc.require:
301  */
302 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_AppStubCov_010, TestSize.Level0)
303 {
304     MessageParcel data;
305     MessageParcel reply;
306     bool syncEnable = false;
307     EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
308     EXPECT_NE(data.WriteString(STRING_NAME), false);
309     EXPECT_NE(data.WriteBool(syncEnable), false);
310     EXPECT_EQ(g_servicePtr->ProcSetAppAccountSyncEnable(static_cast<uint32_t>(static_cast<uint32_t>(0)),
311         data, reply), ERR_NONE);
312 }
313 
314 /**
315  * @tc.name: AppAccountStubModuleTest_AppStubCov_011
316  * @tc.desc: ProcGetAssociatedData success.
317  * @tc.type: FUNC
318  * @tc.require:
319  */
320 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_AppStubCov_011, TestSize.Level0)
321 {
322     MessageParcel data;
323     MessageParcel reply;
324     EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
325     EXPECT_NE(data.WriteString(STRING_NAME), false);
326     EXPECT_NE(data.WriteString(STRING_NAME), false);
327     EXPECT_EQ(g_servicePtr->ProcGetAssociatedData(static_cast<uint32_t>(static_cast<uint32_t>(0)),
328         data, reply), ERR_NONE);
329 }
330 
331 /**
332  * @tc.name: AppAccountStubModuleTest_AppStubCov_012
333  * @tc.desc: ProcSetAssociatedData success.
334  * @tc.type: FUNC
335  * @tc.require:
336  */
337 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_AppStubCov_012, TestSize.Level0)
338 {
339     MessageParcel data;
340     MessageParcel reply;
341     EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
342     EXPECT_NE(data.WriteString(STRING_NAME), false);
343     EXPECT_NE(data.WriteString(STRING_NAME), false);
344     EXPECT_NE(data.WriteString(STRING_NAME), false);
345     EXPECT_EQ(g_servicePtr->ProcSetAssociatedData(static_cast<uint32_t>(static_cast<uint32_t>(0)),
346         data, reply), ERR_NONE);
347 }
348 
349 /**
350  * @tc.name: AppAccountStubModuleTest_AppStubCov_013
351  * @tc.desc: ProcGetAccountCredential success.
352  * @tc.type: FUNC
353  * @tc.require:
354  */
355 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_AppStubCov_013, TestSize.Level0)
356 {
357     MessageParcel data;
358     MessageParcel reply;
359     EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
360     EXPECT_NE(data.WriteString(STRING_NAME), false);
361     EXPECT_NE(data.WriteString(STRING_NAME), false);
362     EXPECT_EQ(g_servicePtr->ProcGetAccountCredential(static_cast<uint32_t>(static_cast<uint32_t>(0)),
363         data, reply), ERR_NONE);
364 }
365 
366 /**
367  * @tc.name: AppAccountStubModuleTest_AppStubCov_014
368  * @tc.desc: ProcGetAccountCredential success.
369  * @tc.type: FUNC
370  * @tc.require:
371  */
372 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_AppStubCov_014, TestSize.Level0)
373 {
374     MessageParcel data;
375     MessageParcel reply;
376     EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
377     EXPECT_NE(data.WriteString(STRING_NAME), false);
378     EXPECT_NE(data.WriteString(STRING_NAME), false);
379     EXPECT_NE(data.WriteString(STRING_NAME), false);
380     EXPECT_EQ(g_servicePtr->ProcSetAccountCredential(static_cast<uint32_t>(static_cast<uint32_t>(0)),
381         data, reply), ERR_NONE);
382 }
383 
384 /**
385  * @tc.name: AppAccountStubModuleTest_AppStubCov_015
386  * @tc.desc: ProcAuthenticate success.
387  * @tc.type: FUNC
388  * @tc.require:
389  */
390 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_AppStubCov_015, TestSize.Level0)
391 {
392     MessageParcel data;
393     MessageParcel reply;
394     EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
395     EXPECT_NE(data.WriteString(STRING_NAME), false);
396     EXPECT_NE(data.WriteString(STRING_NAME), false);
397     EXPECT_NE(data.WriteString(STRING_NAME), false);
398     AAFwk::Want options;
399     sptr<IAppAccountAuthenticatorCallback> callback = new (std::nothrow) MockAuthenticatorCallback();
400     EXPECT_NE(callback, nullptr);
401     EXPECT_NE(data.WriteParcelable(&options), false);
402     EXPECT_NE(data.WriteRemoteObject(callback->AsObject()), false);
403     EXPECT_EQ(g_servicePtr->ProcAuthenticate(static_cast<uint32_t>(static_cast<uint32_t>(0)),
404         data, reply), ERR_NONE);
405 }
406 
407 /**
408  * @tc.name: AppAccountStubModuleTest_AppStubCov_016
409  * @tc.desc: ProcGetAuthToken success.
410  * @tc.type: FUNC
411  * @tc.require:
412  */
413 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_AppStubCov_016, TestSize.Level0)
414 {
415     MessageParcel data;
416     MessageParcel reply;
417     EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
418     EXPECT_NE(data.WriteString(STRING_NAME), false);
419     EXPECT_NE(data.WriteString(STRING_NAME), false);
420     EXPECT_NE(data.WriteString(STRING_NAME), false);
421     EXPECT_EQ(g_servicePtr->ProcGetAuthToken(static_cast<uint32_t>(static_cast<uint32_t>(0)),
422         data, reply), ERR_NONE);
423 }
424 
425 /**
426  * @tc.name: AppAccountStubModuleTest_AppStubCov_017
427  * @tc.desc: ProcSetOAuthToken success.
428  * @tc.type: FUNC
429  * @tc.require:
430  */
431 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_AppStubCov_017, TestSize.Level0)
432 {
433     MessageParcel data;
434     MessageParcel reply;
435     EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
436     EXPECT_NE(data.WriteString(STRING_NAME), false);
437     EXPECT_NE(data.WriteString(STRING_NAME), false);
438     EXPECT_NE(data.WriteString(STRING_NAME), false);
439     EXPECT_EQ(g_servicePtr->ProcSetOAuthToken(static_cast<uint32_t>(static_cast<uint32_t>(0)),
440         data, reply), ERR_NONE);
441 }
442 
443 /**
444  * @tc.name: AppAccountStubModuleTest_AppStubCov_018
445  * @tc.desc: ProcDeleteAuthToken success.
446  * @tc.type: FUNC
447  * @tc.require:
448  */
449 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_AppStubCov_018, TestSize.Level0)
450 {
451     MessageParcel data;
452     MessageParcel reply;
453     EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
454     EXPECT_NE(data.WriteString(STRING_NAME), false);
455     EXPECT_NE(data.WriteString(STRING_NAME), false);
456     EXPECT_NE(data.WriteString(STRING_NAME), false);
457     EXPECT_NE(data.WriteString(STRING_NAME), false);
458     EXPECT_EQ(g_servicePtr->ProcDeleteAuthToken(static_cast<uint32_t>(static_cast<uint32_t>(0)),
459         data, reply), ERR_NONE);
460 }
461 
462 /**
463  * @tc.name: AppAccountStubModuleTest_AppStubCov_019
464  * @tc.desc: ProcSetAuthTokenVisibility success.
465  * @tc.type: FUNC
466  * @tc.require:
467  */
468 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_AppStubCov_019, TestSize.Level0)
469 {
470     MessageParcel data;
471     MessageParcel reply;
472     EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
473     EXPECT_NE(data.WriteString(STRING_NAME), false);
474     EXPECT_NE(data.WriteString(STRING_NAME), false);
475     EXPECT_NE(data.WriteString(STRING_NAME), false);
476     EXPECT_EQ(g_servicePtr->ProcSetAuthTokenVisibility(static_cast<uint32_t>(static_cast<uint32_t>(0)),
477         data, reply), ERR_NONE);
478 }
479 
480 /**
481  * @tc.name: AppAccountStubModuleTest_AppStubCov_020
482  * @tc.desc: ProcCheckAuthTokenVisibility success.
483  * @tc.type: FUNC
484  * @tc.require:
485  */
486 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_AppStubCov_020, TestSize.Level0)
487 {
488     MessageParcel data;
489     MessageParcel reply;
490     EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
491     EXPECT_NE(data.WriteString(STRING_NAME), false);
492     EXPECT_NE(data.WriteString(STRING_NAME), false);
493     EXPECT_NE(data.WriteString(STRING_NAME), false);
494     EXPECT_EQ(g_servicePtr->ProcCheckAuthTokenVisibility(static_cast<uint32_t>(static_cast<uint32_t>(0)),
495         data, reply), ERR_NONE);
496 }
497 
498 /**
499  * @tc.name: AppAccountStubModuleTest_AppStubCov_021
500  * @tc.desc: ProcGetAuthenticatorInfo success.
501  * @tc.type: FUNC
502  * @tc.require:
503  */
504 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_AppStubCov_021, TestSize.Level0)
505 {
506     MessageParcel data;
507     MessageParcel reply;
508     EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
509     EXPECT_NE(data.WriteString(STRING_NAME), false);
510     EXPECT_EQ(g_servicePtr->ProcGetAuthenticatorInfo(static_cast<uint32_t>(static_cast<uint32_t>(0)),
511         data, reply), ERR_NONE);
512 }
513 
514 /**
515  * @tc.name: AppAccountStubModuleTest_AppStubCov_022
516  * @tc.desc: ProcGetAllOAuthTokens success.
517  * @tc.type: FUNC
518  * @tc.require:
519  */
520 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_AppStubCov_022, TestSize.Level0)
521 {
522     MessageParcel data;
523     MessageParcel reply;
524     EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
525     EXPECT_NE(data.WriteString(STRING_NAME), false);
526     EXPECT_NE(data.WriteString(STRING_NAME), false);
527     EXPECT_EQ(g_servicePtr->ProcGetAllOAuthTokens(static_cast<uint32_t>(static_cast<uint32_t>(0)),
528         data, reply), ERR_NONE);
529 }
530 
531 /**
532  * @tc.name: AppAccountStubModuleTest_AppStubCov_023
533  * @tc.desc: ProcGetAuthList success.
534  * @tc.type: FUNC
535  * @tc.require:
536  */
537 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_AppStubCov_023, TestSize.Level0)
538 {
539     MessageParcel data;
540     MessageParcel reply;
541     EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
542     EXPECT_NE(data.WriteString(STRING_NAME), false);
543     EXPECT_NE(data.WriteString(STRING_NAME), false);
544     EXPECT_EQ(g_servicePtr->ProcGetAuthList(static_cast<uint32_t>(static_cast<uint32_t>(0)),
545         data, reply), ERR_NONE);
546 }
547 
548 /**
549  * @tc.name: AppAccountStubModuleTest_AppStubCov_024
550  * @tc.desc: ProcGetAuthenticatorCallback success.
551  * @tc.type: FUNC
552  * @tc.require:
553  */
554 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_AppStubCov_024, TestSize.Level0)
555 {
556     MessageParcel data;
557     MessageParcel reply;
558     EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
559     EXPECT_NE(data.WriteString(STRING_NAME), false);
560     EXPECT_EQ(g_servicePtr->ProcGetAuthenticatorCallback(static_cast<uint32_t>(static_cast<uint32_t>(0)),
561         data, reply), ERR_NONE);
562 }
563 
564 /**
565  * @tc.name: AppAccountStubModuleTest_AppStubCov_025
566  * @tc.desc: ProcGetAllAccounts success.
567  * @tc.type: FUNC
568  * @tc.require:
569  */
570 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_AppStubCov_025, TestSize.Level0)
571 {
572     MessageParcel data;
573     MessageParcel reply;
574     EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
575     EXPECT_NE(data.WriteString(STRING_NAME), false);
576     EXPECT_EQ(g_servicePtr->ProcGetAllAccounts(static_cast<uint32_t>(static_cast<uint32_t>(0)),
577         data, reply), ERR_NONE);
578 }
579 
580 /**
581  * @tc.name: AppAccountStubModuleTest_AppStubCov_026
582  * @tc.desc: ProcGetAllAccessibleAccounts success.
583  * @tc.type: FUNC
584  * @tc.require:
585  */
586 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_AppStubCov_026, TestSize.Level0)
587 {
588     MessageParcel data;
589     MessageParcel reply;
590     EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
591     EXPECT_NE(data.WriteString(STRING_NAME), false);
592     EXPECT_EQ(g_servicePtr->ProcGetAllAccessibleAccounts(
593         static_cast<uint32_t>(static_cast<uint32_t>(GET_ALL_ACCESSIBLE_ACCOUNTS)), data, reply), ERR_NONE);
594     EXPECT_EQ(g_servicePtr->ProcGetAllAccessibleAccounts(
595         static_cast<uint32_t>(static_cast<uint32_t>(QUERY_ALL_ACCESSIBLE_ACCOUNTS)), data, reply), ERR_NONE);
596 }
597 
598 /**
599  * @tc.name: AppAccountStubModuleTest_AppStubCov_027
600  * @tc.desc: ProcCheckAppAccess success.
601  * @tc.type: FUNC
602  * @tc.require:
603  */
604 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_AppStubCov_027, TestSize.Level0)
605 {
606     MessageParcel data;
607     MessageParcel reply;
608     EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
609     EXPECT_NE(data.WriteString(STRING_NAME), false);
610     EXPECT_NE(data.WriteString(STRING_NAME), false);
611     EXPECT_EQ(g_servicePtr->ProcCheckAppAccess(static_cast<uint32_t>(static_cast<uint32_t>(0)),
612         data, reply), ERR_NONE);
613 }
614 
615 /**
616  * @tc.name: AppAccountStubModuleTest_AppStubCov_028
617  * @tc.desc: ProcDeleteAccountCredential success.
618  * @tc.type: FUNC
619  * @tc.require:
620  */
621 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_AppStubCov_028, TestSize.Level0)
622 {
623     MessageParcel data;
624     MessageParcel reply;
625     EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
626     EXPECT_NE(data.WriteString(STRING_NAME), false);
627     EXPECT_NE(data.WriteString(STRING_NAME), false);
628     EXPECT_EQ(g_servicePtr->ProcDeleteAccountCredential(static_cast<uint32_t>(static_cast<uint32_t>(0)),
629         data, reply), ERR_NONE);
630 }
631 
632 /**
633  * @tc.name: AppAccountStubModuleTest_AppStubCov_029
634  * @tc.desc: ProcSelectAccountsByOptions success.
635  * @tc.type: FUNC
636  * @tc.require:
637  */
638 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_AppStubCov_029, TestSize.Level0)
639 {
640     MessageParcel data;
641     MessageParcel reply;
642     EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
643     AAFwk::Want options;
644     sptr<IAppAccountAuthenticatorCallback> callback = new (std::nothrow) MockAuthenticatorCallback();
645     EXPECT_NE(callback, nullptr);
646     EXPECT_NE(data.WriteParcelable(&options), false);
647     EXPECT_NE(data.WriteRemoteObject(callback->AsObject()), false);
648     EXPECT_EQ(g_servicePtr->ProcSelectAccountsByOptions(static_cast<uint32_t>(static_cast<uint32_t>(0)),
649         data, reply), ERR_NONE);
650 }
651 
652 /**
653  * @tc.name: AppAccountStubModuleTest_AppStubCov_030
654  * @tc.desc: ProcVerifyCredential success.
655  * @tc.type: FUNC
656  * @tc.require:
657  */
658 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_AppStubCov_030, TestSize.Level0)
659 {
660     MessageParcel data;
661     MessageParcel reply;
662     EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
663     EXPECT_NE(data.WriteString(STRING_NAME), false);
664     EXPECT_NE(data.WriteString(STRING_NAME), false);
665     AAFwk::Want options;
666     sptr<IAppAccountAuthenticatorCallback> callback = new (std::nothrow) MockAuthenticatorCallback();
667     EXPECT_NE(callback, nullptr);
668     EXPECT_NE(data.WriteParcelable(&options), false);
669     EXPECT_NE(data.WriteRemoteObject(callback->AsObject()), false);
670     EXPECT_EQ(g_servicePtr->ProcVerifyCredential(static_cast<uint32_t>(static_cast<uint32_t>(0)),
671         data, reply), ERR_NONE);
672 }
673 
674 /**
675  * @tc.name: AppAccountStubModuleTest_AppStubCov_031
676  * @tc.desc: ProcCheckAccountLabels success.
677  * @tc.type: FUNC
678  * @tc.require:
679  */
680 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_AppStubCov_031, TestSize.Level0)
681 {
682     MessageParcel data;
683     MessageParcel reply;
684     EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
685     EXPECT_NE(data.WriteString(STRING_NAME), false);
686     EXPECT_NE(data.WriteString(STRING_NAME), false);
687     std::vector<std::string> labels;
688     EXPECT_NE(data.WriteStringVector(labels), false);
689     sptr<IAppAccountAuthenticatorCallback> callback = new (std::nothrow) MockAuthenticatorCallback();
690     EXPECT_NE(callback, nullptr);
691     EXPECT_NE(data.WriteRemoteObject(callback->AsObject()), false);
692     EXPECT_EQ(g_servicePtr->ProcCheckAccountLabels(static_cast<uint32_t>(static_cast<uint32_t>(0)),
693         data, reply), ERR_NONE);
694 }
695 
696 /**
697  * @tc.name: AppAccountStubModuleTest_AppStubCov_032
698  * @tc.desc: ProcSetAuthenticatorProperties success.
699  * @tc.type: FUNC
700  * @tc.require:
701  */
702 HWTEST_F(AppAccountStubModuleTest, AppAccountStubModuleTest_AppStubCov_032, TestSize.Level0)
703 {
704     MessageParcel data;
705     MessageParcel reply;
706     EXPECT_NE(data.WriteInterfaceToken(GetDescriptor()), false);
707     EXPECT_NE(data.WriteString(STRING_NAME), false);
708     AAFwk::Want options;
709     EXPECT_NE(data.WriteParcelable(&options), false);
710     sptr<IAppAccountAuthenticatorCallback> callback = new (std::nothrow) MockAuthenticatorCallback();
711     EXPECT_NE(callback, nullptr);
712     EXPECT_NE(data.WriteRemoteObject(callback->AsObject()), false);
713     EXPECT_EQ(g_servicePtr->ProcSetAuthenticatorProperties(static_cast<uint32_t>(static_cast<uint32_t>(0)),
714         data, reply), ERR_NONE);
715 }