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