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