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 "event_handler.h"
18 #include "accessibility_account_data.h"
19 #include "accessibility_common_helper.h"
20 #include "accessibility_element_operator_proxy.h"
21 #include "accessibility_ut_helper.h"
22 #include "accessibility_window_manager.h"
23 #include "accessible_ability_manager_service.h"
24 #include "iservice_registry.h"
25 #include "mock_accessible_ability_manager_service.h"
26 #include "mock_accessibility_element_operator_proxy.h"
27 #include "mock_accessibility_element_operator_stub.h"
28 #include "mock_bundle_manager.h"
29
30 using namespace testing;
31 using namespace testing::ext;
32
33 namespace OHOS {
34 namespace Accessibility {
35 namespace {
36 constexpr int RETRY_TIMES = 10;
37 constexpr int WINDOW_ID = 2;
38 constexpr int WINDOWS_SIZE = 2;
39 constexpr int SEND_EVENT_TIMES = 2;
40 constexpr int32_t ACCOUNT_ID = 100;
41 } // namespace
42
43 class AccessibilityWindowManagerTest : public testing::Test {
44 public:
AccessibilityWindowManagerTest()45 AccessibilityWindowManagerTest()
46 {}
~AccessibilityWindowManagerTest()47 ~AccessibilityWindowManagerTest()
48 {}
49
50 static void SetUpTestCase();
51 static void TearDownTestCase();
52 static void AddActiveWindow(AccessibilityWindowManager &windowInfoManager,
53 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfoFirst);
54 static void AddNormalWindow(AccessibilityWindowManager &windowInfoManager,
55 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfoSecond);
56 void SetUp() override;
57 void TearDown() override;
58 };
59
SetUpTestCase()60 void AccessibilityWindowManagerTest::SetUpTestCase()
61 {
62 GTEST_LOG_(INFO) << "AccessibilityWindowManagerTest SetUpTestCase";
63 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStart();
64 }
65
TearDownTestCase()66 void AccessibilityWindowManagerTest::TearDownTestCase()
67 {
68 GTEST_LOG_(INFO) << "AccessibilityWindowManagerTest TearDownTestCase";
69 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStop();
70 }
71
SetUp()72 void AccessibilityWindowManagerTest::SetUp()
73 {
74 GTEST_LOG_(INFO) << "AccessibilityWindowManagerTest SetUp";
75 AccessibilityAbilityHelper::GetInstance().ClearSendEventTimes();
76 }
77
TearDown()78 void AccessibilityWindowManagerTest::TearDown()
79 {
80 GTEST_LOG_(INFO) << "AccessibilityWindowManagerTest TearDown";
81 }
82
GetRosenWindowInfo(Rosen::WindowType windowType)83 sptr<Rosen::AccessibilityWindowInfo> GetRosenWindowInfo(Rosen::WindowType windowType)
84 {
85 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = new(std::nothrow) Rosen::AccessibilityWindowInfo();
86 if (rosen_winInfo != nullptr) {
87 rosen_winInfo->type_ = windowType;
88 rosen_winInfo->wid_ = 1;
89 rosen_winInfo->windowRect_.width_ = 1;
90 rosen_winInfo->windowRect_.height_ = 1;
91 rosen_winInfo->windowRect_.posX_ = 1;
92 rosen_winInfo->windowRect_.posY_ = 1;
93 rosen_winInfo->focused_ = true;
94 rosen_winInfo->innerWid_ = 1;
95 }
96 return rosen_winInfo;
97 }
98
AddActiveWindow(AccessibilityWindowManager & windowInfoManager,sptr<Rosen::AccessibilityWindowInfo> rosenWinInfoFirst)99 void AccessibilityWindowManagerTest::AddActiveWindow(AccessibilityWindowManager &windowInfoManager,
100 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfoFirst)
101 {
102 rosenWinInfoFirst->type_ = Rosen::WindowType::WINDOW_TYPE_APP_MAIN_WINDOW;
103 rosenWinInfoFirst->wid_ = 1;
104 rosenWinInfoFirst->focused_ = false;
105 Rosen::Rect rect;
106 rect.posX_ = 1;
107 rect.posY_ = 1;
108 rect.width_ = 1;
109 rect.height_ = 1;
110 rosenWinInfoFirst->windowRect_ = rect;
111 rosenWinInfoFirst->mode_ = Rosen::WindowMode::WINDOW_MODE_PIP;
112 rosenWinInfoFirst->isDecorEnable_ = false;
113 rosenWinInfoFirst->displayId_ = 0;
114 rosenWinInfoFirst->innerWid_ = 1;
115 windowInfoManager.a11yWindows_.insert(std::make_pair(rosenWinInfoFirst->wid_,
116 windowInfoManager.CreateAccessibilityWindowInfo(rosenWinInfoFirst)));
117 EXPECT_EQ(windowInfoManager.a11yWindows_.size(), 1);
118 }
119
AddNormalWindow(AccessibilityWindowManager & windowInfoManager,sptr<Rosen::AccessibilityWindowInfo> rosenWinInfoSecond)120 void AccessibilityWindowManagerTest::AddNormalWindow(AccessibilityWindowManager &windowInfoManager,
121 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfoSecond)
122 {
123 rosenWinInfoSecond->type_ = Rosen::WindowType::APP_WINDOW_BASE;
124 rosenWinInfoSecond->wid_ = WINDOW_ID;
125 rosenWinInfoSecond->focused_ = false;
126 Rosen::Rect rect;
127 rect.posX_ = 1;
128 rect.posY_ = 1;
129 rect.width_ = 1;
130 rect.height_ = 1;
131 rosenWinInfoSecond->windowRect_ = rect;
132 rosenWinInfoSecond->mode_ = Rosen::WindowMode::WINDOW_MODE_PIP;
133 rosenWinInfoSecond->isDecorEnable_ = false;
134 rosenWinInfoSecond->displayId_ = 0;
135 rosenWinInfoSecond->innerWid_ = WINDOW_ID;
136 windowInfoManager.a11yWindows_.insert(std::make_pair(rosenWinInfoSecond->wid_,
137 windowInfoManager.CreateAccessibilityWindowInfo(rosenWinInfoSecond)));
138 EXPECT_EQ(windowInfoManager.a11yWindows_.size(), WINDOWS_SIZE);
139 }
140
141 /**
142 * @tc.number: AccessibilityWindowManager_Unittest_ConvertToRealWindowId001
143 * @tc.name: ConvertToRealWindowId
144 * @tc.desc: Test function ConvertToRealWindowId
145 */
146 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_ConvertToRealWindowId001, TestSize.Level1)
147 {
148 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ConvertToRealWindowId001 start";
149 int32_t windowId = ACTIVE_WINDOW_ID;
150 int32_t focusType = 0;
151 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
152 int32_t realId = mgr.ConvertToRealWindowId(windowId, focusType);
153
154 EXPECT_EQ(mgr.activeWindowId_, realId);
155 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ConvertToRealWindowId001 end";
156 }
157
158 /**
159 * @tc.number: AccessibilityWindowManager_Unittest_ConvertToRealWindowId002
160 * @tc.name: ConvertToRealWindowId
161 * @tc.desc: Test function ConvertToRealWindowId
162 */
163 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_ConvertToRealWindowId002, TestSize.Level1)
164 {
165 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ConvertToRealWindowId002 start";
166 int32_t windowId = ANY_WINDOW_ID;
167 int32_t focusType = FOCUS_TYPE_ACCESSIBILITY;
168 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
169 int32_t realId = mgr.ConvertToRealWindowId(windowId, focusType);
170
171 EXPECT_EQ(mgr.a11yFocusedWindowId_, realId);
172 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ConvertToRealWindowId002 end";
173 }
174
175 /**
176 * @tc.number: AccessibilityWindowManager_Unittest_ConvertToRealWindowId003
177 * @tc.name: ConvertToRealWindowId
178 * @tc.desc: Test function ConvertToRealWindowId
179 */
180 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_ConvertToRealWindowId003, TestSize.Level1)
181 {
182 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ConvertToRealWindowId003 start";
183 int32_t windowId = ANY_WINDOW_ID;
184 int32_t focusType = FOCUS_TYPE_INPUT;
185 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
186 int32_t realId = mgr.ConvertToRealWindowId(windowId, focusType);
187
188 EXPECT_EQ(mgr.activeWindowId_, realId);
189 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ConvertToRealWindowId003 end";
190 }
191
192 /**
193 * @tc.number: AccessibilityWindowManager_Unittest_ConvertToRealWindowId004
194 * @tc.name: ConvertToRealWindowId
195 * @tc.desc: Test function ConvertToRealWindowId
196 */
197 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_ConvertToRealWindowId004, TestSize.Level1)
198 {
199 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ConvertToRealWindowId004 start";
200 int32_t windowId = INVALID_WINDOW_ID;
201 int32_t focusType = FOCUS_TYPE_INPUT;
202 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
203 int32_t realId = mgr.ConvertToRealWindowId(windowId, focusType);
204
205 EXPECT_EQ(windowId, realId);
206 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ConvertToRealWindowId004 end";
207 }
208
209 /**
210 * @tc.number: AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo001
211 * @tc.name: CreateAccessibilityWindowInfo
212 * @tc.desc: Test function CreateAccessibilityWindowInfo
213 */
214 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo001,
215 TestSize.Level1)
216 {
217 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo001 start";
218 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(Rosen::WindowType::APP_MAIN_WINDOW_BASE);
219 EXPECT_TRUE(rosen_winInfo != nullptr);
220
221 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
222 infos.emplace_back(rosen_winInfo);
223
224 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
225 AccessibilityWindowInfo info = windowInfoManager.CreateAccessibilityWindowInfo(rosen_winInfo);
226
227 EXPECT_EQ(TYPE_APPLICATION, info.GetAccessibilityWindowType());
228 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo001 end";
229 }
230
231 /**
232 * @tc.number: AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo002
233 * @tc.name: CreateAccessibilityWindowInfo
234 * @tc.desc: Test function CreateAccessibilityWindowInfo
235 */
236 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo002,
237 TestSize.Level1)
238 {
239 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo002 start";
240 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(
241 Rosen::WindowType::WINDOW_TYPE_LAUNCHER_RECENT);
242 EXPECT_TRUE(rosen_winInfo != nullptr);
243
244 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
245 infos.emplace_back(rosen_winInfo);
246
247 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
248 AccessibilityWindowInfo info = windowInfoManager.CreateAccessibilityWindowInfo(rosen_winInfo);
249
250 EXPECT_EQ(TYPE_SYSTEM, info.GetAccessibilityWindowType());
251 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo002 end";
252 }
253
254 /**
255 * @tc.number: AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo003
256 * @tc.name: CreateAccessibilityWindowInfo
257 * @tc.desc: Test function CreateAccessibilityWindowInfo
258 */
259 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo003,
260 TestSize.Level1)
261 {
262 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo003 start";
263
264 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(
265 static_cast<OHOS::Rosen::WindowType>(0xFFFFFFFF));
266 EXPECT_TRUE(rosen_winInfo != nullptr);
267
268 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
269 infos.emplace_back(rosen_winInfo);
270
271 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
272 AccessibilityWindowInfo info = windowInfoManager.CreateAccessibilityWindowInfo(rosen_winInfo);
273
274 EXPECT_EQ(TYPE_WINDOW_INVALID, info.GetAccessibilityWindowType());
275 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo003 end";
276 }
277
278 /**
279 * @tc.number: AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo004
280 * @tc.name: CreateAccessibilityWindowInfo
281 * @tc.desc: Test function CreateAccessibilityWindowInfo
282 */
283 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo004,
284 TestSize.Level1)
285 {
286 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo004 start";
287
288 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(
289 Rosen::WindowType::WINDOW_TYPE_UI_EXTENSION);
290 EXPECT_TRUE(rosen_winInfo != nullptr);
291
292 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
293 infos.emplace_back(rosen_winInfo);
294
295 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
296 AccessibilityWindowInfo info = windowInfoManager.CreateAccessibilityWindowInfo(rosen_winInfo);
297
298 EXPECT_EQ(TYPE_WINDOW_INVALID, info.GetAccessibilityWindowType());
299 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo004 end";
300 }
301
302 /**
303 * @tc.number: AccessibilityWindowManager_Unittest_RegisterWindowListener001
304 * @tc.name: RegisterWindowListener
305 * @tc.desc: Test function RegisterWindowListener
306 */
307 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_RegisterWindowListener001,
308 TestSize.Level1)
309 {
310 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_RegisterWindowListener001 start";
311
312 Singleton<AccessibilityWindowManager>::GetInstance().RegisterWindowListener(nullptr);
313
314 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_RegisterWindowListener001 end";
315 }
316
317 /**
318 * @tc.number: AccessibilityWindowManager_Unittest_RegisterWindowListener002
319 * @tc.name: RegisterWindowListener
320 * @tc.desc: Test function RegisterWindowListener
321 */
322 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_RegisterWindowListener002,
323 TestSize.Level1)
324 {
325 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_RegisterWindowListener002 start";
326
327 const std::string AAMS_SERVICE_NAME = "AccessibleAbilityManagerService";
328 std::shared_ptr<AppExecFwk::EventRunner> runner_ = AppExecFwk::EventRunner::Create(AAMS_SERVICE_NAME);
329 std::shared_ptr<AppExecFwk::EventHandler> handler_ = std::make_shared<AppExecFwk::EventHandler>(runner_);
330
331 Singleton<AccessibilityWindowManager>::GetInstance().RegisterWindowListener(handler_);
332 EXPECT_NE(handler_, nullptr);
333
334 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_RegisterWindowListener002 end";
335 }
336
337 /**
338 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange001
339 * @tc.name: OnWindowChange
340 * @tc.desc: Test function OnWindowChange
341 */
342 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange001, TestSize.Level1)
343 {
344 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange001 start";
345 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(Rosen::WindowType::APP_WINDOW_BASE);
346 EXPECT_TRUE(rosen_winInfo != nullptr);
347 rosen_winInfo->focused_ = false;
348
349 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
350 infos.emplace_back(rosen_winInfo);
351
352 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
353 windowInfoManager.a11yWindows_.clear();
354 EXPECT_TRUE(!windowInfoManager.a11yWindows_.size());
355
356 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_ADDED);
357 int retryCount = 0;
358 while (retryCount < RETRY_TIMES) {
359 sleep(1);
360 int counts = AccessibilityAbilityHelper::GetInstance().GetSendEventTimes();
361 GTEST_LOG_(INFO) << "The counts of send event is : " << counts;
362 if (counts == 1) {
363 GTEST_LOG_(INFO) << "update window successful";
364 break;
365 }
366 retryCount++;
367 }
368 EXPECT_TRUE(windowInfoManager.a11yWindows_.size() == 1);
369 EXPECT_TRUE(windowInfoManager.a11yWindows_.count(rosen_winInfo->wid_));
370 windowInfoManager.a11yWindows_.clear();
371 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange001 end";
372 }
373
374 /**
375 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange002
376 * @tc.name: OnWindowChange
377 * @tc.desc: Test function OnWindowchange
378 */
379 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange002, TestSize.Level1)
380 {
381 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange002 start";
382 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = new(std::nothrow) Rosen::AccessibilityWindowInfo();;
383 EXPECT_TRUE(rosen_winInfo != nullptr);
384 rosen_winInfo->type_ = Rosen::WindowType::APP_WINDOW_BASE;
385 rosen_winInfo->wid_ = 1;
386 rosen_winInfo->focused_ = true;
387 rosen_winInfo->innerWid_ = 1;
388
389 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
390 infos.emplace_back(rosen_winInfo);
391
392 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
393 windowInfoManager.a11yWindows_.clear();
394 EXPECT_TRUE(!windowInfoManager.a11yWindows_.size());
395 EXPECT_EQ(windowInfoManager.activeWindowId_, INVALID_WINDOW_ID);
396
397 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_ACTIVE);
398 int retryCount = 0;
399 while (retryCount < RETRY_TIMES) {
400 sleep(1);
401 int counts = AccessibilityAbilityHelper::GetInstance().GetSendEventTimes();
402 GTEST_LOG_(INFO) << "The counts of send event is : " << counts;
403 if (counts == 1) {
404 GTEST_LOG_(INFO) << "update window successful";
405 break;
406 }
407 retryCount++;
408 }
409 EXPECT_TRUE(windowInfoManager.a11yWindows_.size() == 1);
410 EXPECT_TRUE(windowInfoManager.a11yWindows_.count(rosen_winInfo->wid_));
411 EXPECT_EQ(windowInfoManager.activeWindowId_, rosen_winInfo->wid_);
412 windowInfoManager.a11yWindows_.clear();
413 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange002 end";
414 }
415
416 /**
417 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange003
418 * @tc.name: OnWindowChange
419 * @tc.desc: Test function OnWindowChange
420 */
421 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange003, TestSize.Level1)
422 {
423 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange003 start";
424 // Clear window data
425 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
426 windowInfoManager.a11yWindows_.clear();
427 EXPECT_TRUE(!windowInfoManager.a11yWindows_.size());
428
429 // Add a window
430 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfoFirst = new Rosen::AccessibilityWindowInfo();
431 AddActiveWindow(windowInfoManager, rosenWinInfoFirst);
432
433 // Add another window
434 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfoSecond = new Rosen::AccessibilityWindowInfo();
435 AddNormalWindow(windowInfoManager, rosenWinInfoSecond);
436
437 // Remove the first window
438 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
439 infos.emplace_back(rosenWinInfoFirst);
440 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_REMOVED);
441
442 int retryCount = 0;
443 while (retryCount < RETRY_TIMES) {
444 sleep(1);
445 int counts = AccessibilityAbilityHelper::GetInstance().GetSendEventTimes();
446 GTEST_LOG_(INFO) << "The counts of send event is : " << counts;
447 if (counts == 1) {
448 GTEST_LOG_(INFO) << "update window successful";
449 break;
450 }
451 retryCount++;
452 }
453 EXPECT_TRUE(windowInfoManager.a11yWindows_.size() == 1);
454 EXPECT_FALSE(windowInfoManager.a11yWindows_.count(rosenWinInfoFirst->wid_));
455 EXPECT_TRUE(windowInfoManager.a11yWindows_.count(rosenWinInfoSecond->wid_));
456 windowInfoManager.a11yWindows_.clear();
457 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange003 end";
458 }
459
460 /**
461 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange004
462 * @tc.name: OnWindowChange
463 * @tc.desc: Test function OnWindowChange
464 */
465 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange004, TestSize.Level1)
466 {
467 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange004 start";
468 // Clear window data
469 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
470 windowInfoManager.a11yWindows_.clear();
471 EXPECT_TRUE(!windowInfoManager.a11yWindows_.size());
472 EXPECT_EQ(windowInfoManager.activeWindowId_, INVALID_WINDOW_ID);
473
474 // Add an active window
475 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfoFirst = new Rosen::AccessibilityWindowInfo();
476 AddActiveWindow(windowInfoManager, rosenWinInfoFirst);
477 windowInfoManager.SetActiveWindow(rosenWinInfoFirst->wid_);
478 EXPECT_EQ(windowInfoManager.activeWindowId_, rosenWinInfoFirst->wid_);
479
480 // Add another normal window
481 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfoSecond = new Rosen::AccessibilityWindowInfo();
482 AddNormalWindow(windowInfoManager, rosenWinInfoSecond);
483
484 // Remove the active window
485 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
486 infos.emplace_back(rosenWinInfoFirst);
487 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_REMOVED);
488
489 int retryCount = 0;
490 while (retryCount < RETRY_TIMES) {
491 sleep(1);
492 int counts = AccessibilityAbilityHelper::GetInstance().GetSendEventTimes();
493 GTEST_LOG_(INFO) << "The counts of send event is : " << counts;
494 if (counts == SEND_EVENT_TIMES) {
495 GTEST_LOG_(INFO) << "update window successful";
496 break;
497 }
498 retryCount++;
499 }
500 EXPECT_TRUE(windowInfoManager.a11yWindows_.size() == 1);
501 EXPECT_FALSE(windowInfoManager.a11yWindows_.count(rosenWinInfoFirst->wid_));
502 EXPECT_TRUE(windowInfoManager.a11yWindows_.count(rosenWinInfoSecond->wid_));
503 EXPECT_EQ(windowInfoManager.activeWindowId_, INVALID_WINDOW_ID);
504 windowInfoManager.a11yWindows_.clear();
505 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange004 end";
506 }
507
508 /**
509 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange005
510 * @tc.name: OnWindowChange
511 * @tc.desc: Test function OnWindowChange(WindowUpdateBounds fail)
512 */
513 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange005, TestSize.Level1)
514 {
515 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange005 start";
516
517 AccessibilityAbilityHelper::GetInstance().SetEventWindowChangeType(WINDOW_UPDATE_ACCESSIBILITY_FOCUSED);
518 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
519 infos.emplace_back(nullptr);
520 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
521 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_BOUNDS);
522 sleep(1);
523 EXPECT_EQ(WINDOW_UPDATE_ACCESSIBILITY_FOCUSED,
524 AccessibilityAbilityHelper::GetInstance().GetEventWindowChangeType());
525 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange005 end";
526 }
527
528 /**
529 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange006
530 * @tc.name: OnWindowChange
531 * @tc.desc: Test function OnWindowChange(WindowUpdateBounds success)
532 */
533 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange006, TestSize.Level1)
534 {
535 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange006 start";
536
537 AccessibilityAbilityHelper::GetInstance().SetEventWindowChangeType(WINDOW_UPDATE_ACCESSIBILITY_FOCUSED);
538 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
539 sptr<Rosen::AccessibilityWindowInfo> winInfo = new(std::nothrow) Rosen::AccessibilityWindowInfo();
540 infos.emplace_back(winInfo);
541 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
542 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_BOUNDS);
__anonb1d724080202() 543 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
544 if (AccessibilityAbilityHelper::GetInstance().GetEventWindowChangeType() == WINDOW_UPDATE_BOUNDS) {
545 return true;
546 } else {
547 return false;
548 }
549 }), 1);
550 EXPECT_TRUE(ret);
551 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange006 end";
552 }
553
554 /**
555 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange007
556 * @tc.name: OnWindowChange
557 * @tc.desc: Test function OnWindowChange(WindowUpdateFocused fail)
558 */
559 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange007, TestSize.Level1)
560 {
561 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange007 start";
562
563 AccessibilityAbilityHelper::GetInstance().SetEventWindowChangeType(WINDOW_UPDATE_ACCESSIBILITY_FOCUSED);
564 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
565 infos.emplace_back(nullptr);
566 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
567 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_FOCUSED);
568 sleep(1);
569 EXPECT_EQ(WINDOW_UPDATE_ACCESSIBILITY_FOCUSED,
570 AccessibilityAbilityHelper::GetInstance().GetEventWindowChangeType());
571 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange007 end";
572 }
573
574 /**
575 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange008
576 * @tc.name: OnWindowChange
577 * @tc.desc: Test function OnWindowChange(WindowUpdateFocused success(a11yWindows_ is not null))
578 */
579 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange008, TestSize.Level1)
580 {
581 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange008 start";
582
583 AccessibilityAbilityHelper::GetInstance().SetEventWindowChangeType(WINDOW_UPDATE_ACCESSIBILITY_FOCUSED);
584 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
585 // Add a window
586 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfo = new Rosen::AccessibilityWindowInfo();
587 rosenWinInfo->wid_ = 1;
588 windowInfoManager.a11yWindows_.insert(std::make_pair(1,
589 windowInfoManager.CreateAccessibilityWindowInfo(rosenWinInfo)));
590 EXPECT_EQ(windowInfoManager.a11yWindows_.size(), 1);
591
592 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
593 sptr<Rosen::AccessibilityWindowInfo> winInfo = new(std::nothrow) Rosen::AccessibilityWindowInfo();
594 winInfo->wid_ = 1;
595 infos.emplace_back(winInfo);
596 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_FOCUSED);
__anonb1d724080302() 597 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
598 if (AccessibilityAbilityHelper::GetInstance().GetEventWindowChangeType() == WINDOW_UPDATE_FOCUSED) {
599 return true;
600 } else {
601 return false;
602 }
603 }), 1);
604 EXPECT_TRUE(ret);
605 windowInfoManager.a11yWindows_.clear();
606 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange008 end";
607 }
608
609 /**
610 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange009
611 * @tc.name: OnWindowChange
612 * @tc.desc: Test function OnWindowChange(WindowUpdateFocused success(a11yWindows_ is null))
613 */
614 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange009, TestSize.Level1)
615 {
616 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange009 start";
617
618 AccessibilityAbilityHelper::GetInstance().SetEventWindowChangeType(WINDOW_UPDATE_ACCESSIBILITY_FOCUSED);
619 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
620 sptr<Rosen::AccessibilityWindowInfo> winInfo = new(std::nothrow) Rosen::AccessibilityWindowInfo();
621 winInfo->wid_ = 1;
622 infos.emplace_back(winInfo);
623 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
624 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_FOCUSED);
__anonb1d724080402() 625 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
626 if (AccessibilityAbilityHelper::GetInstance().GetEventWindowChangeType() == WINDOW_UPDATE_FOCUSED) {
627 return true;
628 } else {
629 return false;
630 }
631 }), 1);
632 EXPECT_TRUE(ret);
633 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange009 end";
634 }
635
636 /**
637 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange010
638 * @tc.name: OnWindowChange
639 * @tc.desc: Test function OnWindowChange(WindowUpdateProperty fail)
640 */
641 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange010, TestSize.Level1)
642 {
643 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange010 start";
644
645 // Add window
646 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
647 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfo = new Rosen::AccessibilityWindowInfo();
648 rosenWinInfo->wid_ = WINDOW_ID;
649 rosenWinInfo->focused_ = false;
650 windowInfoManager.a11yWindows_.insert(std::make_pair(WINDOW_ID,
651 windowInfoManager.CreateAccessibilityWindowInfo(rosenWinInfo)));
652
653 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
654 infos.emplace_back(nullptr);
655 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_PROPERTY);
656 sleep(1);
657 EXPECT_TRUE(!windowInfoManager.a11yWindows_[WINDOW_ID].IsFocused());
658 windowInfoManager.a11yWindows_.clear();
659 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange010 end";
660 }
661
662 /**
663 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange011
664 * @tc.name: OnWindowChange
665 * @tc.desc: Test function OnWindowChange(WindowUpdateProperty fail)
666 */
667 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange011, TestSize.Level1)
668 {
669 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange011 start";
670
671 // Add window
672 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
673 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfo = new Rosen::AccessibilityWindowInfo();
674 rosenWinInfo->wid_ = WINDOW_ID;
675 rosenWinInfo->focused_ = false;
676 windowInfoManager.a11yWindows_.insert(std::make_pair(WINDOW_ID,
677 windowInfoManager.CreateAccessibilityWindowInfo(rosenWinInfo)));
678 EXPECT_EQ(1, windowInfoManager.a11yWindows_.size());
679
680 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
681 sptr<Rosen::AccessibilityWindowInfo> winInfo = new(std::nothrow) Rosen::AccessibilityWindowInfo();
682 winInfo->wid_ = 1;
683 winInfo->focused_ = true;
684 infos.emplace_back(winInfo);
685 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_PROPERTY);
686 sleep(1);
687 EXPECT_TRUE(!windowInfoManager.a11yWindows_[WINDOW_ID].IsFocused());
688 windowInfoManager.a11yWindows_.clear();
689 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange011 end";
690 }
691
692 /**
693 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange012
694 * @tc.name: OnWindowChange
695 * @tc.desc: Test function OnWindowChange(WindowUpdateProperty success)
696 */
697 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange012, TestSize.Level1)
698 {
699 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange012 start";
700
701 // Add window
702 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
703 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfo = new Rosen::AccessibilityWindowInfo();
704 rosenWinInfo->wid_ = WINDOW_ID;
705 rosenWinInfo->focused_ = false;
706 windowInfoManager.a11yWindows_.insert(std::make_pair(WINDOW_ID,
707 windowInfoManager.CreateAccessibilityWindowInfo(rosenWinInfo)));
708 EXPECT_EQ(1, windowInfoManager.a11yWindows_.size());
709
710 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
711 sptr<Rosen::AccessibilityWindowInfo> winInfo = new(std::nothrow) Rosen::AccessibilityWindowInfo();
712 winInfo->wid_ = WINDOW_ID;
713 winInfo->focused_ = true;
714 infos.emplace_back(winInfo);
715 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_PROPERTY);
__anonb1d724080502() 716 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
717 if (Singleton<AccessibilityWindowManager>::GetInstance().a11yWindows_[WINDOW_ID].IsFocused()) {
718 return true;
719 } else {
720 return false;
721 }
722 }), 1);
723 EXPECT_TRUE(ret);
724 windowInfoManager.a11yWindows_.clear();
725 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange012 end";
726 }
727
728 /**
729 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange013
730 * @tc.name: OnWindowChange
731 * @tc.desc: Test function OnWindowChange(size of parameter(infos) is 0)
732 */
733 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange013, TestSize.Level1)
734 {
735 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange013 start";
736
737 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
738 windowInfoManager.a11yWindows_.clear();
739 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
740 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_ADDED);
741 EXPECT_EQ(0, windowInfoManager.a11yWindows_.size());
742 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange013 end";
743 }
744
745 /**
746 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange014
747 * @tc.name: OnWindowChange
748 * @tc.desc: Test function OnWindowChange(WindowUpdateAdded fail)
749 */
750 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange014, TestSize.Level1)
751 {
752 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange014 start";
753
754 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
755 windowInfoManager.a11yWindows_.clear();
756 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
757 infos.emplace_back(nullptr);
758 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_ADDED);
759 sleep(1);
760 EXPECT_EQ(0, windowInfoManager.a11yWindows_.size());
761 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange014 end";
762 }
763
764 /**
765 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange015
766 * @tc.name: OnWindowChange
767 * @tc.desc: Test function OnWindowChange(WindowUpdateAdded success)
768 */
769 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange015, TestSize.Level1)
770 {
771 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange015 start";
772
773 // Add window
774 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
775 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfo1 = new Rosen::AccessibilityWindowInfo();
776 rosenWinInfo1->wid_ = WINDOW_ID;
777 rosenWinInfo1->focused_ = false;
778 windowInfoManager.a11yWindows_.insert(std::make_pair(WINDOW_ID,
779 windowInfoManager.CreateAccessibilityWindowInfo(rosenWinInfo1)));
780
781 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfo2 = new Rosen::AccessibilityWindowInfo();
782 rosenWinInfo2->wid_ = 1;
783 rosenWinInfo2->focused_ = false;
784 windowInfoManager.a11yWindows_.insert(std::make_pair(1,
785 windowInfoManager.CreateAccessibilityWindowInfo(rosenWinInfo2)));
786 windowInfoManager.activeWindowId_ = 1;
787
788 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
789 sptr<Rosen::AccessibilityWindowInfo> winInfo = new(std::nothrow) Rosen::AccessibilityWindowInfo();
790 winInfo->wid_ = WINDOW_ID;
791 winInfo->focused_ = true;
792 infos.emplace_back(winInfo);
793 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_ADDED);
__anonb1d724080602() 794 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
795 if (AccessibilityAbilityHelper::GetInstance().GetEventWindowChangeType() == WINDOW_UPDATE_ACTIVE) {
796 return true;
797 } else {
798 return false;
799 }
800 }), 1);
801 EXPECT_TRUE(ret);
802 windowInfoManager.a11yWindows_.clear();
803 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange015 end";
804 }
805
806 /**
807 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange016
808 * @tc.name: OnWindowChange
809 * @tc.desc: Test function OnWindowChange(WindowUpdateRemoved fail)
810 */
811 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange016, TestSize.Level1)
812 {
813 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange016 start";
814
815 // Add window
816 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
817 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfo = new Rosen::AccessibilityWindowInfo();
818 rosenWinInfo->wid_ = WINDOW_ID;
819 rosenWinInfo->focused_ = false;
820 windowInfoManager.a11yWindows_.insert(std::make_pair(WINDOW_ID,
821 windowInfoManager.CreateAccessibilityWindowInfo(rosenWinInfo)));
822 EXPECT_EQ(1, windowInfoManager.a11yWindows_.size());
823
824 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
825 infos.emplace_back(nullptr);
826 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_REMOVED);
827 sleep(1);
828 EXPECT_EQ(1, windowInfoManager.a11yWindows_.size());
829 windowInfoManager.a11yWindows_.clear();
830 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange016 end";
831 }
832
833 /**
834 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange017
835 * @tc.name: OnWindowChange
836 * @tc.desc: Test function OnWindowChange(WindowUpdateRemoved success)
837 */
838 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange017, TestSize.Level1)
839 {
840 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange017 start";
841
842 // Add window
843 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
844 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfo = new Rosen::AccessibilityWindowInfo();
845 rosenWinInfo->wid_ = WINDOW_ID;
846 rosenWinInfo->focused_ = false;
847 windowInfoManager.a11yWindows_.insert(std::make_pair(WINDOW_ID,
848 windowInfoManager.CreateAccessibilityWindowInfo(rosenWinInfo)));
849 EXPECT_EQ(1, windowInfoManager.a11yWindows_.size());
850 windowInfoManager.a11yFocusedWindowId_ = WINDOW_ID;
851
852 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
853 sptr<Rosen::AccessibilityWindowInfo> winInfo = new(std::nothrow) Rosen::AccessibilityWindowInfo();
854 winInfo->wid_ = WINDOW_ID;
855 winInfo->focused_ = true;
856 infos.emplace_back(winInfo);
857 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_REMOVED);
__anonb1d724080702() 858 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
859 if (AccessibilityAbilityHelper::GetInstance().GetEventWindowChangeType() == WINDOW_UPDATE_REMOVED) {
860 return true;
861 } else {
862 return false;
863 }
864 }), 1);
865 EXPECT_TRUE(ret);
866 EXPECT_EQ(0, windowInfoManager.a11yWindows_.size());
867 windowInfoManager.a11yWindows_.clear();
868 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange017 end";
869 }
870
871 /**
872 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange018
873 * @tc.name: OnWindowChange
874 * @tc.desc: Test function OnWindowChange(WindowUpdateActive fail)
875 */
876 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange018, TestSize.Level1)
877 {
878 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange018 start";
879
880 // Add window
881 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
882 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfo = new Rosen::AccessibilityWindowInfo();
883 rosenWinInfo->wid_ = WINDOW_ID;
884 rosenWinInfo->focused_ = false;
885 windowInfoManager.a11yWindows_.insert(std::make_pair(WINDOW_ID,
886 windowInfoManager.CreateAccessibilityWindowInfo(rosenWinInfo)));
887 EXPECT_EQ(1, windowInfoManager.a11yWindows_.size());
888 windowInfoManager.activeWindowId_ = WINDOW_ID;
889
890 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
891 infos.emplace_back(nullptr);
892 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_ACTIVE);
893 sleep(1);
894 EXPECT_EQ(WINDOW_ID, windowInfoManager.activeWindowId_);
895 windowInfoManager.a11yWindows_.clear();
896 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange018 end";
897 }
898
899 /**
900 * @tc.number: AccessibilityWindowManager_Unittest_SetActiveWindow001
901 * @tc.name: SetActiveWindow
902 * @tc.desc: Test function SetActiveWindow
903 */
904 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_SetActiveWindow001, TestSize.Level1)
905 {
906 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetActiveWindow001 start";
907 /* map insert value */
908 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
909 AccessibilityWindowInfo info;
910 mgr.activeWindowId_ = ACTIVE_WINDOW_ID;
911 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
912 mgr.a11yWindows_.insert(std::make_pair(ANY_WINDOW_ID, info));
913 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
914 /* SetActiveWindow */
915 int32_t windowId = INVALID_WINDOW_ID;
916 mgr.SetActiveWindow(windowId);
917 /* test */
918 bool test1 = false;
919 if (mgr.a11yWindows_.count(ACTIVE_WINDOW_ID)) {
920 test1 = true;
921 }
922 EXPECT_FALSE(test1);
923 EXPECT_EQ(INVALID_WINDOW_ID, mgr.activeWindowId_);
924
925 mgr.a11yWindows_.clear();
926 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetActiveWindow001 end";
927 }
928
929 /**
930 * @tc.number: AccessibilityWindowManager_Unittest_SetActiveWindow002
931 * @tc.name: SetActiveWindow
932 * @tc.desc: Test function SetActiveWindow
933 */
934 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_SetActiveWindow002, TestSize.Level1)
935 {
936 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetActiveWindow002 start";
937 /* map insert value */
938 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
939 AccessibilityWindowInfo info;
940 mgr.activeWindowId_ = ACTIVE_WINDOW_ID;
941 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
942 mgr.a11yWindows_.insert(std::make_pair(ACTIVE_WINDOW_ID, info));
943 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
944 /* SetActiveWindow */
945 int32_t windowId = INVALID_WINDOW_ID;
946 mgr.SetActiveWindow(windowId);
947 /* test */
948 bool test1 = false;
949 if (mgr.a11yWindows_.count(ACTIVE_WINDOW_ID)) {
950 test1 = true;
951 }
952 EXPECT_TRUE(test1);
953 bool test2 = mgr.a11yWindows_[ACTIVE_WINDOW_ID].IsActive();
954 EXPECT_FALSE(test2);
955 EXPECT_EQ(INVALID_WINDOW_ID, mgr.activeWindowId_);
956
957 mgr.a11yWindows_.clear();
958 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetActiveWindow002 end";
959 }
960
961 /**
962 * @tc.number: AccessibilityWindowManager_Unittest_SetActiveWindow003
963 * @tc.name: SetActiveWindow
964 * @tc.desc: Test function SetActiveWindow
965 */
966 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_SetActiveWindow003, TestSize.Level1)
967 {
968 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetActiveWindow003 start";
969 /* map insert value */
970 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
971 AccessibilityWindowInfo info;
972 mgr.activeWindowId_ = ACTIVE_WINDOW_ID;
973 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
974 mgr.a11yWindows_.insert(std::make_pair(ANY_WINDOW_ID, info));
975 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
976 /* SetActiveWindow */
977 int32_t windowId = ACTIVE_WINDOW_ID;
978 mgr.SetActiveWindow(windowId);
979 /* test */
980 bool test1 = false;
981 if (mgr.a11yWindows_.count(windowId)) {
982 test1 = true;
983 }
984 EXPECT_FALSE(test1);
985 EXPECT_EQ(ACTIVE_WINDOW_ID, mgr.activeWindowId_);
986
987 mgr.a11yWindows_.clear();
988 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetActiveWindow003 end";
989 }
990
991 /**
992 * @tc.number: AccessibilityWindowManager_Unittest_SetActiveWindow004
993 * @tc.name: SetActiveWindow
994 * @tc.desc: Test function SetActiveWindow
995 */
996 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_SetActiveWindow004, TestSize.Level1)
997 {
998 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetActiveWindow004 start";
999 /* map insert value */
1000 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1001 AccessibilityWindowInfo info1;
1002 AccessibilityWindowInfo info2;
1003 mgr.activeWindowId_ = ACTIVE_WINDOW_ID;
1004 int32_t windowId = ANY_WINDOW_ID;
1005 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1006 mgr.a11yWindows_.insert(std::make_pair(ACTIVE_WINDOW_ID, info1));
1007 mgr.a11yWindows_.insert(std::make_pair(windowId, info2));
1008 EXPECT_EQ(2, (int)mgr.a11yWindows_.size());
1009 /* SetActiveWindow */
1010 mgr.SetActiveWindow(windowId);
1011 /* test */
1012 bool test1 = false;
1013 if (mgr.a11yWindows_.count(ACTIVE_WINDOW_ID)) {
1014 test1 = true;
1015 }
1016 EXPECT_TRUE(test1);
1017 bool test2 = mgr.a11yWindows_[ACTIVE_WINDOW_ID].IsActive();
1018 EXPECT_FALSE(test2);
1019 EXPECT_EQ(ANY_WINDOW_ID, mgr.activeWindowId_);
1020 bool test3 = mgr.a11yWindows_[mgr.activeWindowId_].IsActive();
1021 EXPECT_TRUE(test3);
1022
1023 mgr.a11yWindows_.clear();
1024 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetActiveWindow004 end";
1025 }
1026
1027 /**
1028 * @tc.number: AccessibilityWindowManager_Unittest_SetActiveWindow005
1029 * @tc.name: SetActiveWindow
1030 * @tc.desc: Test function SetActiveWindow
1031 */
1032 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_SetActiveWindow005, TestSize.Level1)
1033 {
1034 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetActiveWindow005 start";
1035 /* map insert value */
1036 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1037 AccessibilityWindowInfo info1;
1038 AccessibilityWindowInfo info2;
1039 mgr.activeWindowId_ = ACTIVE_WINDOW_ID;
1040 mgr.a11yFocusedWindowId_ = ACTIVE_WINDOW_ID;
1041 int32_t windowId = ANY_WINDOW_ID;
1042 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1043 mgr.a11yWindows_.insert(std::make_pair(ACTIVE_WINDOW_ID, info1));
1044 mgr.a11yWindows_.insert(std::make_pair(windowId, info2));
1045 EXPECT_EQ(2, (int)mgr.a11yWindows_.size());
1046 /* SetActiveWindow */
1047 mgr.SetActiveWindow(windowId);
1048 /* test */
1049 EXPECT_EQ(INVALID_WINDOW_ID, mgr.a11yFocusedWindowId_);
1050 mgr.a11yWindows_.clear();
1051 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetActiveWindow005 end";
1052 }
1053
1054 /**
1055 * @tc.number: AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow001
1056 * @tc.name: SetAccessibilityFocusedWindow
1057 * @tc.desc: Test function SetAccessibilityFocusedWindow
1058 */
1059 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow001,
1060 TestSize.Level1)
1061 {
1062 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow001 start";
1063 /* map insert value */
1064 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1065 AccessibilityWindowInfo info;
1066 mgr.a11yFocusedWindowId_ = ANY_WINDOW_ID;
1067 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1068 mgr.a11yWindows_.insert(std::make_pair(ACTIVE_WINDOW_ID, info));
1069 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1070 /* SetAccessibilityFocusedWindow */
1071 int32_t windowId = INVALID_WINDOW_ID;
1072 mgr.SetAccessibilityFocusedWindow(windowId);
1073 /* test */
1074 bool test1 = false;
1075 if (mgr.a11yWindows_.count(ANY_WINDOW_ID)) {
1076 test1 = true;
1077 }
1078 EXPECT_FALSE(test1);
1079 EXPECT_EQ(INVALID_WINDOW_ID, mgr.a11yFocusedWindowId_);
1080
1081 mgr.a11yWindows_.clear();
1082 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow001 end";
1083 }
1084
1085 /**
1086 * @tc.number: AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow002
1087 * @tc.name: SetAccessibilityFocusedWindow
1088 * @tc.desc: Test function SetAccessibilityFocusedWindow
1089 */
1090 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow002,
1091 TestSize.Level1)
1092 {
1093 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow002 start";
1094 /* map insert value */
1095 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1096 AccessibilityWindowInfo info;
1097 mgr.a11yFocusedWindowId_ = ANY_WINDOW_ID;
1098 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1099 mgr.a11yWindows_.insert(std::make_pair(ANY_WINDOW_ID, info));
1100 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1101 /* SetAccessibilityFocusedWindow */
1102 int32_t windowId = INVALID_WINDOW_ID;
1103 mgr.SetAccessibilityFocusedWindow(windowId);
1104 /* test */
1105 bool test1 = false;
1106 if (mgr.a11yWindows_.count(ANY_WINDOW_ID)) {
1107 test1 = true;
1108 }
1109 EXPECT_TRUE(test1);
1110 bool test2 = mgr.a11yWindows_[ANY_WINDOW_ID].IsAccessibilityFocused();
1111 EXPECT_FALSE(test2);
1112 EXPECT_EQ(INVALID_WINDOW_ID, mgr.a11yFocusedWindowId_);
1113
1114 mgr.a11yWindows_.clear();
1115 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow002 end";
1116 }
1117
1118 /**
1119 * @tc.number: AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow003
1120 * @tc.name: SetAccessibilityFocusedWindow
1121 * @tc.desc: Test function SetAccessibilityFocusedWindow
1122 */
1123 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow003,
1124 TestSize.Level1)
1125 {
1126 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow003 start";
1127 /* map insert value */
1128 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1129 AccessibilityWindowInfo info;
1130 mgr.a11yFocusedWindowId_ = ACTIVE_WINDOW_ID;
1131 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1132 mgr.a11yWindows_.insert(std::make_pair(ANY_WINDOW_ID, info));
1133 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1134 /* SetAccessibilityFocusedWindow */
1135 int32_t windowId = ACTIVE_WINDOW_ID;
1136 mgr.SetAccessibilityFocusedWindow(windowId);
1137 /* test */
1138 bool test1 = false;
1139 if (mgr.a11yWindows_.count(windowId)) {
1140 test1 = true;
1141 }
1142 EXPECT_FALSE(test1);
1143 EXPECT_EQ(ACTIVE_WINDOW_ID, mgr.a11yFocusedWindowId_);
1144
1145 mgr.a11yWindows_.clear();
1146 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow003 end";
1147 }
1148
1149 /**
1150 * @tc.number: AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow004
1151 * @tc.name: SetAccessibilityFocusedWindow
1152 * @tc.desc: Test function SetAccessibilityFocusedWindow
1153 */
1154 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow004,
1155 TestSize.Level1)
1156 {
1157 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow004 start";
1158 /* map insert value */
1159 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1160 AccessibilityWindowInfo info1;
1161 AccessibilityWindowInfo info2;
1162 mgr.a11yFocusedWindowId_ = ANY_WINDOW_ID;
1163 int32_t windowId = ACTIVE_WINDOW_ID;
1164 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1165 mgr.a11yWindows_.insert(std::make_pair(ANY_WINDOW_ID, info1));
1166 mgr.a11yWindows_.insert(std::make_pair(windowId, info2));
1167 EXPECT_EQ(2, (int)mgr.a11yWindows_.size());
1168 /* SetAccessibilityFocusedWindow */
1169 mgr.SetAccessibilityFocusedWindow(windowId);
1170 /* test */
1171 bool test1 = false;
1172 if (mgr.a11yWindows_.count(ANY_WINDOW_ID)) {
1173 test1 = true;
1174 }
1175 EXPECT_TRUE(test1);
1176 bool test2 = mgr.a11yWindows_[ANY_WINDOW_ID].IsAccessibilityFocused();
1177 EXPECT_FALSE(test2);
1178 EXPECT_EQ(ACTIVE_WINDOW_ID, mgr.a11yFocusedWindowId_);
1179 bool test3 = mgr.a11yWindows_[mgr.a11yFocusedWindowId_].IsAccessibilityFocused();
1180 EXPECT_TRUE(test3);
1181
1182 mgr.a11yWindows_.clear();
1183 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow004 end";
1184 }
1185
1186 /**
1187 * @tc.number: AccessibilityWindowManager_Unittest_GetAccessibilityWindows001
1188 * @tc.name: GetAccessibilityWindows
1189 * @tc.desc: Test function GetAccessibilityWindows
1190 */
1191 HWTEST_F(
1192 AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_GetAccessibilityWindows001, TestSize.Level1)
1193 {
1194 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetAccessibilityWindows001 start";
1195 /* map insert value */
1196 int32_t windowId = ANY_WINDOW_ID;
1197
1198 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(
1199 Rosen::WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
1200 EXPECT_TRUE(rosen_winInfo != nullptr);
1201
1202 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
1203 infos.emplace_back(rosen_winInfo);
1204
1205 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1206 AccessibilityWindowInfo info = mgr.CreateAccessibilityWindowInfo(rosen_winInfo);
1207 info.SetAccessibilityWindowType(AccessibilityWindowType::TYPE_APPLICATION);
1208 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1209 mgr.a11yWindows_.insert(std::make_pair(windowId, info));
1210 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1211
1212 /* SetAccessibilityFocusedWindow */
1213 mgr.SetAccessibilityFocusedWindow(windowId);
1214
1215 /* GetAccessibilityWindows */
1216 std::vector<AccessibilityWindowInfo> windows = mgr.GetAccessibilityWindows();
1217 ASSERT_EQ(1, (int)windows.size());
1218 static Accessibility::AccessibilityWindowType type = windows.begin()->GetAccessibilityWindowType();
1219 EXPECT_EQ(AccessibilityWindowType::TYPE_APPLICATION, type);
1220
1221 mgr.a11yWindows_.clear();
1222 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetAccessibilityWindows001 end";
1223 }
1224
1225 /**
1226 * @tc.number: AccessibilityWindowManager_Unittest_GetAccessibilityWindow001
1227 * @tc.name: GetAccessibilityWindow
1228 * @tc.desc: Test function GetAccessibilityWindow
1229 */
1230 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_GetAccessibilityWindow001, TestSize.Level1)
1231 {
1232 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetAccessibilityWindow001 start";
1233 /* map insert value */
1234 int32_t windowId = ANY_WINDOW_ID;
1235
1236 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(
1237 Rosen::WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
1238 EXPECT_TRUE(rosen_winInfo != nullptr);
1239
1240 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
1241 infos.emplace_back(rosen_winInfo);
1242
1243 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1244 AccessibilityWindowInfo info = mgr.CreateAccessibilityWindowInfo(rosen_winInfo);
1245 info.SetAccessibilityWindowType(AccessibilityWindowType::TYPE_APPLICATION);
1246 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1247 mgr.a11yWindows_.insert(std::make_pair(windowId, info));
1248 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1249
1250 /* GetAccessibilityWindow */
1251 bool window = mgr.GetAccessibilityWindow(windowId, info);
1252 EXPECT_TRUE(window);
1253
1254 mgr.a11yWindows_.clear();
1255 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetAccessibilityWindow001 end";
1256 }
1257
1258 /**
1259 * @tc.number: AccessibilityWindowManager_Unittest_GetAccessibilityWindow002
1260 * @tc.name: GetAccessibilityWindow
1261 * @tc.desc: Test function GetAccessibilityWindow
1262 */
1263 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_GetAccessibilityWindow002, TestSize.Level1)
1264 {
1265 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetAccessibilityWindow002 start";
1266 /* map insert value */
1267 int32_t windowId = ANY_WINDOW_ID;
1268
1269 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(
1270 Rosen::WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
1271 EXPECT_TRUE(rosen_winInfo != nullptr);
1272
1273 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
1274 infos.emplace_back(rosen_winInfo);
1275
1276 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1277 AccessibilityWindowInfo info = mgr.CreateAccessibilityWindowInfo(rosen_winInfo);
1278 info.SetAccessibilityWindowType(AccessibilityWindowType::TYPE_APPLICATION);
1279 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1280 mgr.a11yWindows_.insert(std::make_pair(windowId, info));
1281 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1282
1283 /* GetAccessibilityWindow */
1284 bool window = mgr.GetAccessibilityWindow(-1, info);
1285 EXPECT_FALSE(window);
1286
1287 mgr.a11yWindows_.clear();
1288 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetAccessibilityWindow002 end";
1289 }
1290
1291 /**
1292 * @tc.number: AccessibilityWindowManager_Unittest_IsValidWindow001
1293 * @tc.name: IsValidWindow
1294 * @tc.desc: Test function IsValidWindow
1295 */
1296 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_IsValidWindow001, TestSize.Level1)
1297 {
1298 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_IsValidWindow001 start";
1299 /* map insert value */
1300 int32_t windowId = ANY_WINDOW_ID;
1301
1302 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(
1303 Rosen::WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
1304 EXPECT_TRUE(rosen_winInfo != nullptr);
1305
1306 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
1307 infos.emplace_back(rosen_winInfo);
1308
1309 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1310 AccessibilityWindowInfo info = mgr.CreateAccessibilityWindowInfo(rosen_winInfo);
1311 info.SetAccessibilityWindowType(AccessibilityWindowType::TYPE_APPLICATION);
1312 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1313 mgr.a11yWindows_.insert(std::make_pair(windowId, info));
1314 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1315
1316 /* IsValidWindow */
1317 bool window = mgr.IsValidWindow(windowId);
1318 EXPECT_TRUE(window);
1319
1320 mgr.a11yWindows_.clear();
1321 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_IsValidWindow001 end";
1322 }
1323
1324 /**
1325 * @tc.number: AccessibilityWindowManager_Unittest_IsValidWindow002
1326 * @tc.name: IsValidWindow
1327 * @tc.desc: Test function IsValidWindow
1328 */
1329 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_IsValidWindow002, TestSize.Level1)
1330 {
1331 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_IsValidWindow002 start";
1332 /* map insert value */
1333 int32_t windowId = ANY_WINDOW_ID;
1334
1335 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(
1336 Rosen::WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
1337 EXPECT_TRUE(rosen_winInfo != nullptr);
1338
1339 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
1340 infos.emplace_back(rosen_winInfo);
1341
1342 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1343 AccessibilityWindowInfo info = mgr.CreateAccessibilityWindowInfo(rosen_winInfo);
1344 info.SetAccessibilityWindowType(AccessibilityWindowType::TYPE_APPLICATION);
1345 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1346 mgr.a11yWindows_.insert(std::make_pair(windowId, info));
1347 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1348
1349 /* IsValidWindow */
1350 bool window = mgr.IsValidWindow(0);
1351 EXPECT_FALSE(window);
1352
1353 mgr.a11yWindows_.clear();
1354 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_IsValidWindow002 end";
1355 }
1356
1357 /**
1358 * @tc.number: AccessibilityWindowManager_Unittest_SetWindowSize001
1359 * @tc.name: SetActiveWindow
1360 * @tc.desc: Test function SetActiveWindow
1361 */
1362 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_SetWindowSize001, TestSize.Level1)
1363 {
1364 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetWindowSize001 start";
1365 /* map insert value */
1366 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1367 int32_t windowId = ANY_WINDOW_ID;
1368 AccessibilityWindowInfo info;
1369 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1370 mgr.a11yWindows_.insert(std::make_pair(windowId, info));
1371 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1372
1373 /* SetWindowSize */
1374 Rect rect(1, 2, 3, 4);
1375 mgr.SetWindowSize(windowId, rect);
1376 AccessibilityWindowInfo mapInfo;
1377 for (auto& window : mgr.a11yWindows_) {
1378 mapInfo = window.second;
1379 }
1380 EXPECT_EQ(rect.GetLeftTopXScreenPostion(), mapInfo.GetRectInScreen().GetLeftTopXScreenPostion());
1381 EXPECT_EQ(rect.GetRightBottomXScreenPostion(), mapInfo.GetRectInScreen().GetRightBottomXScreenPostion());
1382
1383 mgr.a11yWindows_.clear();
1384 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetWindowSize001 end";
1385 }
1386
1387 /**
1388 * @tc.number: AccessibilityWindowManager_Unittest_ClearAccessibilityFocused001
1389 * @tc.name: ClearAccessibilityFocused
1390 * @tc.desc: Test function ClearAccessibilityFocused
1391 */
1392 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_ClearAccessibilityFocused001,
1393 TestSize.Level1)
1394 {
1395 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ClearAccessibilityFocused001 start";
1396 /* map insert value */
1397 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1398 AccessibilityWindowInfo info1;
1399 mgr.a11yFocusedWindowId_ = ACTIVE_WINDOW_ID;
1400 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1401 mgr.a11yWindows_.insert(std::make_pair(ACTIVE_WINDOW_ID, info1));
1402
1403 AccessibilityAbilityHelper::GetInstance().SetNeedAccountDataNullFlag(true);
1404 /* ClearAccessibilityFocused */
1405 mgr.ClearAccessibilityFocused();
1406 AccessibilityAbilityHelper::GetInstance().SetNeedAccountDataNullFlag(false);
1407 /* test */
1408 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1409 mgr.a11yWindows_.clear();
1410 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ClearAccessibilityFocused001 end";
1411 }
1412
1413 /**
1414 * @tc.number: AccessibilityWindowManager_Unittest_ClearAccessibilityFocused002
1415 * @tc.name: ClearAccessibilityFocused
1416 * @tc.desc: Test function ClearAccessibilityFocused
1417 */
1418 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_ClearAccessibilityFocused002,
1419 TestSize.Level1)
1420 {
1421 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ClearAccessibilityFocused002 start";
1422 /* map insert value */
1423 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1424 AccessibilityWindowInfo info1;
1425 mgr.a11yFocusedWindowId_ = ACTIVE_WINDOW_ID;
1426 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1427 mgr.a11yWindows_.insert(std::make_pair(ACTIVE_WINDOW_ID, info1));
1428 sptr<AccessibilityAccountData> accountData =
1429 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1430 if (!accountData) {
1431 GTEST_LOG_(INFO) << "accountData is null";
1432 return;
1433 }
1434 sptr<AccessibilityWindowConnection> windowConnection =
1435 new(std::nothrow) AccessibilityWindowConnection(ACTIVE_WINDOW_ID, nullptr, ACCOUNT_ID);
1436 accountData->RemoveAccessibilityWindowConnection(ACTIVE_WINDOW_ID);
1437 accountData->AddAccessibilityWindowConnection(ACTIVE_WINDOW_ID, windowConnection);
1438 /* ClearAccessibilityFocused */
1439 mgr.ClearAccessibilityFocused();
1440 /* test */
1441 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1442 mgr.a11yWindows_.clear();
1443 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ClearAccessibilityFocused002 end";
1444 }
1445
1446 /**
1447 * @tc.number: AccessibilityWindowManager_Unittest_ClearAccessibilityFocused003
1448 * @tc.name: ClearAccessibilityFocused
1449 * @tc.desc: Test function ClearAccessibilityFocused
1450 */
1451 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_ClearAccessibilityFocused003,
1452 TestSize.Level1)
1453 {
1454 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ClearAccessibilityFocused003 start";
1455 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1456 mgr.a11yFocusedWindowId_ = ACTIVE_WINDOW_ID;
1457 sptr<AccessibilityAccountData> accountData =
1458 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1459 if (!accountData) {
1460 GTEST_LOG_(INFO) << "accountData is null";
1461 return;
1462 }
1463 sptr<IAccessibilityElementOperator> proxy = new(std::nothrow) AccessibilityElementOperatorProxy(nullptr);
1464 sptr<AccessibilityWindowConnection> windowConnection =
1465 new(std::nothrow) AccessibilityWindowConnection(ACTIVE_WINDOW_ID, proxy, ACCOUNT_ID);
1466 accountData->RemoveAccessibilityWindowConnection(ACTIVE_WINDOW_ID);
1467 accountData->AddAccessibilityWindowConnection(ACTIVE_WINDOW_ID, windowConnection);
1468 /* ClearAccessibilityFocused */
1469 mgr.ClearAccessibilityFocused();
1470 /* test */
1471 EXPECT_EQ(ACTIVE_WINDOW_ID, AccessibilityAbilityHelper::GetInstance().GetEventWindowId());
1472 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ClearAccessibilityFocused003 end";
1473 }
1474
1475 /**
1476 * @tc.number: AccessibilityWindowManager_Unittest_DeregisterWindowListener001
1477 * @tc.name: RegisterWindowListener
1478 * @tc.desc: Test function RegisterWindowListener
1479 */
1480 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_DeregisterWindowListener001,
1481 TestSize.Level1)
1482 {
1483 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_DeregisterWindowListener001 start";
1484
1485 Singleton<AccessibilityWindowManager>::GetInstance().DeregisterWindowListener();
1486
1487 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_DeregisterWindowListener001 end";
1488 }
1489
1490 /**
1491 * @tc.number: AccessibilityWindowManager_Unittest_DeregisterWindowListener002
1492 * @tc.name: RegisterWindowListener
1493 * @tc.desc: Test function RegisterWindowListener
1494 */
1495 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_DeregisterWindowListener002,
1496 TestSize.Level1)
1497 {
1498 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_DeregisterWindowListener002 start";
1499
1500 const std::string AAMS_SERVICE_NAME = "AccessibleAbilityManagerService";
1501 std::shared_ptr<AppExecFwk::EventRunner> runner_ = AppExecFwk::EventRunner::Create(AAMS_SERVICE_NAME);
1502 std::shared_ptr<AppExecFwk::EventHandler> handler_ = std::make_shared<AppExecFwk::EventHandler>(runner_);
1503
1504 Singleton<AccessibilityWindowManager>::GetInstance().RegisterWindowListener(handler_);
1505 Singleton<AccessibilityWindowManager>::GetInstance().DeregisterWindowListener();
1506
1507 EXPECT_NE(handler_, nullptr);
1508
1509 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_DeregisterWindowListener002 end";
1510 }
1511
1512 /**
1513 * @tc.number: AccessibilityWindowManager_Unittest_DeInit001
1514 * @tc.name: DeInit
1515 * @tc.desc: Test function DeInit
1516 */
1517 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_DeInit001, TestSize.Level1)
1518 {
1519 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_DeInit001 start";
1520 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
1521 int32_t windowId = WINDOW_ID;
1522 AccessibilityWindowInfo winInfo;
1523
1524 windowInfoManager.activeWindowId_ = windowId;
1525 windowInfoManager.a11yFocusedWindowId_ = windowId;
1526 windowInfoManager.a11yWindows_.emplace(windowId, winInfo);
1527 windowInfoManager.DeInit();
1528
1529 EXPECT_EQ(windowInfoManager.activeWindowId_, INVALID_WINDOW_ID);
1530 EXPECT_EQ(windowInfoManager.a11yFocusedWindowId_, INVALID_WINDOW_ID);
1531 EXPECT_TRUE(!windowInfoManager.a11yWindows_.size());
1532 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_DeInit001 end";
1533 }
1534
1535 /**
1536 * @tc.number: AccessibilityWindowManager_Unittest_Init001
1537 * @tc.name: Init
1538 * @tc.desc: Test function Init
1539 */
1540 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_Init001, TestSize.Level1)
1541 {
1542 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_Init001 start";
1543 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
1544 int32_t windowId = WINDOW_ID;
1545 AccessibilityWindowInfo winInfo;
1546
1547 windowInfoManager.activeWindowId_ = windowId;
1548 windowInfoManager.a11yFocusedWindowId_ = windowId;
1549 windowInfoManager.a11yWindows_.emplace(windowId, winInfo);
1550 EXPECT_EQ(1, (int)windowInfoManager.a11yWindows_.size());
1551
1552 int32_t windowId1 = ACTIVE_WINDOW_ID;
1553 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(
1554 Rosen::WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
1555 EXPECT_TRUE(rosen_winInfo != nullptr);
1556
1557 AccessibilityWindowInfo info = windowInfoManager.CreateAccessibilityWindowInfo(rosen_winInfo);
1558 info.SetAccessibilityWindowType(AccessibilityWindowType::TYPE_APPLICATION);
1559 windowInfoManager.a11yWindows_.insert(std::make_pair(windowId1, info));
1560 EXPECT_EQ(2, (int)windowInfoManager.a11yWindows_.size());
1561
1562 /* SetAccessibilityFocusedWindow */
1563 windowInfoManager.SetAccessibilityFocusedWindow(windowId1);
1564 EXPECT_EQ(windowInfoManager.a11yFocusedWindowId_, ACTIVE_WINDOW_ID);
1565
1566 bool result = windowInfoManager.Init();
1567 EXPECT_EQ(result, true);
1568
1569 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_Init001 end";
1570 }
1571 } // namespace Accessibility
1572 } // namespace OHOS