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 EXPECT_TRUE(currentAccount != nullptr);
130 std::shared_ptr<AccessibilitySettingsConfig> config = currentAccount->GetConfig();
131 EXPECT_TRUE(config != nullptr);
132 config->SetCaptionState(true);
133
134 std::string cmdUser("-u");
135 std::vector<std::u16string> args;
136 args.emplace_back(Str8ToStr16(cmdUser));
137 int ret = dumper_->Dump(fd_, args);
138 EXPECT_GE(ret, -1);
139
140 GTEST_LOG_(INFO) << "AccessibilityDumper_Unittest_Dump_004 end";
141 }
142
143 /**
144 * @tc.number: AccessibilityDumper_Unittest_Dump_005
145 * @tc.name: Dump
146 * @tc.desc: Test function Dump
147 */
148 HWTEST_F(AccessibilityDumperUnitTest, AccessibilityDumper_Unittest_Dump_005, TestSize.Level1)
149 {
150 GTEST_LOG_(INFO) << "AccessibilityDumper_Unittest_Dump_005 start";
151 AccessibilityAbilityInitParams initParams;
152 initParams.bundleName = "ohos";
153 initParams.moduleName = "accessibility";
154 initParams.name = "test";
155 initParams.description = "for dumper-ut";
156 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
157 sptr<AccessibilityAccountData> currentAccount
158 = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
159 EXPECT_TRUE(currentAccount != nullptr);
160 sptr<AccessibleAbilityConnection> connection
161 = new MockAccessibleAbilityConnection(currentAccount->GetAccountId(), 0, *abilityInfo);
162 EXPECT_TRUE(connection != nullptr);
163 currentAccount->AddConnectedAbility(connection);
164
165 std::string cmdClient("-c");
166 std::vector<std::u16string> args;
167 args.emplace_back(Str8ToStr16(cmdClient));
168 int ret = dumper_->Dump(fd_, args);
169 EXPECT_GE(ret, -1);
170
171 currentAccount->RemoveConnectedAbility(connection->GetElementName());
172 GTEST_LOG_(INFO) << "AccessibilityDumper_Unittest_Dump_005 end";
173 }
174
175 /**
176 * @tc.number: AccessibilityDumper_Unittest_Dump_006
177 * @tc.name: Dump
178 * @tc.desc: Test function Dump.
179 */
180 HWTEST_F(AccessibilityDumperUnitTest, AccessibilityDumper_Unittest_Dump_006, TestSize.Level1)
181 {
182 GTEST_LOG_(INFO) << "AccessibilityDumper_Unittest_Dump_006 start";
183 const int32_t accountId = 1;
184 const int32_t windowId = 1;
185 sptr<AccessibilityAccountData> currentAccount
186 = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
187 if (!currentAccount) {
188 GTEST_LOG_(ERROR) << "Account data is nullptr";
189 } else {
190 sptr<AccessibilityWindowConnection> operationConnection
191 = new AccessibilityWindowConnection(windowId, nullptr, accountId);
192 /* add asacConnections */
193 currentAccount->AddAccessibilityWindowConnection(windowId, operationConnection);
194
195 std::string cmdWindow("-w");
196 std::vector<std::u16string> args;
197 args.emplace_back(Str8ToStr16(cmdWindow));
198 int ret = dumper_->Dump(fd_, args);
199 EXPECT_GE(ret, -1);
200
201 currentAccount->RemoveAccessibilityWindowConnection(windowId);
202 }
203 GTEST_LOG_(INFO) << "AccessibilityDumper_Unittest_Dump_006 end";
204 }
205
206 /**
207 * @tc.number: AccessibilityDumper_Unittest_Dump_007
208 * @tc.name: Dump
209 * @tc.desc: Test function Dump
210 */
211 HWTEST_F(AccessibilityDumperUnitTest, AccessibilityDumper_Unittest_Dump_007, TestSize.Level1)
212 {
213 GTEST_LOG_(INFO) << "AccessibilityDumper_Unittest_Dump_007 start";
214 sptr<AccessibilityAccountData> currentAccount
215 = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
216
217 std::shared_ptr<AccessibilitySettingsConfig> config = currentAccount->GetConfig();
218 if (!config) {
219 GTEST_LOG_(ERROR) << "Config is nullptr";
220 } else {
221 config->SetCaptionState(true);
222
223 std::string cmdUser("-u");
224 std::vector<std::u16string> args;
225 args.emplace_back(Str8ToStr16(cmdUser));
226 AccessibilityAbilityHelper::GetInstance().SetNeedAccountDataNullFlag(true);
227 int ret = dumper_->Dump(fd_, args);
228 EXPECT_GE(ret, -1);
229 AccessibilityAbilityHelper::GetInstance().SetNeedAccountDataNullFlag(false);
230 }
231 GTEST_LOG_(INFO) << "AccessibilityDumper_Unittest_Dump_007 end";
232 }
233
234 /**
235 * @tc.number: AccessibilityDumper_Unittest_Dump_008
236 * @tc.name: Dump
237 * @tc.desc: Test function Dump
238 */
239 HWTEST_F(AccessibilityDumperUnitTest, AccessibilityDumper_Unittest_Dump_008, TestSize.Level1)
240 {
241 GTEST_LOG_(INFO) << "AccessibilityDumper_Unittest_Dump_005 start";
242 AccessibilityAbilityInitParams initParams;
243 initParams.bundleName = "ohos";
244 initParams.moduleName = "accessibility";
245 initParams.name = "test";
246 initParams.description = "for dumper-ut";
247 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
248 sptr<AccessibilityAccountData> currentAccount =
249 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
250 EXPECT_TRUE(currentAccount != nullptr);
251 sptr<AccessibleAbilityConnection> connection =
252 new MockAccessibleAbilityConnection(currentAccount->GetAccountId(), 0, *abilityInfo);
253 EXPECT_TRUE(connection != nullptr);
254 currentAccount->AddConnectedAbility(connection);
255
256 std::string cmdClient("-c");
257 std::vector<std::u16string> args;
258 args.emplace_back(Str8ToStr16(cmdClient));
259 AccessibilityAbilityHelper::GetInstance().SetNeedAccountDataNullFlag(true);
260 int ret = dumper_->Dump(fd_, args);
261 AccessibilityAbilityHelper::GetInstance().SetNeedAccountDataNullFlag(false);
262 EXPECT_GE(ret, -1);
263
264 currentAccount->RemoveConnectedAbility(connection->GetElementName());
265 GTEST_LOG_(INFO) << "AccessibilityDumper_Unittest_Dump_008 end";
266 }
267
268 /**
269 * @tc.number: AccessibilityDumper_Unittest_Dump_009
270 * @tc.name: Dump
271 * @tc.desc: Test function Dump.
272 */
273 HWTEST_F(AccessibilityDumperUnitTest, AccessibilityDumper_Unittest_Dump_009, TestSize.Level1)
274 {
275 GTEST_LOG_(INFO) << "AccessibilityDumper_Unittest_Dump_009 start";
276 const int32_t accountId = 1;
277 const int32_t windowId = 1;
278 sptr<AccessibilityAccountData> currentAccount
279 = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
280 if (!currentAccount) {
281 GTEST_LOG_(ERROR) << "Account data is nullptr";
282 } else {
283 sptr<AccessibilityWindowConnection> operationConnection
284 = new AccessibilityWindowConnection(windowId, nullptr, accountId);
285 /* add asacConnections */
286 currentAccount->AddAccessibilityWindowConnection(windowId, operationConnection);
287
288 std::string cmdWindow("-w");
289 std::vector<std::u16string> args;
290 args.emplace_back(Str8ToStr16(cmdWindow));
291 AccessibilityAbilityHelper::GetInstance().SetNeedAccountDataNullFlag(true);
292 int ret = dumper_->Dump(fd_, args);
293 EXPECT_GE(ret, -1);
294 AccessibilityAbilityHelper::GetInstance().SetNeedAccountDataNullFlag(false);
295 currentAccount->RemoveAccessibilityWindowConnection(windowId);
296 }
297 GTEST_LOG_(INFO) << "AccessibilityDumper_Unittest_Dump_009 end";
298 }
299 } // namespace Accessibility
300 } // namespace OHOS