• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2024 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 <cstdio>
17 #include <gtest/gtest.h>
18 #include <securec.h>
19 
20 #include "account_manager.h"
21 #include "key_event.h"
22 #include "mmi_log.h"
23 
24 #undef MMI_LOG_TAG
25 #define MMI_LOG_TAG "AccountManagerTest"
26 
27 namespace OHOS {
28 namespace MMI {
29 namespace {
30 using namespace testing::ext;
31 constexpr int32_t TEST_ACCOUNT_ID_001 { 1 };
32 constexpr int32_t TEST_ACCOUNT_ID_002 { 2 };
33 constexpr int32_t MAIN_ACCOUNT_ID { 100 };
34 constexpr size_t DEFAULT_BUFFER_LENGTH { 512 };
35 const std::string SECURE_SETTING_URI_PROXY {""};
36 } // namespace
37 
38 class AccountManagerTest : public testing::Test {
39 public:
SetUpTestCase(void)40     static void SetUpTestCase(void) {}
TearDownTestCase(void)41     static void TearDownTestCase(void)
42     {
43         int32_t accountId = ACCOUNT_MGR->currentAccountId_;
44         EXPECT_EQ(accountId, MAIN_ACCOUNT_ID);
45         ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->accounts_[accountId]->switchObserver_ = nullptr);
46         ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->accounts_[accountId]->onScreenLockedSwitchObserver_ = nullptr);
47         ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->accounts_[accountId]->configObserver_ = nullptr);
48     }
49 };
50 
51 /**
52  * @tc.name: AccountManagerTest_GetInstance_01
53  * @tc.desc: Test the funcation GetInstance
54  * @tc.type: FUNC
55  * @tc.require:
56  */
57 HWTEST_F(AccountManagerTest, AccountManagerTest_GetInstance_01, TestSize.Level1)
58 {
59     CALL_TEST_DEBUG;
60     AccountManager::instance_ = nullptr;
61     ASSERT_NE(ACCOUNT_MGR, nullptr);
62 }
63 
64 /**
65  * @tc.name: AccountManagerTest_SubscribeCommonEvent_01
66  * @tc.desc: Test the funcation SubscribeCommonEvent
67  * @tc.type: FUNC
68  * @tc.require:
69  */
70 HWTEST_F(AccountManagerTest, AccountManagerTest_SubscribeCommonEvent_01, TestSize.Level1)
71 {
72     CALL_TEST_DEBUG;
73     ACCOUNT_MGR->subscriber_ = nullptr;
74     ACCOUNT_MGR->timerId_ = -1;
75     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->SubscribeCommonEvent());
76 }
77 
78 /**
79  * @tc.name: AccountManagerTest_UnsubscribeCommonEvent_01
80  * @tc.desc: Test the funcation UnsubscribeCommonEvent
81  * @tc.type: FUNC
82  * @tc.require:
83  */
84 HWTEST_F(AccountManagerTest, AccountManagerTest_UnsubscribeCommonEvent_01, TestSize.Level1)
85 {
86     CALL_TEST_DEBUG;
87     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->SubscribeCommonEvent());
88     ACCOUNT_MGR->subscriber_ = nullptr;
89     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->UnsubscribeCommonEvent());
90 }
91 
92 /**
93  * @tc.name: AccountManagerTest_SubscribeCommonEvent_02
94  * @tc.desc: Test the funcation SubscribeCommonEvent
95  * @tc.type: FUNC
96  * @tc.require:
97  */
98 HWTEST_F(AccountManagerTest, AccountManagerTest_SubscribeCommonEvent_02, TestSize.Level1)
99 {
100     CALL_TEST_DEBUG;
101     ACCOUNT_MGR->subscriber_ = nullptr;
102     ACCOUNT_MGR->timerId_ = 1;
103     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->SubscribeCommonEvent());
104 }
105 
106 /**
107  * @tc.name: AccountManagerTest_OnAddUser_01
108  * @tc.desc: Test the funcation OnAddUser
109  * @tc.type: FUNC
110  * @tc.require:
111  */
112 HWTEST_F(AccountManagerTest, AccountManagerTest_OnAddUser_01, TestSize.Level1)
113 {
114     CALL_TEST_DEBUG;
115     int32_t accountId = TEST_ACCOUNT_ID_001;
116     EventFwk::CommonEventData data;
117     data.SetCode(accountId);
118     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->OnAddUser(data));
119 
120     auto ret = ACCOUNT_MGR->accounts_.emplace(accountId, std::make_unique<AccountManager::AccountSetting>(accountId));
121     EXPECT_FALSE(ret.second);
122     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->OnAddUser(data));
123 }
124 
125 /**
126  * @tc.name: AccountManagerTest_OnRemoveUser_01
127  * @tc.desc: Test the funcation OnRemoveUser
128  * @tc.type: FUNC
129  * @tc.require:
130  */
131 HWTEST_F(AccountManagerTest, AccountManagerTest_OnRemoveUser_01, TestSize.Level1)
132 {
133     CALL_TEST_DEBUG;
134     int32_t accountId = TEST_ACCOUNT_ID_002;
135     EventFwk::CommonEventData data;
136     data.SetCode(accountId);
137     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->OnAddUser(data));
138     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->OnRemoveUser(data));
139 }
140 
141 /**
142  * @tc.name: AccountManagerTest_OnCommonEvent_01
143  * @tc.desc: Test the funcation OnCommonEvent
144  * @tc.type: FUNC
145  * @tc.require:
146  */
147 HWTEST_F(AccountManagerTest, AccountManagerTest_OnCommonEvent_01, TestSize.Level1)
148 {
149     CALL_TEST_DEBUG;
150     EventFwk::CommonEventData data;
151     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->OnCommonEvent(data));
152 }
153 
154 /**
155  * @tc.name: AccountManagerTest_OnCommonEvent_02
156  * @tc.desc: Test the funcation OnCommonEvent
157  * @tc.type: FUNC
158  * @tc.require:
159  */
160 HWTEST_F(AccountManagerTest, AccountManagerTest_OnCommonEvent_02, TestSize.Level1)
161 {
162     CALL_TEST_DEBUG;
163     EventFwk::CommonEventData data;
164     std::string action = data.GetWant().GetAction();
__anonf86f38430202(const EventFwk::CommonEventData &) 165     auto func = [](const EventFwk::CommonEventData &) {};
166     ACCOUNT_MGR->handlers_[action] = func;
167     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->OnCommonEvent(data));
168 }
169 
170 /**
171  * @tc.name: AccountManagerTest_OnSwitchUser_01
172  * @tc.desc: Test OnSwitchUser with empty account
173  * @tc.type: FUNC
174  * @tc.require:
175  */
176 HWTEST_F(AccountManagerTest, AccountManagerTest_OnSwitchUser_01, TestSize.Level1)
177 {
178     CALL_TEST_DEBUG;
179     int32_t accountId = TEST_ACCOUNT_ID_002;
180     EventFwk::CommonEventData data;
181     data.SetCode(accountId);
182     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->OnSwitchUser(data));
183 
184     EXPECT_EQ(ACCOUNT_MGR->currentAccountId_, accountId);
185     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->OnSwitchUser(data));
186 }
187 
188 /**
189  * @tc.name: AccountManagerTest_OnSwitchUser_02
190  * @tc.desc: Test OnSwitchUser with used account
191  * @tc.type: FUNC
192  * @tc.require:
193  */
194 HWTEST_F(AccountManagerTest, AccountManagerTest_OnSwitchUser_02, TestSize.Level1)
195 {
196     CALL_TEST_DEBUG;
197     int32_t accountId = TEST_ACCOUNT_ID_001;
198     EventFwk::CommonEventData data;
199     data.SetCode(accountId);
200     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->OnSwitchUser(data));
201 
202     data.SetCode(MAIN_ACCOUNT_ID);
203     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->OnSwitchUser(data));
204 
205     data.SetCode(accountId);
206     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->OnRemoveUser(data));
207 }
208 
209 /**
210  * @tc.name: AccountManagerTest_GetCurrentAccountSetting
211  * @tc.desc: Test the funcation GetCurrentAccountSetting
212  * @tc.type: FUNC
213  * @tc.require:
214  */
215 HWTEST_F(AccountManagerTest, AccountManagerTest_GetCurrentAccountSetting_001, TestSize.Level1)
216 {
217     CALL_TEST_DEBUG;
218     auto accountSetting = ACCOUNT_MGR->GetCurrentAccountSetting();
219     int32_t accountId = accountSetting.GetAccountId();
220     EXPECT_EQ(accountId, MAIN_ACCOUNT_ID);
221 }
222 
223 /**
224  * @tc.name: AccountManagerTest_GetCurrentAccountSetting_002
225  * @tc.desc: Test the funcation GetCurrentAccountSetting
226  * @tc.type: FUNC
227  * @tc.require:
228  */
229 HWTEST_F(AccountManagerTest, AccountManagerTest_GetCurrentAccountSetting_002, TestSize.Level1)
230 {
231     CALL_TEST_DEBUG;
232     AccountManager accountManager;
233     accountManager.timerId_ = 0;
234     accountManager.currentAccountId_ = 10;
235     accountManager.accounts_.clear();
236     auto accountSetting = accountManager.GetCurrentAccountSetting();
237     EXPECT_EQ(accountManager.accounts_.size(), 1);
238     EXPECT_EQ(accountSetting.GetAccountId(), 10);
239 }
240 
241 /**
242  * @tc.name: AccountManagerTest_InitializeSetting_01
243  * @tc.desc: Test the funcation InitializeSetting
244  * @tc.type: FUNC
245  * @tc.require:
246  */
247 HWTEST_F(AccountManagerTest, AccountManagerTest_InitializeSetting_01, TestSize.Level1)
248 {
249     CALL_TEST_DEBUG;
250     int32_t accountId = 1;
251     AccountManager::AccountSetting accountSetting(accountId);
252     accountSetting.switchObserver_ = nullptr;
253     ASSERT_NO_FATAL_FAILURE(accountSetting.InitializeSetting());
254 
255     EventFwk::CommonEventData data;
256     data.SetCode(accountId);
257     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->OnRemoveUser(data));
258 }
259 
260 /**
261  * @tc.name: AccountManagerTest_InitializeSetting_02
262  * @tc.desc: Test the funcation InitializeSetting
263  * @tc.type: FUNC
264  * @tc.require:
265  */
266 HWTEST_F(AccountManagerTest, AccountManagerTest_InitializeSetting_02, TestSize.Level1)
267 {
268     CALL_TEST_DEBUG;
269     int32_t accountId = 2;
270     AccountManager::AccountSetting accountSetting(accountId);
271     accountSetting.onScreenLockedSwitchObserver_ = nullptr;
272     ASSERT_NO_FATAL_FAILURE(accountSetting.InitializeSetting());
273 
274     EventFwk::CommonEventData data;
275     data.SetCode(accountId);
276     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->OnRemoveUser(data));
277 }
278 
279 /**
280  * @tc.name: AccountManagerTest_InitializeSetting_03
281  * @tc.desc: Test the funcation InitializeSetting
282  * @tc.type: FUNC
283  * @tc.require:
284  */
285 HWTEST_F(AccountManagerTest, AccountManagerTest_InitializeSetting_03, TestSize.Level1)
286 {
287     CALL_TEST_DEBUG;
288     int32_t accountId = 3;
289     AccountManager::AccountSetting accountSetting(accountId);
290     accountSetting.configObserver_ = nullptr;
291     ASSERT_NO_FATAL_FAILURE(accountSetting.InitializeSetting());
292 
293     EventFwk::CommonEventData data;
294     data.SetCode(accountId);
295     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->OnRemoveUser(data));
296 }
297 
298 /**
299  * @tc.name: AccountManagerTest_ReadSwitchStatus_01
300  * @tc.desc: Test the funcation ReadSwitchStatus
301  * @tc.type: FUNC
302  * @tc.require:
303  */
304 HWTEST_F(AccountManagerTest, AccountManagerTest_ReadSwitchStatus_01, TestSize.Level1)
305 {
306     CALL_TEST_DEBUG;
307     int32_t accountId = 3;
308     AccountManager::AccountSetting accountSetting(accountId);
309     accountSetting.accountId_ = -1;
310     std::string key = "down";
311     bool currentSwitchStatus = true;
312     bool ret = accountSetting.ReadSwitchStatus(key, currentSwitchStatus);
313     EXPECT_FALSE(ret);
314 
315     EventFwk::CommonEventData data;
316     data.SetCode(accountId);
317     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->OnRemoveUser(data));
318 }
319 
320 /**
321  * @tc.name: AccountManagerTest_ReadSwitchStatus_02
322  * @tc.desc: Test the funcation ReadSwitchStatus
323  * @tc.type: FUNC
324  * @tc.require:
325  */
326 HWTEST_F(AccountManagerTest, AccountManagerTest_ReadSwitchStatus_02, TestSize.Level1)
327 {
328     CALL_TEST_DEBUG;
329     int32_t accountId = 5;
330     AccountManager::AccountSetting accountSetting(accountId);
331     accountSetting.accountId_ = 2;
332     std::string key = "invaild";
333     bool currentSwitchStatus = false;
334 
335     char buf[DEFAULT_BUFFER_LENGTH] {};
336     EXPECT_FALSE(sprintf_s(buf, sizeof(buf), SECURE_SETTING_URI_PROXY.c_str(), accountSetting.accountId_) > 0);
337     bool ret = accountSetting.ReadSwitchStatus(key, currentSwitchStatus);
338     EXPECT_FALSE(ret);
339 
340     EventFwk::CommonEventData data;
341     data.SetCode(accountId);
342     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->OnRemoveUser(data));
343 }
344 
345 /**
346  * @tc.name: AccountManagerTest_ReadLongPressTime_01
347  * @tc.desc: Test the funcation ReadLongPressTime
348  * @tc.type: FUNC
349  * @tc.require:
350  */
351 HWTEST_F(AccountManagerTest, AccountManagerTest_ReadLongPressTime_01, TestSize.Level1)
352 {
353     CALL_TEST_DEBUG;
354     int32_t accountId = 3;
355     AccountManager::AccountSetting accountSetting(accountId);
356     accountSetting.accountId_ = -1;
357     ASSERT_NO_FATAL_FAILURE(accountSetting.ReadLongPressTime());
358 
359     EventFwk::CommonEventData data;
360     data.SetCode(accountId);
361     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->OnRemoveUser(data));
362 }
363 
364 /**
365  * @tc.name: AccountManagerTest_ReadLongPressTime_02
366  * @tc.desc: Test the funcation ReadLongPressTime
367  * @tc.type: FUNC
368  * @tc.require:
369  */
370 HWTEST_F(AccountManagerTest, AccountManagerTest_ReadLongPressTime_02, TestSize.Level1)
371 {
372     CALL_TEST_DEBUG;
373     int32_t accountId = 3;
374     AccountManager::AccountSetting accountSetting(accountId);
375     accountSetting.accountId_ = 2;
376 
377     char buf[DEFAULT_BUFFER_LENGTH] {};
378     EXPECT_FALSE(sprintf_s(buf, sizeof(buf), SECURE_SETTING_URI_PROXY.c_str(), accountSetting.accountId_) > 0);
379     ASSERT_NO_FATAL_FAILURE(accountSetting.ReadLongPressTime());
380 
381     EventFwk::CommonEventData data;
382     data.SetCode(accountId);
383     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->OnRemoveUser(data));
384 }
385 
386 /**
387  * @tc.name: AccountManagerTest_AccShortcutTimeout_01
388  * @tc.desc: Test the funcation AccShortcutTimeout
389  * @tc.type: FUNC
390  * @tc.require:
391  */
392 HWTEST_F(AccountManagerTest, AccountManagerTest_AccShortcutTimeout_01, TestSize.Level1)
393 {
394     CALL_TEST_DEBUG;
395     int32_t accountId = 1;
396     std::string key = "testKey";
397     AccountManager::AccountSetting accountSetting(accountId);
398     auto accountMgr = ACCOUNT_MGR;
399     accountMgr->accounts_.emplace(accountId, std::make_unique<AccountManager::AccountSetting>(accountId));
400     ASSERT_NO_FATAL_FAILURE(accountSetting.AccShortcutTimeout(accountId, key));
401 
402     EventFwk::CommonEventData data;
403     data.SetCode(accountId);
404     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->OnRemoveUser(data));
405 }
406 
407 /**
408  * @tc.name: AccountManagerTest_AccShortcutTimeout_02
409  * @tc.desc: Test the funcation AccShortcutTimeout
410  * @tc.type: FUNC
411  * @tc.require:
412  */
413 HWTEST_F(AccountManagerTest, AccountManagerTest_AccShortcutTimeout_02, TestSize.Level1)
414 {
415     CALL_TEST_DEBUG;
416     int32_t accountId = 2;
417     std::string key = "testKey";
418     AccountManager::AccountSetting accountSetting(accountId);
419     auto accountMgr = ACCOUNT_MGR;
420     ASSERT_NO_FATAL_FAILURE(accountSetting.AccShortcutTimeout(accountId, key));
421 
422     EventFwk::CommonEventData data;
423     data.SetCode(accountId);
424     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->OnRemoveUser(data));
425 }
426 
427 /**
428  * @tc.name: AccountManagerTest_AccShortcutEnabled_01
429  * @tc.desc: Test the funcation AccShortcutEnabled
430  * @tc.type: FUNC
431  * @tc.require:
432  */
433 HWTEST_F(AccountManagerTest, AccountManagerTest_AccShortcutEnabled_01, TestSize.Level1)
434 {
435     CALL_TEST_DEBUG;
436     int32_t accountId = 1;
437     std::string key = "shortcutKey";
438     AccountManager::AccountSetting accountSetting(accountId);
439     auto accountMgr = ACCOUNT_MGR;
440     accountMgr->accounts_.emplace(accountId, std::make_unique<AccountManager::AccountSetting>(accountId));
441     ASSERT_NO_FATAL_FAILURE(accountSetting.AccShortcutEnabled(accountId, key));
442 
443     EventFwk::CommonEventData data;
444     data.SetCode(accountId);
445     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->OnRemoveUser(data));
446 }
447 
448 /**
449  * @tc.name: AccountManagerTest_AccShortcutEnabled_02
450  * @tc.desc: Test the funcation AccShortcutEnabled
451  * @tc.type: FUNC
452  * @tc.require:
453  */
454 HWTEST_F(AccountManagerTest, AccountManagerTest_AccShortcutEnabled_02, TestSize.Level1)
455 {
456     CALL_TEST_DEBUG;
457     int32_t accountId = 2;
458     std::string key = "shortcutKey";
459     AccountManager::AccountSetting accountSetting(accountId);
460     auto accountMgr = ACCOUNT_MGR;
461     ASSERT_NO_FATAL_FAILURE(accountSetting.AccShortcutEnabled(accountId, key));
462 
463     EventFwk::CommonEventData data;
464     data.SetCode(accountId);
465     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->OnRemoveUser(data));
466 }
467 
468 /**
469  * @tc.name: AccountManagerTest_AccShortcutEnabledOnScreenLocked_01
470  * @tc.desc: Test the funcation AccShortcutEnabledOnScreenLocked
471  * @tc.type: FUNC
472  * @tc.require:
473  */
474 HWTEST_F(AccountManagerTest, AccountManagerTest_AccShortcutEnabledOnScreenLocked_01, TestSize.Level1)
475 {
476     CALL_TEST_DEBUG;
477     int32_t accountId = 1;
478     std::string key = "shortcutKey";
479     AccountManager::AccountSetting accountSetting(accountId);
480     auto accountMgr = ACCOUNT_MGR;
481     accountMgr->accounts_.emplace(accountId, std::make_unique<AccountManager::AccountSetting>(accountId));
482     ASSERT_NO_FATAL_FAILURE(accountSetting.AccShortcutEnabledOnScreenLocked(accountId, key));
483 
484     EventFwk::CommonEventData data;
485     data.SetCode(accountId);
486     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->OnRemoveUser(data));
487 }
488 
489 /**
490  * @tc.name: AccountManagerTest_AccShortcutEnabledOnScreenLocked_02
491  * @tc.desc: Test the funcation AccShortcutEnabledOnScreenLocked
492  * @tc.type: FUNC
493  * @tc.require:
494  */
495 HWTEST_F(AccountManagerTest, AccountManagerTest_AccShortcutEnabledOnScreenLocked_02, TestSize.Level1)
496 {
497     CALL_TEST_DEBUG;
498     int32_t accountId = 2;
499     std::string key = "shortcutKey";
500     AccountManager::AccountSetting accountSetting(accountId);
501     auto accountMgr = ACCOUNT_MGR;
502     ASSERT_NO_FATAL_FAILURE(accountSetting.AccShortcutEnabledOnScreenLocked(accountId, key));
503 
504     EventFwk::CommonEventData data;
505     data.SetCode(accountId);
506     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->OnRemoveUser(data));
507 }
508 
509 /**
510  * @tc.name: AccountManagerTest_ReadSwitchStatus_03
511  * @tc.desc: Test the funcation ReadSwitchStatus
512  * @tc.type: FUNC
513  * @tc.require:
514  */
515 HWTEST_F(AccountManagerTest, AccountManagerTest_ReadSwitchStatus_03, TestSize.Level1)
516 {
517     CALL_TEST_DEBUG;
518     int32_t accountId = -1;
519     AccountManager::AccountSetting accountSetting(accountId);
520     std::string key = "down";
521     bool currentSwitchStatus = true;
522     bool ret = accountSetting.ReadSwitchStatus(key, currentSwitchStatus);
523     EXPECT_FALSE(ret);
524 
525     EventFwk::CommonEventData data;
526     data.SetCode(accountId);
527     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->OnRemoveUser(data));
528 }
529 
530 /**
531  * @tc.name: AccountManagerTest_ReadSwitchStatus_04
532  * @tc.desc: Test the funcation ReadSwitchStatus
533  * @tc.type: FUNC
534  * @tc.require:
535  */
536 HWTEST_F(AccountManagerTest, AccountManagerTest_ReadSwitchStatus_04, TestSize.Level1)
537 {
538     CALL_TEST_DEBUG;
539     int32_t accountId = 5;
540     AccountManager::AccountSetting accountSetting(accountId);
541     std::string key = "invaild";
542     bool currentSwitchStatus = false;
543 
544     char buf[DEFAULT_BUFFER_LENGTH] {};
545     EXPECT_FALSE(sprintf_s(buf, sizeof(buf), SECURE_SETTING_URI_PROXY.c_str(), accountSetting.accountId_) > 0);
546     bool ret = accountSetting.ReadSwitchStatus(key, currentSwitchStatus);
547     EXPECT_FALSE(ret);
548 
549     EventFwk::CommonEventData data;
550     data.SetCode(accountId);
551     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->OnRemoveUser(data));
552 }
553 
554 /**
555  * @tc.name: AccountManagerTest_ReadLongPressTime_03
556  * @tc.desc: Test the funcation ReadLongPressTime
557  * @tc.type: FUNC
558  * @tc.require:
559  */
560 HWTEST_F(AccountManagerTest, AccountManagerTest_ReadLongPressTime_03, TestSize.Level1)
561 {
562     CALL_TEST_DEBUG;
563     int32_t accountId = -1;
564     AccountManager::AccountSetting accountSetting(accountId);
565     ASSERT_NO_FATAL_FAILURE(accountSetting.ReadLongPressTime());
566 
567     EventFwk::CommonEventData data;
568     data.SetCode(accountId);
569     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->OnRemoveUser(data));
570 }
571 
572 /**
573  * @tc.name: AccountManagerTest_ReadLongPressTime_04
574  * @tc.desc: Test the funcation ReadLongPressTime
575  * @tc.type: FUNC
576  * @tc.require:
577  */
578 HWTEST_F(AccountManagerTest, AccountManagerTest_ReadLongPressTime_04, TestSize.Level1)
579 {
580     CALL_TEST_DEBUG;
581     int32_t accountId = 3;
582     AccountManager::AccountSetting accountSetting(accountId);
583     accountSetting.accountId_ = 2;
584     char buf[DEFAULT_BUFFER_LENGTH] {};
585     EXPECT_FALSE(sprintf_s(buf, sizeof(buf), SECURE_SETTING_URI_PROXY.c_str(), accountSetting.accountId_) > 0);
586     ASSERT_NO_FATAL_FAILURE(accountSetting.ReadLongPressTime());
587 
588     EventFwk::CommonEventData data;
589     data.SetCode(accountId);
590     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->OnRemoveUser(data));
591 }
592 
593 /**
594  * @tc.name: AccountManagerTest_OnReceiveEvent
595  * @tc.desc: Test the funcation OnReceiveEvent
596  * @tc.type: FUNC
597  * @tc.require:
598  */
599 HWTEST_F(AccountManagerTest, AccountManagerTest_OnReceiveEvent, TestSize.Level1)
600 {
601     CALL_TEST_DEBUG;
602     EventFwk::CommonEventData data;
603     auto subscriber = ACCOUNT_MGR->subscriber_;
604     ASSERT_NE(subscriber, nullptr);
605     ASSERT_NO_FATAL_FAILURE(subscriber->OnReceiveEvent(data));
606 }
607 
608 /**
609  * @tc.name: AccountManagerTest_Operator
610  * @tc.desc: Test the funcation operator=
611  * @tc.type: FUNC
612  * @tc.require:
613  */
614 HWTEST_F(AccountManagerTest, AccountManagerTest_Operator, TestSize.Level1)
615 {
616     CALL_TEST_DEBUG;
617     int32_t accountId = 3;
618     int32_t timeout = 5000;
619     AccountManager::AccountSetting accountSetting(accountId);
620     accountSetting.accShortcutEnabled_ = true;
621     accountSetting.accShortcutEnabledOnScreenLocked_ = true;
622     accountSetting.accShortcutTimeout_ = timeout;
623     AccountManager::AccountSetting accountSetting1 = accountSetting;
624     EXPECT_EQ(accountSetting1.accountId_, accountId);
625     EXPECT_TRUE(accountSetting1.accShortcutEnabled_);
626     EXPECT_TRUE(accountSetting1.accShortcutEnabledOnScreenLocked_);
627     EXPECT_EQ(accountSetting1.accShortcutTimeout_, timeout);
628 }
629 
630 /**
631  * @tc.name: AccountManagerTest_SetupMainAccount
632  * @tc.desc: Test the funcation SetupMainAccount
633  * @tc.type: FUNC
634  * @tc.require:
635  */
636 HWTEST_F(AccountManagerTest, AccountManagerTest_SetupMainAccount, TestSize.Level1)
637 {
638     CALL_TEST_DEBUG;
639     ACCOUNT_MGR->accounts_.clear();
640     auto ret = ACCOUNT_MGR->accounts_.emplace(MAIN_ACCOUNT_ID,
641                                                     std::make_unique<AccountManager::AccountSetting>(MAIN_ACCOUNT_ID));
642     EXPECT_TRUE(ret.second);
643     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->SetupMainAccount());
644 
645     ret = ACCOUNT_MGR->accounts_.emplace(MAIN_ACCOUNT_ID,
646                                                     std::make_unique<AccountManager::AccountSetting>(MAIN_ACCOUNT_ID));
647     EXPECT_FALSE(ret.second);
648     ASSERT_NO_FATAL_FAILURE(ACCOUNT_MGR->SetupMainAccount());
649 }
650 } // namespace MMI
651 } // namespace OHOS