1 /*
2 * Copyright (C) 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 <gtest/gtest.h>
17 #include "accessibility_common_event.h"
18 #include "accessibility_ut_helper.h"
19 #include "accessible_ability_manager_service.h"
20 #include "common_event_manager.h"
21 #include "common_event_support.h"
22 #include "iservice_registry.h"
23 #include "mock_bundle_manager.h"
24
25 using namespace testing;
26 using namespace testing::ext;
27 using namespace OHOS::EventFwk;
28
29 namespace OHOS {
30 namespace Accessibility {
31 namespace {
32 constexpr int32_t USERID_1 = 1;
33 constexpr int32_t SLEEP_TIME = 1;
34 const std::string BUNDLE_NAME = "test";
35 }
36 class AccessibilityCommonEventUnitTest : public ::testing::Test {
37 public:
AccessibilityCommonEventUnitTest()38 AccessibilityCommonEventUnitTest()
39 {}
~AccessibilityCommonEventUnitTest()40 ~AccessibilityCommonEventUnitTest()
41 {}
42
43 static void SetUpTestCase();
44 static void TearDownTestCase();
45 void SetUp() override;
46 void TearDown() override;
47
48 std::shared_ptr<CommonEventManager> commonEventManagerMock_ = nullptr;
49 };
50
SetUpTestCase()51 void AccessibilityCommonEventUnitTest::SetUpTestCase()
52 {
53 GTEST_LOG_(INFO) << "###################### AccessibilityCommonEventUnitTest Start ######################";
54 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStart();
55 }
56
TearDownTestCase()57 void AccessibilityCommonEventUnitTest::TearDownTestCase()
58 {
59 GTEST_LOG_(INFO) << "###################### AccessibilityCommonEventUnitTest End ######################";
60 Singleton<AccessibilityCommonEvent>::GetInstance().UnSubscriberEvent();
61 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStop();
62 }
63
SetUp()64 void AccessibilityCommonEventUnitTest::SetUp()
65 {
66 GTEST_LOG_(INFO) << "SetUp";
67 }
68
TearDown()69 void AccessibilityCommonEventUnitTest::TearDown()
70 {
71 GTEST_LOG_(INFO) << "TearDown";
72 }
73
74 /**
75 * @tc.number: AccessibilityCommonEvent_Unittest_HandleUserRemoved_001
76 * @tc.name: HandleUserRemoved
77 * @tc.desc: Test function HandleUserRemoved(remove fail)
78 */
79 HWTEST_F(AccessibilityCommonEventUnitTest, AccessibilityCommonEvent_Unittest_HandleUserRemoved_001,
80 TestSize.Level1)
81 {
82 GTEST_LOG_(INFO) << "AccessibilityCommonEvent_Unittest_HandleUserRemoved_001 start";
83
84 CommonEventData data;
85 Want want;
86 want.SetAction(CommonEventSupport::COMMON_EVENT_USER_REMOVED);
87 data.SetWant(want);
88 data.SetCode(-1);
89 CommonEventManager::PublishCommonEvent(data);
90 sleep(SLEEP_TIME);
91 std::vector<int32_t> userIds;
92 AccessibilityAbilityHelper::GetInstance().GetUserIds(userIds);
93 EXPECT_EQ(0, userIds.size());
94
95 GTEST_LOG_(INFO) << "AccessibilityCommonEvent_Unittest_HandleUserRemoved_001 end";
96 }
97
98 /**
99 * @tc.number: AccessibilityCommonEvent_Unittest_HandleUserRemoved_002
100 * @tc.name: HandleUserRemoved
101 * @tc.desc: Test function HandleUserRemoved(add/remove success)
102 */
103 HWTEST_F(AccessibilityCommonEventUnitTest, AccessibilityCommonEvent_Unittest_HandleUserRemoved_002,
104 TestSize.Level1)
105 {
106 GTEST_LOG_(INFO) << "AccessibilityCommonEvent_Unittest_HandleUserRemoved_002 start";
107
108 CommonEventData data1;
109 Want want1;
110 want1.SetAction(CommonEventSupport::COMMON_EVENT_USER_ADDED);
111 data1.SetWant(want1);
112 data1.SetCode(USERID_1);
113 CommonEventManager::PublishCommonEvent(data1);
114 sleep(SLEEP_TIME);
115 std::vector<int32_t> userIds;
116 AccessibilityAbilityHelper::GetInstance().GetUserIds(userIds);
117 EXPECT_EQ(1, userIds.size());
118
119 CommonEventData data2;
120 Want want2;
121 want2.SetAction(CommonEventSupport::COMMON_EVENT_USER_REMOVED);
122 data2.SetWant(want2);
123 data2.SetCode(USERID_1);
124 CommonEventManager::PublishCommonEvent(data2);
125 sleep(SLEEP_TIME);
126 userIds.clear();
127 AccessibilityAbilityHelper::GetInstance().GetUserIds(userIds);
128 EXPECT_EQ(0, userIds.size());
129
130 GTEST_LOG_(INFO) << "AccessibilityCommonEvent_Unittest_HandleUserRemoved_002 end";
131 }
132
133 /**
134 * @tc.number: AccessibilityCommonEvent_Unittest_HandleUserAdded_001
135 * @tc.name: HandleUserAdded
136 * @tc.desc: Test function HandleUserAdded(add fail)
137 */
138 HWTEST_F(AccessibilityCommonEventUnitTest, AccessibilityCommonEvent_Unittest_HandleUserAdded_001,
139 TestSize.Level1)
140 {
141 GTEST_LOG_(INFO) << "AccessibilityCommonEvent_Unittest_HandleUserAdded_001 start";
142
143 CommonEventData data;
144 Want want;
145 want.SetAction(CommonEventSupport::COMMON_EVENT_USER_ADDED);
146 data.SetWant(want);
147 data.SetCode(-1);
148 CommonEventManager::PublishCommonEvent(data);
149 sleep(SLEEP_TIME);
150 std::vector<int32_t> userIds;
151 AccessibilityAbilityHelper::GetInstance().GetUserIds(userIds);
152 EXPECT_EQ(0, userIds.size());
153
154 GTEST_LOG_(INFO) << "AccessibilityCommonEvent_Unittest_HandleUserAdded_001 end";
155 }
156
157 /**
158 * @tc.number: AccessibilityCommonEvent_Unittest_HandleUserSwitched_001
159 * @tc.name: HandleUserSwitched
160 * @tc.desc: Test function HandleUserSwitched(switch success)
161 */
162 HWTEST_F(AccessibilityCommonEventUnitTest, AccessibilityCommonEvent_Unittest_HandleUserSwitched_001,
163 TestSize.Level1)
164 {
165 GTEST_LOG_(INFO) << "AccessibilityCommonEvent_Unittest_HandleUserSwitched_001 start";
166
167 CommonEventData data;
168 Want want;
169 want.SetAction(CommonEventSupport::COMMON_EVENT_USER_SWITCHED);
170 data.SetWant(want);
171 data.SetCode(USERID_1);
172 CommonEventManager::PublishCommonEvent(data);
173 sleep(SLEEP_TIME);
174 int32_t userId = AccessibilityAbilityHelper::GetInstance().GetCurrentUserId();
175 EXPECT_EQ(USERID_1, userId);
176
177 GTEST_LOG_(INFO) << "AccessibilityCommonEvent_Unittest_HandleUserSwitched_001 end";
178 }
179
180 /**
181 * @tc.number: AccessibilityCommonEvent_Unittest_HandleUserSwitched_002
182 * @tc.name: HandleUserSwitched
183 * @tc.desc: Test function HandleUserSwitched(switch fail)
184 */
185 HWTEST_F(AccessibilityCommonEventUnitTest, AccessibilityCommonEvent_Unittest_HandleUserSwitched_002,
186 TestSize.Level1)
187 {
188 GTEST_LOG_(INFO) << "AccessibilityCommonEvent_Unittest_HandleUserSwitched_002 start";
189
190 AccessibilityAbilityHelper::GetInstance().SetCurrentUserId(USERID_1);
191 CommonEventData data;
192 Want want;
193 want.SetAction(CommonEventSupport::COMMON_EVENT_USER_SWITCHED);
194 data.SetWant(want);
195 data.SetCode(-1);
196 CommonEventManager::PublishCommonEvent(data);
197 sleep(SLEEP_TIME);
198 int32_t userId = AccessibilityAbilityHelper::GetInstance().GetCurrentUserId();
199 EXPECT_EQ(USERID_1, userId);
200
201 GTEST_LOG_(INFO) << "AccessibilityCommonEvent_Unittest_HandleUserSwitched_002 end";
202 }
203
204 /**
205 * @tc.number: AccessibilityCommonEvent_Unittest_HandlePackageRemoved_001
206 * @tc.name: HandlePackageRemoved
207 * @tc.desc: Test function HandlePackageRemoved(add/remove success)
208 */
209 HWTEST_F(AccessibilityCommonEventUnitTest, AccessibilityCommonEvent_Unittest_HandlePackageRemoved_001,
210 TestSize.Level1)
211 {
212 GTEST_LOG_(INFO) << "AccessibilityCommonEvent_Unittest_HandlePackageRemoved_001 start";
213
214 CommonEventData data1;
215 Want want1;
216 want1.SetAction(CommonEventSupport::COMMON_EVENT_PACKAGE_ADDED);
217 want1.SetBundle(BUNDLE_NAME);
218 want1.SetParam("userId", -1);
219 data1.SetWant(want1);
220 CommonEventManager::PublishCommonEvent(data1);
221 sleep(SLEEP_TIME);
222 std::vector<std::string> packages;
223 AccessibilityAbilityHelper::GetInstance().GetPackages(packages);
224 EXPECT_EQ(1, packages.size());
225
226 CommonEventData data2;
227 Want want2;
228 want2.SetAction(CommonEventSupport::COMMON_EVENT_PACKAGE_REMOVED);
229 want2.SetBundle(BUNDLE_NAME);
230 data2.SetWant(want2);
231 CommonEventManager::PublishCommonEvent(data2);
232 sleep(SLEEP_TIME);
233 packages.clear();
234 AccessibilityAbilityHelper::GetInstance().GetPackages(packages);
235 EXPECT_EQ(1, packages.size());
236
237 GTEST_LOG_(INFO) << "AccessibilityCommonEvent_Unittest_HandlePackageRemoved_001 end";
238 }
239
240 /**
241 * @tc.number: AccessibilityCommonEvent_Unittest_HandlePackageChanged_001
242 * @tc.name: HandlePackageChanged
243 * @tc.desc: Test function HandlePackageChanged
244 */
245 HWTEST_F(AccessibilityCommonEventUnitTest, AccessibilityCommonEvent_Unittest_HandlePackageChanged_001,
246 TestSize.Level1)
247 {
248 GTEST_LOG_(INFO) << "AccessibilityCommonEvent_Unittest_HandlePackageChanged_001 start";
249
250 CommonEventData data;
251 Want want;
252 want.SetAction(CommonEventSupport::COMMON_EVENT_PACKAGE_CHANGED);
253 want.SetBundle(BUNDLE_NAME);
254 want.SetParam("userId", -1);
255 data.SetWant(want);
256 CommonEventManager::PublishCommonEvent(data);
257 sleep(SLEEP_TIME);
258
259 EXPECT_TRUE(AccessibilityAbilityHelper::GetInstance().GetChangePackageFlag());
260 GTEST_LOG_(INFO) << "AccessibilityCommonEvent_Unittest_HandlePackageChanged_001 end";
261 }
262 } // namespace Accessibility
263 } // namespace OHOS