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 <fcntl.h>
17 #include <gtest/gtest.h>
18 #include <unistd.h>
19 #include "accessibility_dumper.h"
20 #include "accessibility_ut_helper.h"
21 #include "mock_accessible_ability_connection.h"
22 #include "mock_accessible_ability_manager_service.h"
23 #include "string_ex.h"
24
25 using namespace testing;
26 using namespace testing::ext;
27
28 namespace OHOS {
29 namespace Accessibility {
30 class AccessibilityDumperUnitTest : public ::testing::Test {
31 public:
AccessibilityDumperUnitTest()32 AccessibilityDumperUnitTest()
33 {}
~AccessibilityDumperUnitTest()34 ~AccessibilityDumperUnitTest()
35 {}
36
37 static void SetUpTestCase();
38 static void TearDownTestCase();
39 void SetUp() override;
40 void TearDown() override;
41
42 int fd_ = -1;
43 sptr<AccessibilityDumper> dumper_ = nullptr;
44 };
45
SetUpTestCase()46 void AccessibilityDumperUnitTest::SetUpTestCase()
47 {
48 GTEST_LOG_(INFO) << "###################### AccessibilityDumperUnitTest Start ######################";
49 }
50
TearDownTestCase()51 void AccessibilityDumperUnitTest::TearDownTestCase()
52 {
53 GTEST_LOG_(INFO) << "###################### AccessibilityDumperUnitTest End ######################";
54 }
55
SetUp()56 void AccessibilityDumperUnitTest::SetUp()
57 {
58 fd_ = open("/dev/stdout", O_WRONLY);
59 dumper_ = new AccessibilityDumper();
60 }
61
TearDown()62 void AccessibilityDumperUnitTest::TearDown()
63 {
64 close(fd_);
65 fd_ = -1;
66 dumper_ = nullptr;
67 }
68
69 /**
70 * @tc.number: AccessibilityDumper_Unittest_Dump_001
71 * @tc.name: Dump
72 * @tc.desc: Test function Dump
73 */
74 HWTEST_F(AccessibilityDumperUnitTest, AccessibilityDumper_Unittest_Dump_001, TestSize.Level1)
75 {
76 GTEST_LOG_(INFO) << "AccessibilityDumper_Unittest_Dump_001 start";
77
78 std::vector<std::u16string> args;
79 int ret = dumper_->Dump(-1, args);
80 EXPECT_EQ(-1, ret);
81
82 GTEST_LOG_(INFO) << "AccessibilityDumper_Unittest_Dump_001 end";
83 }
84
85 /**
86 * @tc.number: AccessibilityDumper_Unittest_Dump_002
87 * @tc.name: Dump
88 * @tc.desc: Test function Dump
89 */
90 HWTEST_F(AccessibilityDumperUnitTest, AccessibilityDumper_Unittest_Dump_002, TestSize.Level1)
91 {
92 GTEST_LOG_(INFO) << "AccessibilityDumper_Unittest_Dump_002 start";
93
94 std::vector<std::u16string> args;
95 int ret = dumper_->Dump(fd_, args);
96 EXPECT_GE(ret, -1);
97
98 GTEST_LOG_(INFO) << "AccessibilityDumper_Unittest_Dump_002 end";
99 }
100
101 /**
102 * @tc.number: AccessibilityDumper_Unittest_Dump_003
103 * @tc.name: Dump
104 * @tc.desc: Test function Dump
105 */
106 HWTEST_F(AccessibilityDumperUnitTest, AccessibilityDumper_Unittest_Dump_003, TestSize.Level1)
107 {
108 GTEST_LOG_(INFO) << "AccessibilityDumper_Unittest_Dump_003 start";
109
110 std::string cmdHelp("-h");
111 std::vector<std::u16string> args;
112 args.emplace_back(Str8ToStr16(cmdHelp));
113 int ret = dumper_->Dump(fd_, args);
114 EXPECT_GE(ret, -1);
115
116 GTEST_LOG_(INFO) << "AccessibilityDumper_Unittest_Dump_003 end";
117 }
118
119 /**
120 * @tc.number: AccessibilityDumper_Unittest_Dump_004
121 * @tc.name: Dump
122 * @tc.desc: Test function Dump
123 */
124 HWTEST_F(AccessibilityDumperUnitTest, AccessibilityDumper_Unittest_Dump_004, TestSize.Level1)
125 {
126 GTEST_LOG_(INFO) << "AccessibilityDumper_Unittest_Dump_004 start";
127 sptr<AccessibilityAccountData> currentAccount =
128 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
129 if (!currentAccount) {
130 GTEST_LOG_(ERROR) << "Account data is nullptr";
131 return;
132 }
133 std::shared_ptr<AccessibilitySettingsConfig> config = currentAccount->GetConfig();
134 if (!config) {
135 GTEST_LOG_(ERROR) << "Config is nullptr";
136 return;
137 }
138 config->SetCaptionState(true);
139
140 std::string cmdUser("-u");
141 std::vector<std::u16string> args;
142 args.emplace_back(Str8ToStr16(cmdUser));
143 int ret = dumper_->Dump(fd_, args);
144 EXPECT_GE(ret, -1);
145
146 GTEST_LOG_(INFO) << "AccessibilityDumper_Unittest_Dump_004 end";
147 }
148
149 /**
150 * @tc.number: AccessibilityDumper_Unittest_Dump_005
151 * @tc.name: Dump
152 * @tc.desc: Test function Dump
153 */
154 HWTEST_F(AccessibilityDumperUnitTest, AccessibilityDumper_Unittest_Dump_005, TestSize.Level1)
155 {
156 GTEST_LOG_(INFO) << "AccessibilityDumper_Unittest_Dump_005 start";
157 AccessibilityAbilityInitParams initParams;
158 initParams.bundleName = "ohos";
159 initParams.moduleName = "accessibility";
160 initParams.name = "test";
161 initParams.description = "for dumper-ut";
162 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
163 sptr<AccessibilityAccountData> currentAccount =
164 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
165 if (!currentAccount) {
166 GTEST_LOG_(ERROR) << "Account data is nullptr";
167 return;
168 }
169 sptr<AccessibleAbilityConnection> connection =
170 new MockAccessibleAbilityConnection(currentAccount->GetAccountId(), 0, *abilityInfo);
171 if (!connection) {
172 GTEST_LOG_(ERROR) << "Connection is nullptr";
173 return;
174 }
175 currentAccount->AddConnectedAbility(connection);
176
177 std::string cmdClient("-c");
178 std::vector<std::u16string> args;
179 args.emplace_back(Str8ToStr16(cmdClient));
180 int ret = dumper_->Dump(fd_, args);
181 EXPECT_GE(ret, -1);
182
183 currentAccount->RemoveConnectedAbility(connection->GetElementName());
184 GTEST_LOG_(INFO) << "AccessibilityDumper_Unittest_Dump_005 end";
185 }
186
187 /**
188 * @tc.number: AccessibilityDumper_Unittest_Dump_006
189 * @tc.name: Dump
190 * @tc.desc: Test function Dump.
191 */
192 HWTEST_F(AccessibilityDumperUnitTest, AccessibilityDumper_Unittest_Dump_006, TestSize.Level1)
193 {
194 GTEST_LOG_(INFO) << "AccessibilityDumper_Unittest_Dump_006 start";
195 const int32_t accountId = 1;
196 const int32_t windowId = 1;
197 sptr<AccessibilityAccountData> currentAccount =
198 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
199 if (!currentAccount) {
200 GTEST_LOG_(ERROR) << "Account data is nullptr";
201 return;
202 }
203 sptr<AccessibilityWindowConnection> operationConnection =
204 new AccessibilityWindowConnection(windowId, nullptr, accountId);
205 /* add asacConnections */
206 currentAccount->AddAccessibilityWindowConnection(windowId, operationConnection);
207
208 std::string cmdWindow("-w");
209 std::vector<std::u16string> args;
210 args.emplace_back(Str8ToStr16(cmdWindow));
211 int ret = dumper_->Dump(fd_, args);
212 EXPECT_GE(ret, -1);
213
214 currentAccount->RemoveAccessibilityWindowConnection(windowId);
215 GTEST_LOG_(INFO) << "AccessibilityDumper_Unittest_Dump_006 end";
216 }
217
218 /**
219 * @tc.number: AccessibilityDumper_Unittest_Dump_007
220 * @tc.name: Dump
221 * @tc.desc: Test function Dump
222 */
223 HWTEST_F(AccessibilityDumperUnitTest, AccessibilityDumper_Unittest_Dump_007, TestSize.Level1)
224 {
225 GTEST_LOG_(INFO) << "AccessibilityDumper_Unittest_Dump_007 start";
226 sptr<AccessibilityAccountData> currentAccount =
227 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
228
229 std::shared_ptr<AccessibilitySettingsConfig> config = currentAccount->GetConfig();
230 if (!config) {
231 GTEST_LOG_(ERROR) << "Config is nullptr";
232 return;
233 }
234 config->SetCaptionState(true);
235
236 std::string cmdUser("-u");
237 std::vector<std::u16string> args;
238 args.emplace_back(Str8ToStr16(cmdUser));
239 AccessibilityAbilityHelper::GetInstance().SetNeedAccountDataNullFlag(true);
240 int ret = dumper_->Dump(fd_, args);
241 EXPECT_GE(ret, -1);
242 AccessibilityAbilityHelper::GetInstance().SetNeedAccountDataNullFlag(false);
243 GTEST_LOG_(INFO) << "AccessibilityDumper_Unittest_Dump_007 end";
244 }
245
246 /**
247 * @tc.number: AccessibilityDumper_Unittest_Dump_008
248 * @tc.name: Dump
249 * @tc.desc: Test function Dump
250 */
251 HWTEST_F(AccessibilityDumperUnitTest, AccessibilityDumper_Unittest_Dump_008, TestSize.Level1)
252 {
253 GTEST_LOG_(INFO) << "AccessibilityDumper_Unittest_Dump_005 start";
254 AccessibilityAbilityInitParams initParams;
255 initParams.bundleName = "ohos";
256 initParams.moduleName = "accessibility";
257 initParams.name = "test";
258 initParams.description = "for dumper-ut";
259 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
260 sptr<AccessibilityAccountData> currentAccount =
261 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
262 if (!currentAccount) {
263 GTEST_LOG_(ERROR) << "Account data is nullptr";
264 return;
265 }
266 sptr<AccessibleAbilityConnection> connection =
267 new MockAccessibleAbilityConnection(currentAccount->GetAccountId(), 0, *abilityInfo);
268 if (!connection) {
269 GTEST_LOG_(ERROR) << "Connection is nullptr";
270 return;
271 }
272 currentAccount->AddConnectedAbility(connection);
273
274 std::string cmdClient("-c");
275 std::vector<std::u16string> args;
276 args.emplace_back(Str8ToStr16(cmdClient));
277 AccessibilityAbilityHelper::GetInstance().SetNeedAccountDataNullFlag(true);
278 int ret = dumper_->Dump(fd_, args);
279 AccessibilityAbilityHelper::GetInstance().SetNeedAccountDataNullFlag(false);
280 EXPECT_GE(ret, -1);
281
282 currentAccount->RemoveConnectedAbility(connection->GetElementName());
283 GTEST_LOG_(INFO) << "AccessibilityDumper_Unittest_Dump_008 end";
284 }
285
286 /**
287 * @tc.number: AccessibilityDumper_Unittest_Dump_009
288 * @tc.name: Dump
289 * @tc.desc: Test function Dump.
290 */
291 HWTEST_F(AccessibilityDumperUnitTest, AccessibilityDumper_Unittest_Dump_009, TestSize.Level1)
292 {
293 GTEST_LOG_(INFO) << "AccessibilityDumper_Unittest_Dump_009 start";
294 const int32_t accountId = 1;
295 const int32_t windowId = 1;
296 sptr<AccessibilityAccountData> currentAccount =
297 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
298 if (!currentAccount) {
299 GTEST_LOG_(ERROR) << "Account data is nullptr";
300 return;
301 }
302 sptr<AccessibilityWindowConnection> operationConnection =
303 new AccessibilityWindowConnection(windowId, nullptr, accountId);
304 /* add asacConnections */
305 currentAccount->AddAccessibilityWindowConnection(windowId, operationConnection);
306
307 std::string cmdWindow("-w");
308 std::vector<std::u16string> args;
309 args.emplace_back(Str8ToStr16(cmdWindow));
310 AccessibilityAbilityHelper::GetInstance().SetNeedAccountDataNullFlag(true);
311 int ret = dumper_->Dump(fd_, args);
312 EXPECT_GE(ret, -1);
313 AccessibilityAbilityHelper::GetInstance().SetNeedAccountDataNullFlag(false);
314 currentAccount->RemoveAccessibilityWindowConnection(windowId);
315 GTEST_LOG_(INFO) << "AccessibilityDumper_Unittest_Dump_009 end";
316 }
317 } // namespace Accessibility
318 } // namespace OHOS