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);
__anon96be1aa90202() 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);
__anon96be1aa90302() 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);
__anon96be1aa90402() 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);
__anon96be1aa90502() 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);
__anon96be1aa90602() 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);
__anon96be1aa90702() 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 rosen_winInfo_second->wid_ = 2;
935 rosen_winInfo_second->innerWid_ = 2;
936 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
937 infos.emplace_back(rosen_winInfo_first);
938 infos.emplace_back(rosen_winInfo_second);
939
940 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
941 windowInfoManager.a11yWindows_.clear();
942 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_ALL);
943 for (auto& info : windowInfoManager.a11yWindows_) {
944 bool cmpFirstBundleName = info.second.GetBundleName() == "rosen_winInfo_first";
945 bool cmpSecondBundleName = info.second.GetBundleName() == "rosen_winInfo_second";
946 EXPECT_TRUE(cmpFirstBundleName || cmpSecondBundleName);
947 }
948 windowInfoManager.a11yWindows_.clear();
949 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange019 end";
950 }
951
952 /**
953 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange020
954 * @tc.name: OnWindowChange
955 * @tc.desc: Test function OnWindowChange(layer success)
956 */
957 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange020, TestSize.Level1)
958 {
959 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange020 start";
960 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo_first = GetRosenWindowInfo(Rosen::WindowType::APP_WINDOW_BASE);
961 rosen_winInfo_first->bundleName_ = "rosen_winInfo_first";
962 rosen_winInfo_first->touchHotAreas_ = {Rosen::Rect{0, 0, 2, 2}, Rosen::Rect{2, 2, 4, 4}};
963 rosen_winInfo_first->wid_ = 1;
964 rosen_winInfo_first->layer_ = 2;
965
966 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo_second = GetRosenWindowInfo(Rosen::WindowType::APP_WINDOW_BASE);
967 rosen_winInfo_second->bundleName_ = "rosen_winInfo_second";
968 rosen_winInfo_second->touchHotAreas_ = {Rosen::Rect{0, 0, 3, 3}, Rosen::Rect{3, 3, 6, 6}};
969 rosen_winInfo_second->wid_ = 2;
970 rosen_winInfo_second->innerWid_ = 2;
971 rosen_winInfo_second->layer_ = 1;
972 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
973 infos.emplace_back(rosen_winInfo_first);
974 infos.emplace_back(rosen_winInfo_second);
975
976 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
977 windowInfoManager.a11yWindows_.clear();
978 EXPECT_TRUE(windowInfoManager.a11yWindows_.size() == 0);
979 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_ALL);
980 windowInfoManager.a11yWindows_.clear();
981 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange020 end";
982 }
983
984 /**
985 * @tc.number: AccessibilityWindowManager_Unittest_SetActiveWindow001
986 * @tc.name: SetActiveWindow
987 * @tc.desc: Test function SetActiveWindow
988 */
989 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_SetActiveWindow001, TestSize.Level1)
990 {
991 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetActiveWindow001 start";
992 /* map insert value */
993 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
994 AccessibilityWindowInfo info;
995 mgr.activeWindowId_ = ACTIVE_WINDOW_ID;
996 mgr.a11yWindows_.clear();
997 mgr.a11yWindows_.insert(std::make_pair(ANY_WINDOW_ID, info));
998 /* SetActiveWindow */
999 int32_t windowId = INVALID_WINDOW_ID;
1000 mgr.SetActiveWindow(windowId);
1001 /* test */
1002 bool test1 = false;
1003 if (mgr.a11yWindows_.count(ACTIVE_WINDOW_ID)) {
1004 test1 = true;
1005 }
1006 EXPECT_FALSE(test1);
1007 EXPECT_EQ(INVALID_WINDOW_ID, mgr.activeWindowId_);
1008
1009 mgr.a11yWindows_.clear();
1010 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetActiveWindow001 end";
1011 }
1012
1013 /**
1014 * @tc.number: AccessibilityWindowManager_Unittest_SetActiveWindow002
1015 * @tc.name: SetActiveWindow
1016 * @tc.desc: Test function SetActiveWindow
1017 */
1018 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_SetActiveWindow002, TestSize.Level1)
1019 {
1020 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetActiveWindow002 start";
1021 /* map insert value */
1022 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1023 AccessibilityWindowInfo info;
1024 mgr.activeWindowId_ = ACTIVE_WINDOW_ID;
1025 mgr.a11yWindows_.clear();
1026 mgr.a11yWindows_.insert(std::make_pair(ACTIVE_WINDOW_ID, info));
1027 /* SetActiveWindow */
1028 int32_t windowId = INVALID_WINDOW_ID;
1029 mgr.SetActiveWindow(windowId);
1030 /* test */
1031 bool test1 = false;
1032 if (mgr.a11yWindows_.count(ACTIVE_WINDOW_ID)) {
1033 test1 = true;
1034 }
1035 EXPECT_TRUE(test1);
1036 bool test2 = mgr.a11yWindows_[ACTIVE_WINDOW_ID].IsActive();
1037 EXPECT_FALSE(test2);
1038 EXPECT_EQ(INVALID_WINDOW_ID, mgr.activeWindowId_);
1039
1040 mgr.a11yWindows_.clear();
1041 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetActiveWindow002 end";
1042 }
1043
1044 /**
1045 * @tc.number: AccessibilityWindowManager_Unittest_SetActiveWindow003
1046 * @tc.name: SetActiveWindow
1047 * @tc.desc: Test function SetActiveWindow
1048 */
1049 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_SetActiveWindow003, TestSize.Level1)
1050 {
1051 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetActiveWindow003 start";
1052 /* map insert value */
1053 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1054 AccessibilityWindowInfo info;
1055 mgr.activeWindowId_ = ACTIVE_WINDOW_ID;
1056 mgr.a11yWindows_.clear();
1057 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1058 mgr.a11yWindows_.insert(std::make_pair(ANY_WINDOW_ID, info));
1059 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1060 /* SetActiveWindow */
1061 int32_t windowId = ACTIVE_WINDOW_ID;
1062 mgr.SetActiveWindow(windowId);
1063 /* test */
1064 bool test1 = false;
1065 if (mgr.a11yWindows_.count(windowId)) {
1066 test1 = true;
1067 }
1068 EXPECT_FALSE(test1);
1069 EXPECT_EQ(ACTIVE_WINDOW_ID, mgr.activeWindowId_);
1070
1071 mgr.a11yWindows_.clear();
1072 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetActiveWindow003 end";
1073 }
1074
1075 /**
1076 * @tc.number: AccessibilityWindowManager_Unittest_SetActiveWindow004
1077 * @tc.name: SetActiveWindow
1078 * @tc.desc: Test function SetActiveWindow
1079 */
1080 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_SetActiveWindow004, TestSize.Level1)
1081 {
1082 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetActiveWindow004 start";
1083 /* map insert value */
1084 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1085 AccessibilityWindowInfo info1;
1086 AccessibilityWindowInfo info2;
1087 mgr.activeWindowId_ = ACTIVE_WINDOW_ID;
1088 int32_t windowId = ANY_WINDOW_ID;
1089 mgr.a11yWindows_.clear();
1090 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1091 mgr.a11yWindows_.insert(std::make_pair(ACTIVE_WINDOW_ID, info1));
1092 mgr.a11yWindows_.insert(std::make_pair(windowId, info2));
1093 EXPECT_EQ(2, (int)mgr.a11yWindows_.size());
1094 /* SetActiveWindow */
1095 mgr.SetActiveWindow(windowId);
1096 /* test */
1097 bool test1 = false;
1098 if (mgr.a11yWindows_.count(ACTIVE_WINDOW_ID)) {
1099 test1 = true;
1100 }
1101 EXPECT_TRUE(test1);
1102 bool test2 = mgr.a11yWindows_[ACTIVE_WINDOW_ID].IsActive();
1103 EXPECT_FALSE(test2);
1104 EXPECT_EQ(ANY_WINDOW_ID, mgr.activeWindowId_);
1105 bool test3 = mgr.a11yWindows_[mgr.activeWindowId_].IsActive();
1106 EXPECT_TRUE(test3);
1107
1108 mgr.a11yWindows_.clear();
1109 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetActiveWindow004 end";
1110 }
1111
1112 /**
1113 * @tc.number: AccessibilityWindowManager_Unittest_SetActiveWindow005
1114 * @tc.name: SetActiveWindow
1115 * @tc.desc: Test function SetActiveWindow
1116 */
1117 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_SetActiveWindow005, TestSize.Level1)
1118 {
1119 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetActiveWindow005 start";
1120 /* map insert value */
1121 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1122 AccessibilityWindowInfo info1;
1123 AccessibilityWindowInfo info2;
1124 mgr.activeWindowId_ = ACTIVE_WINDOW_ID;
1125 mgr.a11yFocusedWindowId_ = ACTIVE_WINDOW_ID;
1126 int32_t windowId = ANY_WINDOW_ID;
1127 mgr.a11yWindows_.clear();
1128 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1129 mgr.a11yWindows_.insert(std::make_pair(ACTIVE_WINDOW_ID, info1));
1130 mgr.a11yWindows_.insert(std::make_pair(windowId, info2));
1131 EXPECT_EQ(2, (int)mgr.a11yWindows_.size());
1132 /* SetActiveWindow */
1133 mgr.SetActiveWindow(windowId);
1134 /* test */
1135 EXPECT_EQ(INVALID_WINDOW_ID, mgr.a11yFocusedWindowId_);
1136 mgr.a11yWindows_.clear();
1137 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetActiveWindow005 end";
1138 }
1139
1140 /**
1141 * @tc.number: AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow001
1142 * @tc.name: SetAccessibilityFocusedWindow
1143 * @tc.desc: Test function SetAccessibilityFocusedWindow
1144 */
1145 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow001,
1146 TestSize.Level1)
1147 {
1148 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow001 start";
1149 /* map insert value */
1150 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1151 AccessibilityWindowInfo info;
1152 mgr.a11yFocusedWindowId_ = ANY_WINDOW_ID;
1153 mgr.a11yWindows_.clear();
1154 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1155 mgr.a11yWindows_.insert(std::make_pair(ACTIVE_WINDOW_ID, info));
1156 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1157 /* SetAccessibilityFocusedWindow */
1158 int32_t windowId = INVALID_WINDOW_ID;
1159 mgr.SetAccessibilityFocusedWindow(windowId);
1160 /* test */
1161 bool test1 = false;
1162 if (mgr.a11yWindows_.count(ANY_WINDOW_ID)) {
1163 test1 = true;
1164 }
1165 EXPECT_FALSE(test1);
1166 EXPECT_EQ(INVALID_WINDOW_ID, mgr.a11yFocusedWindowId_);
1167
1168 mgr.a11yWindows_.clear();
1169 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow001 end";
1170 }
1171
1172 /**
1173 * @tc.number: AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow002
1174 * @tc.name: SetAccessibilityFocusedWindow
1175 * @tc.desc: Test function SetAccessibilityFocusedWindow
1176 */
1177 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow002,
1178 TestSize.Level1)
1179 {
1180 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow002 start";
1181 /* map insert value */
1182 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1183 AccessibilityWindowInfo info;
1184 mgr.a11yFocusedWindowId_ = ANY_WINDOW_ID;
1185 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1186 mgr.a11yWindows_.insert(std::make_pair(ANY_WINDOW_ID, info));
1187 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1188 /* SetAccessibilityFocusedWindow */
1189 int32_t windowId = INVALID_WINDOW_ID;
1190 mgr.SetAccessibilityFocusedWindow(windowId);
1191 /* test */
1192 bool test1 = false;
1193 if (mgr.a11yWindows_.count(ANY_WINDOW_ID)) {
1194 test1 = true;
1195 }
1196 EXPECT_TRUE(test1);
1197 bool test2 = mgr.a11yWindows_[ANY_WINDOW_ID].IsAccessibilityFocused();
1198 EXPECT_FALSE(test2);
1199 EXPECT_EQ(INVALID_WINDOW_ID, mgr.a11yFocusedWindowId_);
1200
1201 mgr.a11yWindows_.clear();
1202 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow002 end";
1203 }
1204
1205 /**
1206 * @tc.number: AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow003
1207 * @tc.name: SetAccessibilityFocusedWindow
1208 * @tc.desc: Test function SetAccessibilityFocusedWindow
1209 */
1210 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow003,
1211 TestSize.Level1)
1212 {
1213 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow003 start";
1214 /* map insert value */
1215 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1216 AccessibilityWindowInfo info;
1217 mgr.a11yFocusedWindowId_ = ACTIVE_WINDOW_ID;
1218 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1219 mgr.a11yWindows_.insert(std::make_pair(ANY_WINDOW_ID, info));
1220 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1221 /* SetAccessibilityFocusedWindow */
1222 int32_t windowId = ACTIVE_WINDOW_ID;
1223 mgr.SetAccessibilityFocusedWindow(windowId);
1224 /* test */
1225 bool test1 = false;
1226 if (mgr.a11yWindows_.count(windowId)) {
1227 test1 = true;
1228 }
1229 EXPECT_FALSE(test1);
1230 EXPECT_EQ(ACTIVE_WINDOW_ID, mgr.a11yFocusedWindowId_);
1231
1232 mgr.a11yWindows_.clear();
1233 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow003 end";
1234 }
1235
1236 /**
1237 * @tc.number: AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow004
1238 * @tc.name: SetAccessibilityFocusedWindow
1239 * @tc.desc: Test function SetAccessibilityFocusedWindow
1240 */
1241 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow004,
1242 TestSize.Level1)
1243 {
1244 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow004 start";
1245 /* map insert value */
1246 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1247 AccessibilityWindowInfo info1;
1248 AccessibilityWindowInfo info2;
1249 mgr.a11yFocusedWindowId_ = ANY_WINDOW_ID;
1250 int32_t windowId = ACTIVE_WINDOW_ID;
1251 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1252 mgr.a11yWindows_.insert(std::make_pair(ANY_WINDOW_ID, info1));
1253 mgr.a11yWindows_.insert(std::make_pair(windowId, info2));
1254 EXPECT_EQ(2, (int)mgr.a11yWindows_.size());
1255 /* SetAccessibilityFocusedWindow */
1256 mgr.SetAccessibilityFocusedWindow(windowId);
1257 /* test */
1258 bool test1 = false;
1259 if (mgr.a11yWindows_.count(ANY_WINDOW_ID)) {
1260 test1 = true;
1261 }
1262 EXPECT_TRUE(test1);
1263 bool test2 = mgr.a11yWindows_[ANY_WINDOW_ID].IsAccessibilityFocused();
1264 EXPECT_FALSE(test2);
1265 EXPECT_EQ(ACTIVE_WINDOW_ID, mgr.a11yFocusedWindowId_);
1266 bool test3 = mgr.a11yWindows_[mgr.a11yFocusedWindowId_].IsAccessibilityFocused();
1267 EXPECT_TRUE(test3);
1268
1269 mgr.a11yWindows_.clear();
1270 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow004 end";
1271 }
1272
1273 /**
1274 * @tc.number: AccessibilityWindowManager_Unittest_GetAccessibilityWindows001
1275 * @tc.name: GetAccessibilityWindows
1276 * @tc.desc: Test function GetAccessibilityWindows
1277 */
1278 HWTEST_F(
1279 AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_GetAccessibilityWindows001, TestSize.Level1)
1280 {
1281 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetAccessibilityWindows001 start";
1282 /* map insert value */
1283 int32_t windowId = ANY_WINDOW_ID;
1284
1285 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(
1286 Rosen::WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
1287 EXPECT_TRUE(rosen_winInfo != nullptr);
1288
1289 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
1290 infos.emplace_back(rosen_winInfo);
1291
1292 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1293 AccessibilityWindowInfo info = mgr.CreateAccessibilityWindowInfo(rosen_winInfo);
1294 info.SetAccessibilityWindowType(AccessibilityWindowType::TYPE_APPLICATION);
1295 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1296 mgr.a11yWindows_.insert(std::make_pair(windowId, info));
1297 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1298
1299 /* SetAccessibilityFocusedWindow */
1300 mgr.SetAccessibilityFocusedWindow(windowId);
1301
1302 /* GetAccessibilityWindows */
1303 std::vector<AccessibilityWindowInfo> windows = mgr.GetAccessibilityWindows();
1304 ASSERT_EQ(1, (int)windows.size());
1305 static Accessibility::AccessibilityWindowType type = windows.begin()->GetAccessibilityWindowType();
1306 EXPECT_EQ(AccessibilityWindowType::TYPE_APPLICATION, type);
1307
1308 mgr.a11yWindows_.clear();
1309 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetAccessibilityWindows001 end";
1310 }
1311
1312 /**
1313 * @tc.number: AccessibilityWindowManager_Unittest_GetAccessibilityWindow001
1314 * @tc.name: GetAccessibilityWindow
1315 * @tc.desc: Test function GetAccessibilityWindow
1316 */
1317 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_GetAccessibilityWindow001, TestSize.Level1)
1318 {
1319 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetAccessibilityWindow001 start";
1320 /* map insert value */
1321 int32_t windowId = ANY_WINDOW_ID;
1322
1323 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(
1324 Rosen::WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
1325 EXPECT_TRUE(rosen_winInfo != nullptr);
1326
1327 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
1328 infos.emplace_back(rosen_winInfo);
1329
1330 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1331 AccessibilityWindowInfo info = mgr.CreateAccessibilityWindowInfo(rosen_winInfo);
1332 info.SetAccessibilityWindowType(AccessibilityWindowType::TYPE_APPLICATION);
1333 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1334 mgr.a11yWindows_.insert(std::make_pair(windowId, info));
1335 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1336
1337 /* GetAccessibilityWindow */
1338 bool window = mgr.GetAccessibilityWindow(windowId, info);
1339 EXPECT_TRUE(window);
1340
1341 mgr.a11yWindows_.clear();
1342 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetAccessibilityWindow001 end";
1343 }
1344
1345 /**
1346 * @tc.number: AccessibilityWindowManager_Unittest_GetAccessibilityWindow002
1347 * @tc.name: GetAccessibilityWindow
1348 * @tc.desc: Test function GetAccessibilityWindow
1349 */
1350 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_GetAccessibilityWindow002, TestSize.Level1)
1351 {
1352 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetAccessibilityWindow002 start";
1353 /* map insert value */
1354 int32_t windowId = ANY_WINDOW_ID;
1355
1356 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(
1357 Rosen::WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
1358 EXPECT_TRUE(rosen_winInfo != nullptr);
1359
1360 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
1361 infos.emplace_back(rosen_winInfo);
1362
1363 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1364 AccessibilityWindowInfo info = mgr.CreateAccessibilityWindowInfo(rosen_winInfo);
1365 info.SetAccessibilityWindowType(AccessibilityWindowType::TYPE_APPLICATION);
1366 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1367 mgr.a11yWindows_.insert(std::make_pair(windowId, info));
1368 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1369
1370 /* GetAccessibilityWindow */
1371 bool window = mgr.GetAccessibilityWindow(-1, info);
1372 EXPECT_FALSE(window);
1373
1374 mgr.a11yWindows_.clear();
1375 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetAccessibilityWindow002 end";
1376 }
1377
1378 /**
1379 * @tc.number: AccessibilityWindowManager_Unittest_IsValidWindow001
1380 * @tc.name: IsValidWindow
1381 * @tc.desc: Test function IsValidWindow
1382 */
1383 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_IsValidWindow001, TestSize.Level1)
1384 {
1385 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_IsValidWindow001 start";
1386 /* map insert value */
1387 int32_t windowId = ANY_WINDOW_ID;
1388
1389 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(
1390 Rosen::WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
1391 EXPECT_TRUE(rosen_winInfo != nullptr);
1392
1393 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
1394 infos.emplace_back(rosen_winInfo);
1395
1396 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1397 AccessibilityWindowInfo info = mgr.CreateAccessibilityWindowInfo(rosen_winInfo);
1398 info.SetAccessibilityWindowType(AccessibilityWindowType::TYPE_APPLICATION);
1399 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1400 mgr.a11yWindows_.insert(std::make_pair(windowId, info));
1401 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1402
1403 /* IsValidWindow */
1404 bool window = mgr.IsValidWindow(windowId);
1405 EXPECT_TRUE(window);
1406
1407 mgr.a11yWindows_.clear();
1408 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_IsValidWindow001 end";
1409 }
1410
1411 /**
1412 * @tc.number: AccessibilityWindowManager_Unittest_IsValidWindow002
1413 * @tc.name: IsValidWindow
1414 * @tc.desc: Test function IsValidWindow
1415 */
1416 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_IsValidWindow002, TestSize.Level1)
1417 {
1418 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_IsValidWindow002 start";
1419 /* map insert value */
1420 int32_t windowId = ANY_WINDOW_ID;
1421
1422 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(
1423 Rosen::WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
1424 EXPECT_TRUE(rosen_winInfo != nullptr);
1425
1426 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
1427 infos.emplace_back(rosen_winInfo);
1428
1429 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1430 AccessibilityWindowInfo info = mgr.CreateAccessibilityWindowInfo(rosen_winInfo);
1431 info.SetAccessibilityWindowType(AccessibilityWindowType::TYPE_APPLICATION);
1432 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1433 mgr.a11yWindows_.insert(std::make_pair(windowId, info));
1434 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1435
1436 /* IsValidWindow */
1437 bool window = mgr.IsValidWindow(0);
1438 EXPECT_FALSE(window);
1439
1440 mgr.a11yWindows_.clear();
1441 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_IsValidWindow002 end";
1442 }
1443
1444 /**
1445 * @tc.number: AccessibilityWindowManager_Unittest_SetWindowSize001
1446 * @tc.name: SetActiveWindow
1447 * @tc.desc: Test function SetActiveWindow
1448 */
1449 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_SetWindowSize001, TestSize.Level1)
1450 {
1451 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetWindowSize001 start";
1452 /* map insert value */
1453 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1454 int32_t windowId = ANY_WINDOW_ID;
1455 AccessibilityWindowInfo info;
1456 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1457 mgr.a11yWindows_.insert(std::make_pair(windowId, info));
1458 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1459
1460 /* SetWindowSize */
1461 Rect rect(1, 2, 3, 4);
1462 mgr.SetWindowSize(windowId, rect);
1463 AccessibilityWindowInfo mapInfo;
1464 for (auto& window : mgr.a11yWindows_) {
1465 mapInfo = window.second;
1466 }
1467 EXPECT_EQ(rect.GetLeftTopXScreenPostion(), mapInfo.GetRectInScreen().GetLeftTopXScreenPostion());
1468 EXPECT_EQ(rect.GetRightBottomXScreenPostion(), mapInfo.GetRectInScreen().GetRightBottomXScreenPostion());
1469
1470 mgr.a11yWindows_.clear();
1471 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetWindowSize001 end";
1472 }
1473
1474 /**
1475 * @tc.number: AccessibilityWindowManager_Unittest_ClearAccessibilityFocused001
1476 * @tc.name: ClearAccessibilityFocused
1477 * @tc.desc: Test function ClearAccessibilityFocused
1478 */
1479 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_ClearAccessibilityFocused001,
1480 TestSize.Level1)
1481 {
1482 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ClearAccessibilityFocused001 start";
1483 /* map insert value */
1484 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1485 AccessibilityWindowInfo info1;
1486 mgr.a11yFocusedWindowId_ = ACTIVE_WINDOW_ID;
1487 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1488 mgr.a11yWindows_.insert(std::make_pair(ACTIVE_WINDOW_ID, info1));
1489
1490 AccessibilityAbilityHelper::GetInstance().SetNeedAccountDataNullFlag(true);
1491 /* ClearAccessibilityFocused */
1492 mgr.ClearAccessibilityFocused();
1493 AccessibilityAbilityHelper::GetInstance().SetNeedAccountDataNullFlag(false);
1494 /* test */
1495 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1496 mgr.a11yWindows_.clear();
1497 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ClearAccessibilityFocused001 end";
1498 }
1499
1500 /**
1501 * @tc.number: AccessibilityWindowManager_Unittest_ClearAccessibilityFocused002
1502 * @tc.name: ClearAccessibilityFocused
1503 * @tc.desc: Test function ClearAccessibilityFocused
1504 */
1505 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_ClearAccessibilityFocused002,
1506 TestSize.Level1)
1507 {
1508 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ClearAccessibilityFocused002 start";
1509 /* map insert value */
1510 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1511 AccessibilityWindowInfo info1;
1512 mgr.a11yFocusedWindowId_ = ACTIVE_WINDOW_ID;
1513 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1514 mgr.a11yWindows_.insert(std::make_pair(ACTIVE_WINDOW_ID, info1));
1515 sptr<AccessibilityAccountData> accountData =
1516 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1517 if (!accountData) {
1518 GTEST_LOG_(INFO) << "accountData is null";
1519 return;
1520 }
1521 sptr<AccessibilityWindowConnection> windowConnection =
1522 new(std::nothrow) AccessibilityWindowConnection(ACTIVE_WINDOW_ID, nullptr, ACCOUNT_ID);
1523 accountData->RemoveAccessibilityWindowConnection(ACTIVE_WINDOW_ID);
1524 accountData->AddAccessibilityWindowConnection(ACTIVE_WINDOW_ID, windowConnection);
1525 /* ClearAccessibilityFocused */
1526 mgr.ClearAccessibilityFocused();
1527 /* test */
1528 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1529 mgr.a11yWindows_.clear();
1530 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ClearAccessibilityFocused002 end";
1531 }
1532
1533 /**
1534 * @tc.number: AccessibilityWindowManager_Unittest_ClearAccessibilityFocused003
1535 * @tc.name: ClearAccessibilityFocused
1536 * @tc.desc: Test function ClearAccessibilityFocused
1537 */
1538 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_ClearAccessibilityFocused003,
1539 TestSize.Level1)
1540 {
1541 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ClearAccessibilityFocused003 start";
1542 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1543 mgr.a11yFocusedWindowId_ = ACTIVE_WINDOW_ID;
1544 sptr<AccessibilityAccountData> accountData =
1545 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1546 if (!accountData) {
1547 GTEST_LOG_(INFO) << "accountData is null";
1548 return;
1549 }
1550 sptr<IAccessibilityElementOperator> proxy = new(std::nothrow) AccessibilityElementOperatorProxy(nullptr);
1551 sptr<AccessibilityWindowConnection> windowConnection =
1552 new(std::nothrow) AccessibilityWindowConnection(ACTIVE_WINDOW_ID, proxy, ACCOUNT_ID);
1553 accountData->RemoveAccessibilityWindowConnection(ACTIVE_WINDOW_ID);
1554 accountData->AddAccessibilityWindowConnection(ACTIVE_WINDOW_ID, windowConnection);
1555 /* ClearAccessibilityFocused */
1556 mgr.ClearAccessibilityFocused();
1557 /* test */
1558 EXPECT_EQ(ACTIVE_WINDOW_ID, AccessibilityAbilityHelper::GetInstance().GetEventWindowId());
1559 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ClearAccessibilityFocused003 end";
1560 }
1561
1562 /**
1563 * @tc.number: AccessibilityWindowManager_Unittest_DeregisterWindowListener001
1564 * @tc.name: RegisterWindowListener
1565 * @tc.desc: Test function RegisterWindowListener
1566 */
1567 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_DeregisterWindowListener001,
1568 TestSize.Level1)
1569 {
1570 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_DeregisterWindowListener001 start";
1571
1572 Singleton<AccessibilityWindowManager>::GetInstance().DeregisterWindowListener();
1573
1574 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_DeregisterWindowListener001 end";
1575 }
1576
1577 /**
1578 * @tc.number: AccessibilityWindowManager_Unittest_DeregisterWindowListener002
1579 * @tc.name: RegisterWindowListener
1580 * @tc.desc: Test function RegisterWindowListener
1581 */
1582 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_DeregisterWindowListener002,
1583 TestSize.Level1)
1584 {
1585 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_DeregisterWindowListener002 start";
1586
1587 const std::string AAMS_SERVICE_NAME = "AccessibleAbilityManagerService";
1588 std::shared_ptr<AppExecFwk::EventRunner> runner_ =
1589 AppExecFwk::EventRunner::Create(AAMS_SERVICE_NAME, AppExecFwk::ThreadMode::FFRT);
1590 std::shared_ptr<AppExecFwk::EventHandler> handler_ = std::make_shared<AppExecFwk::EventHandler>(runner_);
1591
1592 Singleton<AccessibilityWindowManager>::GetInstance().RegisterWindowListener(handler_);
1593 Singleton<AccessibilityWindowManager>::GetInstance().DeregisterWindowListener();
1594
1595 EXPECT_NE(handler_, nullptr);
1596
1597 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_DeregisterWindowListener002 end";
1598 }
1599
1600 /**
1601 * @tc.number: AccessibilityWindowManager_Unittest_DeInit001
1602 * @tc.name: DeInit
1603 * @tc.desc: Test function DeInit
1604 */
1605 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_DeInit001, TestSize.Level1)
1606 {
1607 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_DeInit001 start";
1608 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
1609 int32_t windowId = WINDOW_ID;
1610 AccessibilityWindowInfo winInfo;
1611
1612 windowInfoManager.activeWindowId_ = windowId;
1613 windowInfoManager.a11yFocusedWindowId_ = windowId;
1614 windowInfoManager.a11yWindows_.emplace(windowId, winInfo);
1615 windowInfoManager.DeInit();
1616
1617 EXPECT_EQ(windowInfoManager.activeWindowId_, INVALID_WINDOW_ID);
1618 EXPECT_EQ(windowInfoManager.a11yFocusedWindowId_, INVALID_WINDOW_ID);
1619 EXPECT_TRUE(!windowInfoManager.a11yWindows_.size());
1620 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_DeInit001 end";
1621 }
1622
1623 /**
1624 * @tc.number: AccessibilityWindowManager_Unittest_Init001
1625 * @tc.name: Init
1626 * @tc.desc: Test function Init
1627 */
1628 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_Init001, TestSize.Level1)
1629 {
1630 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_Init001 start";
1631 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
1632 int32_t windowId = WINDOW_ID;
1633 AccessibilityWindowInfo winInfo;
1634
1635 windowInfoManager.activeWindowId_ = windowId;
1636 windowInfoManager.a11yFocusedWindowId_ = windowId;
1637 windowInfoManager.a11yWindows_.emplace(windowId, winInfo);
1638 EXPECT_EQ(1, (int)windowInfoManager.a11yWindows_.size());
1639
1640 int32_t windowId1 = ACTIVE_WINDOW_ID;
1641 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(
1642 Rosen::WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
1643 EXPECT_TRUE(rosen_winInfo != nullptr);
1644
1645 AccessibilityWindowInfo info = windowInfoManager.CreateAccessibilityWindowInfo(rosen_winInfo);
1646 info.SetAccessibilityWindowType(AccessibilityWindowType::TYPE_APPLICATION);
1647 windowInfoManager.a11yWindows_.insert(std::make_pair(windowId1, info));
1648 EXPECT_EQ(2, (int)windowInfoManager.a11yWindows_.size());
1649
1650 /* SetAccessibilityFocusedWindow */
1651 windowInfoManager.SetAccessibilityFocusedWindow(windowId1);
1652 EXPECT_EQ(windowInfoManager.a11yFocusedWindowId_, ACTIVE_WINDOW_ID);
1653
1654 bool result = windowInfoManager.Init();
1655 EXPECT_EQ(result, true);
1656
1657 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_Init001 end";
1658 }
1659
1660 /**
1661 * @tc.number: AccessibilityWindowManager_Unittest_GetRealWindowAndElementId001
1662 * @tc.name: GetRealWindowAndElementId
1663 * @tc.desc: Test function GetRealWindowAndElementId
1664 */
1665 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_GetRealWindowAndElementId001,
1666 TestSize.Level1)
1667 {
1668 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetRealWindowAndElementId001 start";
1669 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(Rosen::WindowType::APP_WINDOW_BASE);
1670 EXPECT_TRUE(rosen_winInfo != nullptr);
1671 rosen_winInfo->wid_ = 1;
1672 rosen_winInfo->innerWid_ = INNER_WINDOW_ID;
1673 rosen_winInfo->uiNodeId_ = INNER_ELEMENT_ID;
1674
1675 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
1676 windowInfoManager.a11yWindows_.clear();
1677 windowInfoManager.subWindows_.clear();
1678 windowInfoManager.a11yWindows_.insert(std::make_pair(rosen_winInfo->innerWid_,
1679 windowInfoManager.CreateAccessibilityWindowInfo(rosen_winInfo)));
1680 windowInfoManager.subWindows_.insert(rosen_winInfo->innerWid_);
1681
1682 int32_t windowId = INNER_WINDOW_ID;
1683 int64_t elementId = INVALID_ELEMENT_ID;
1684 windowInfoManager.GetRealWindowAndElementId(windowId, elementId);
1685 EXPECT_EQ(windowId, 1);
1686 EXPECT_EQ(elementId, INNER_ELEMENT_ID);
1687
1688 windowId = INNER_WINDOW_ID;
1689 elementId = 0;
1690 windowInfoManager.GetRealWindowAndElementId(windowId, elementId);
1691 EXPECT_EQ(windowId, 1);
1692 EXPECT_NE(elementId, INNER_ELEMENT_ID);
1693 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetRealWindowAndElementId001 end";
1694 }
1695
1696 /**
1697 * @tc.number: AccessibilityWindowManager_Unittest_GetSceneBoardInnerWinId001
1698 * @tc.name: GetSceneBoardInnerWinId
1699 * @tc.desc: Test function GetSceneBoardInnerWinId
1700 */
1701 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_GetSceneBoardInnerWinId001,
1702 TestSize.Level1)
1703 {
1704 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetSceneBoardInnerWinId001 start";
1705 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(Rosen::WindowType::APP_WINDOW_BASE);
1706 EXPECT_TRUE(rosen_winInfo != nullptr);
1707 rosen_winInfo->wid_ = 1;
1708 rosen_winInfo->innerWid_ = INNER_WINDOW_ID;
1709 rosen_winInfo->uiNodeId_ = INNER_ELEMENT_ID;
1710
1711 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
1712 windowInfoManager.a11yWindows_.clear();
1713 windowInfoManager.subWindows_.clear();
1714 windowInfoManager.a11yWindows_.insert(std::make_pair(rosen_winInfo->innerWid_,
1715 windowInfoManager.CreateAccessibilityWindowInfo(rosen_winInfo)));
1716 windowInfoManager.subWindows_.insert(rosen_winInfo->innerWid_);
1717
1718 int32_t windowId = 1;
1719 int64_t elementId = INNER_ELEMENT_ID;
1720 int32_t innerWid = 0;
1721 windowInfoManager.GetSceneBoardInnerWinId(windowId, elementId, innerWid);
1722 EXPECT_EQ(innerWid, INNER_WINDOW_ID);
1723 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetSceneBoardInnerWinId001 end";
1724 }
1725
1726 /**
1727 * @tc.number: AccessibilityWindowManager_Unittest_GetSceneBoardInnerWinId002
1728 * @tc.name: GetSceneBoardInnerWinId
1729 * @tc.desc: Test function GetSceneBoardInnerWinId
1730 */
1731 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_GetSceneBoardInnerWinId002,
1732 TestSize.Level1)
1733 {
1734 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetSceneBoardInnerWinId002 start";
1735 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(Rosen::WindowType::APP_WINDOW_BASE);
1736 EXPECT_TRUE(rosen_winInfo != nullptr);
1737 rosen_winInfo->wid_ = 1;
1738 rosen_winInfo->innerWid_ = INNER_WINDOW_ID;
1739 rosen_winInfo->uiNodeId_ = INNER_ELEMENT_ID;
1740
1741 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
1742 windowInfoManager.a11yWindows_.clear();
1743 windowInfoManager.subWindows_.clear();
1744 windowInfoManager.a11yWindows_.insert(std::make_pair(rosen_winInfo->innerWid_,
1745 windowInfoManager.CreateAccessibilityWindowInfo(rosen_winInfo)));
1746 windowInfoManager.subWindows_.insert(rosen_winInfo->innerWid_);
1747
1748 int32_t windowId = 2;
1749 int64_t elementId = INNER_ELEMENT_ID;
1750 int32_t innerWid = 0;
1751 windowInfoManager.GetSceneBoardInnerWinId(windowId, elementId, innerWid);
1752 EXPECT_NE(innerWid, INNER_WINDOW_ID);
1753 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetSceneBoardInnerWinId002 end";
1754 }
1755
1756 /**
1757 * @tc.number: AccessibilityWindowManager_Unittest_GetFocusedWindowId001
1758 * @tc.name: GetFocusedWindowId
1759 * @tc.desc: Test function GetFocusedWindowId
1760 */
1761 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_GetFocusedWindowId001,
1762 TestSize.Level1)
1763 {
1764 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetFocusedWindowId001 start";
1765 int32_t windowId = 1;
1766 RetError ret = Singleton<AccessibilityWindowManager>::GetInstance().GetFocusedWindowId(windowId);
1767 EXPECT_EQ(ret, RET_OK);
1768
1769 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetFocusedWindowId001 end";
1770 }
1771
1772 /**
1773 * @tc.number: AccessibilityWindowManager_Unittest_IsInnerWindowRootElement001
1774 * @tc.name: IsInnerWindowRootElement
1775 * @tc.desc: Test function IsInnerWindowRootElement
1776 */
1777 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_IsInnerWindowRootElement001,
1778 TestSize.Level1)
1779 {
1780 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_IsInnerWindowRootElement001 start";
1781 int32_t windowId = INNER_WINDOW_ID;
1782 int64_t elementId = INVALID_ELEMENT_ID;
1783 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1784 mgr.sceneBoardElementIdMap_.Clear();
1785
1786 EXPECT_FALSE(mgr.IsInnerWindowRootElement(elementId));
1787 mgr.sceneBoardElementIdMap_.InsertPair(windowId, elementId);
1788
1789 EXPECT_TRUE(mgr.IsInnerWindowRootElement(elementId));
1790 mgr.sceneBoardElementIdMap_.Clear();
1791 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_IsInnerWindowRootElement001 end";
1792 }
1793
1794 /**
1795 * @tc.number: AccessibilityWindowManager_Unittest_GetSceneBoardElementId001
1796 * @tc.name: GetSceneBoardElementId
1797 * @tc.desc: Test function GetSceneBoardElementId
1798 */
1799 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_GetSceneBoardElementId001, TestSize.Level1)
1800 {
1801 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetSceneBoardElementId001 start";
1802 int32_t windowId = ANY_WINDOW_ID;
1803 int32_t elementId = INVALID_ELEMENT_ID;
1804 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1805 mgr.GetSceneBoardElementId(windowId, elementId);
1806 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetSceneBoardElementId001 end";
1807 }
1808
1809 /**
1810 * @tc.number: AccessibilityWindowManager_Unittest_GetSceneBoardElementId002
1811 * @tc.name: GetSceneBoardElementId
1812 * @tc.desc: Test function GetSceneBoardElementId
1813 */
1814 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_GetSceneBoardElementId002, TestSize.Level1)
1815 {
1816 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetSceneBoardElementId002 start";
1817 int32_t windowId = ANY_WINDOW_ID;
1818 int32_t elementId = INVALID_SCENE_BOARD_ELEMENT_ID;
1819 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1820 mgr.GetSceneBoardElementId(windowId, elementId);
1821 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetSceneBoardElementId002 end";
1822 }
1823
1824 /**
1825 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowUpdate001
1826 * @tc.name: OnWindowUpdate
1827 * @tc.desc: Test function OnWindowUpdate
1828 */
1829 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowUpdate001, TestSize.Level1)
1830 {
1831 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowUpdate001 start";
1832
1833 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
1834 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
1835 infos.emplace_back(nullptr);
1836 windowInfoManager.RegisterWindowListener(nullptr);
1837 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_ACTIVE);
1838 sleep(1);
1839 windowInfoManager.a11yWindows_.clear();
1840 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowUpdate001 end";
1841 }
1842 } // namespace Accessibility
1843 } // namespace OHOS
1844