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