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