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