1 /*
2  * Copyright (c) 2021-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 // gtest
17 #include <gtest/gtest.h>
18 #include "scene_board_judgement.h"
19 #include "wm_common.h"
20 #include "window_manager.h"
21 #include "window_test_utils.h"
22 using namespace testing;
23 using namespace testing::ext;
24 
25 namespace OHOS {
26 namespace Rosen {
27 namespace {
28 constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_WINDOW, "WindowFocusTest"};
29 }
30 
31 using Utils = WindowTestUtils;
32 const int WAIT_ASYNC_US = 100000;  // 100000us
33 
34 class TestFocusChangedListener : public IFocusChangedListener {
35 public:
36     uint32_t focusedWindow_ = INVALID_WINDOW_ID;
37     uint32_t unfocusedWindow_ = INVALID_WINDOW_ID;
38     void OnFocused(const sptr<FocusChangeInfo>& focusChangeInfo) override;
39     void OnUnfocused(const sptr<FocusChangeInfo>& focusChangeInfo) override;
40 };
41 
42 class WindowFocusTest : public testing::Test {
43 public:
44     static void SetUpTestCase();
45     static void TearDownTestCase();
46     virtual void SetUp() override;
47     virtual void TearDown() override;
48     static sptr<TestFocusChangedListener> testFocusChangedListener_;
49     Utils::TestWindowInfo fullScreenAppInfo_;
50     Utils::TestWindowInfo floatAppInfo_;
51     Utils::TestWindowInfo subAppInfo_;
52 };
53 
54 sptr<TestFocusChangedListener> WindowFocusTest::testFocusChangedListener_ =
55     new TestFocusChangedListener();
56 
OnFocused(const sptr<FocusChangeInfo> & focusChangeInfo)57 void TestFocusChangedListener::OnFocused(const sptr<FocusChangeInfo>& focusChangeInfo)
58 {
59     WLOGI("TestFocusChangedListener Focused ID: %{public}u", focusChangeInfo->windowId_);
60     focusedWindow_ = focusChangeInfo->windowId_;
61 }
62 
OnUnfocused(const sptr<FocusChangeInfo> & focusChangeInfo)63 void TestFocusChangedListener::OnUnfocused(const sptr<FocusChangeInfo>& focusChangeInfo)
64 {
65     WLOGI("TestFocusChangedListener Unfocused ID: %{public}u", focusChangeInfo->windowId_);
66     unfocusedWindow_ = focusChangeInfo->windowId_;
67 }
68 
SetUpTestCase()69 void WindowFocusTest::SetUpTestCase()
70 {
71     auto display = DisplayManager::GetInstance().GetDisplayById(0);
72     ASSERT_TRUE((display != nullptr));
73     WLOGI("GetDefaultDisplay: id %{public}" PRIu64", w %{public}d, h %{public}d, fps %{public}u",
74         display->GetId(), display->GetWidth(), display->GetHeight(), display->GetRefreshRate());
75     Rect displayRect = {0, 0, display->GetWidth(), display->GetHeight()};
76     Utils::InitByDisplayRect(displayRect);
77 }
78 
TearDownTestCase()79 void WindowFocusTest::TearDownTestCase()
80 {
81 }
82 
SetUp()83 void WindowFocusTest::SetUp()
84 {
85     fullScreenAppInfo_ = {
86             .name = "FullWindow",
87             .rect = Utils::customAppRect_,
88             .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
89             .mode = WindowMode::WINDOW_MODE_FULLSCREEN,
90             .needAvoid = false,
91             .parentLimit = false,
92             .showWhenLocked = true,
93             .parentId = INVALID_WINDOW_ID,
94     };
95     floatAppInfo_ = {
96             .name = "ParentWindow",
97             .rect = Utils::customAppRect_,
98             .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
99             .mode = WindowMode::WINDOW_MODE_FLOATING,
100             .needAvoid = false,
101             .parentLimit = false,
102             .showWhenLocked = true,
103             .parentId = INVALID_WINDOW_ID,
104     };
105     subAppInfo_ = {
106             .name = "SubWindow",
107             .rect = Utils::customAppRect_,
108             .type = WindowType::WINDOW_TYPE_APP_SUB_WINDOW,
109             .mode = WindowMode::WINDOW_MODE_FLOATING,
110             .needAvoid = false,
111             .parentLimit = false,
112             .showWhenLocked = false,
113             .parentId = INVALID_WINDOW_ID,
114     };
115     WindowManager::GetInstance().RegisterFocusChangedListener(testFocusChangedListener_);
116 }
117 
TearDown()118 void WindowFocusTest::TearDown()
119 {
120     WindowManager::GetInstance().UnregisterFocusChangedListener(testFocusChangedListener_);
121 }
122 
123 namespace {
124 /**
125  * @tc.name: FocusChangedTest01
126  * @tc.desc: add main window and sub window and show it to test focus
127  * @tc.type: FUNC
128  */
129 HWTEST_F(WindowFocusTest, FocusChangedTest01, Function | MediumTest | Level3)
130 {
131     fullScreenAppInfo_.name = "FocusChangedTest01_1";
132     fullScreenAppInfo_.focusable_ = false;
133     const sptr<Window>& window1 = Utils::CreateTestWindow(fullScreenAppInfo_);
134     if (window1 == nullptr) {
135         return;
136     }
137     ASSERT_NE(nullptr, window1);
138 
139     floatAppInfo_.name = "FocusChangedTest01_2";
140     floatAppInfo_.rect = { 10, 200, 300, 400 };
141     const sptr<Window>& window2 = Utils::CreateTestWindow(floatAppInfo_);
142     if (window2 == nullptr) {
143         return;
144     }
145     ASSERT_NE(nullptr, window2);
146 
147     floatAppInfo_.name = "FocusChangedTest01_3";
148     floatAppInfo_.rect = { 250, 150, 300, 500 };
149     const sptr<Window>& window3 = Utils::CreateTestWindow(floatAppInfo_);
150     if (window3 == nullptr) {
151         return;
152     }
153     ASSERT_NE(nullptr, window3);
154 
155     subAppInfo_.name = "FocusChangedTest01_4";
156     subAppInfo_.rect = { 400, 200, 100, 100 };
157     subAppInfo_.parentId = window3->GetWindowId();
158     const sptr<Window>& subWindow = Utils::CreateTestWindow(subAppInfo_);
159     ASSERT_NE(nullptr, subWindow);
160     ASSERT_EQ(WMError::WM_OK, window3->Show());
161     // Await 100ms and get callback result in listener.
162     usleep(WAIT_ASYNC_US);
163     ASSERT_EQ(window3->GetWindowId(), testFocusChangedListener_->focusedWindow_);
164 
165     ASSERT_EQ(WMError::WM_OK, window1->Show());
166     // Await 100ms and get callback result in listener.
167     usleep(WAIT_ASYNC_US);
168     ASSERT_EQ(window3->GetWindowId(), testFocusChangedListener_->focusedWindow_);
169 
170     ASSERT_EQ(WMError::WM_OK, window2->Show());
171     // Await 100ms and get callback result in listener.
172     usleep(WAIT_ASYNC_US);
173     ASSERT_EQ(window3->GetWindowId(), testFocusChangedListener_->unfocusedWindow_);
174     ASSERT_EQ(window2->GetWindowId(), testFocusChangedListener_->focusedWindow_);
175 
176     ASSERT_EQ(WMError::WM_OK, subWindow->Show());
177     // Await 100ms and get callback result in listener.
178     usleep(WAIT_ASYNC_US);
179     ASSERT_EQ(window2->GetWindowId(), testFocusChangedListener_->unfocusedWindow_);
180     ASSERT_EQ(subWindow->GetWindowId(), testFocusChangedListener_->focusedWindow_);
181 
182     window1->Destroy();
183     window2->Destroy();
184     window3->Destroy();
185     subWindow->Destroy();
186 }
187 
188 /**
189  * @tc.name: FocusChangedTest02
190  * @tc.desc: hide focused window to test focus
191  * @tc.type: FUNC
192  */
193 HWTEST_F(WindowFocusTest, FocusChangedTest02, Function | MediumTest | Level3)
194 {
195     floatAppInfo_.name = "FocusChangedTest02_1";
196     floatAppInfo_.rect = { 10, 200, 300, 400 };
197     const sptr<Window>& mainWindow = Utils::CreateTestWindow(floatAppInfo_);
198     if (mainWindow == nullptr) {
199         return;
200     }
201     ASSERT_NE(nullptr, mainWindow);
202     ASSERT_EQ(WMError::WM_OK, mainWindow->Show());
203 
204     subAppInfo_.name = "FocusChangedTest02_2";
205     subAppInfo_.rect = { 400, 200, 100, 100 };
206     subAppInfo_.parentId = mainWindow->GetWindowId();
207     const sptr<Window>& subWindow = Utils::CreateTestWindow(subAppInfo_);
208     if (subWindow == nullptr) {
209         return;
210     }
211     ASSERT_NE(nullptr, subWindow);
212     ASSERT_EQ(WMError::WM_OK, subWindow->Show());
213     usleep(WAIT_ASYNC_US);
214     ASSERT_EQ(subWindow->GetWindowId(), testFocusChangedListener_->focusedWindow_);
215 
216     ASSERT_EQ(WMError::WM_OK, subWindow->Hide());
217     // Await 100ms and get callback result in listener.
218     usleep(WAIT_ASYNC_US);
219     ASSERT_EQ(mainWindow->GetWindowId(), testFocusChangedListener_->focusedWindow_);
220 
221     mainWindow->Destroy();
222     subWindow->Destroy();
223 }
224 
225 /**
226  * @tc.name: FocusChangedTest03
227  * @tc.desc: hide focused window to test focus
228  * @tc.type: FUNC
229  */
230 HWTEST_F(WindowFocusTest, FocusChangedTest03, Function | MediumTest | Level3)
231 {
232     floatAppInfo_.name = "FocusChangedTest03_1";
233     floatAppInfo_.rect = { 10, 200, 300, 400 };
234     const sptr<Window>& mainWindow1 = Utils::CreateTestWindow(floatAppInfo_);
235     if (mainWindow1 == nullptr) {
236         return;
237     }
238     ASSERT_NE(nullptr, mainWindow1);
239     ASSERT_EQ(WMError::WM_OK, mainWindow1->Show());
240 
241     subAppInfo_.name = "FocusChangedTest03_2";
242     subAppInfo_.rect = { 400, 200, 100, 100 };
243     subAppInfo_.parentId = mainWindow1->GetWindowId();
244     const sptr<Window>& aboveSubWindow = Utils::CreateTestWindow(subAppInfo_);
245     ASSERT_NE(nullptr, aboveSubWindow);
246     ASSERT_EQ(WMError::WM_OK, aboveSubWindow->Show());
247 
248     floatAppInfo_.name = "FocusChangedTest03_3";
249     floatAppInfo_.rect = { 200, 200, 100, 100 };
250     const sptr<Window>& mainWindow2 = Utils::CreateTestWindow(floatAppInfo_);
251     if (mainWindow2 == nullptr) {
252         return;
253     }
254     ASSERT_NE(nullptr, mainWindow2);
255     ASSERT_EQ(WMError::WM_OK, mainWindow2->Show());
256     usleep(WAIT_ASYNC_US);
257     ASSERT_EQ(mainWindow2->GetWindowId(), testFocusChangedListener_->focusedWindow_);
258 
259     ASSERT_EQ(WMError::WM_OK, mainWindow2->Hide());
260     // Await 100ms and get callback result in listener.
261     usleep(WAIT_ASYNC_US);
262     ASSERT_EQ(mainWindow2->GetWindowId(), testFocusChangedListener_->unfocusedWindow_);
263     ASSERT_EQ(aboveSubWindow->GetWindowId(), testFocusChangedListener_->focusedWindow_);
264 
265     mainWindow1->Destroy();
266     mainWindow2->Destroy();
267     aboveSubWindow->Destroy();
268 }
269 
270 /**
271  * @tc.name: FocusChangedTest04
272  * @tc.desc: hide focused window to test focus
273  * @tc.type: FUNC
274  */
275 HWTEST_F(WindowFocusTest, FocusChangedTest04, Function | MediumTest | Level3)
276 {
277     floatAppInfo_.name = "FocusChangedTest04_1";
278     floatAppInfo_.rect = { 10, 200, 300, 400 };
279     const sptr<Window>& mainWindow1 = Utils::CreateTestWindow(floatAppInfo_);
280     if (mainWindow1 == nullptr) {
281         return;
282     }
283     ASSERT_NE(nullptr, mainWindow1);
284     ASSERT_EQ(WMError::WM_OK, mainWindow1->Show());
285 
286     subAppInfo_.name = "FocusChangedTest04_2";
287     subAppInfo_.rect = { 400, 200, 100, 100 };
288     subAppInfo_.parentId = mainWindow1->GetWindowId();
289     subAppInfo_.type = WindowType::WINDOW_TYPE_MEDIA;
290     const sptr<Window>& belowSubWindow = Utils::CreateTestWindow(subAppInfo_);
291     if (belowSubWindow == nullptr) {
292         return;
293     }
294     ASSERT_NE(nullptr, belowSubWindow);
295     ASSERT_EQ(WMError::WM_OK, belowSubWindow->Show());
296 
297     floatAppInfo_.name = "FocusChangedTest04_3";
298     floatAppInfo_.rect = { 200, 200, 100, 100 };
299     const sptr<Window>& mainWindow2 = Utils::CreateTestWindow(floatAppInfo_);
300     if (mainWindow2 == nullptr) {
301         return;
302     }
303     ASSERT_NE(nullptr, mainWindow2);
304     ASSERT_EQ(WMError::WM_OK, mainWindow2->Show());
305     usleep(WAIT_ASYNC_US);
306     ASSERT_EQ(mainWindow2->GetWindowId(), testFocusChangedListener_->focusedWindow_);
307 
308     ASSERT_EQ(WMError::WM_OK, mainWindow2->Hide());
309     // Await 100ms and get callback result in listener.
310     usleep(WAIT_ASYNC_US);
311     ASSERT_EQ(mainWindow2->GetWindowId(), testFocusChangedListener_->unfocusedWindow_);
312     ASSERT_EQ(mainWindow1->GetWindowId(), testFocusChangedListener_->focusedWindow_);
313 
314     mainWindow1->Destroy();
315     mainWindow2->Destroy();
316     belowSubWindow->Destroy();
317 }
318 
319 /**
320  * @tc.name: FocusChangedTest05
321  * @tc.desc: hide focused window to test focus
322  * @tc.type: FUNC
323  */
324 HWTEST_F(WindowFocusTest, FocusChangedTest05, Function | MediumTest | Level3)
325 {
326     floatAppInfo_.name = "FocusChangedTest05_1";
327     floatAppInfo_.rect = { 10, 200, 300, 400 };
328     const sptr<Window>& mainWindow1 = Utils::CreateTestWindow(floatAppInfo_);
329     if (mainWindow1 == nullptr) {
330         return;
331     }
332     ASSERT_NE(nullptr, mainWindow1);
333     ASSERT_EQ(WMError::WM_OK, mainWindow1->Show());
334 
335     floatAppInfo_.name = "FocusChangedTest05_2";
336     floatAppInfo_.rect = { 200, 200, 100, 100 };
337     const sptr<Window>& mainWindow2 = Utils::CreateTestWindow(floatAppInfo_);
338     if (mainWindow2 == nullptr) {
339         return;
340     }
341     ASSERT_NE(nullptr, mainWindow2);
342     ASSERT_EQ(WMError::WM_OK, mainWindow2->Show());
343 
344     subAppInfo_.name = "FocusChangedTest05_3";
345     subAppInfo_.rect = { 400, 200, 100, 100 };
346     subAppInfo_.parentId = mainWindow2->GetWindowId();
347     subAppInfo_.type = WindowType::WINDOW_TYPE_MEDIA;
348     const sptr<Window>& belowSubWindow = Utils::CreateTestWindow(subAppInfo_);
349     if (belowSubWindow == nullptr) {
350         return;
351     }
352     ASSERT_NE(nullptr, belowSubWindow);
353     ASSERT_EQ(WMError::WM_OK, belowSubWindow->Show());
354     usleep(WAIT_ASYNC_US);
355     ASSERT_EQ(belowSubWindow->GetWindowId(), testFocusChangedListener_->focusedWindow_);
356 
357     ASSERT_EQ(WMError::WM_OK, belowSubWindow->Hide());
358     // Await 100ms and get callback result in listener.
359     usleep(WAIT_ASYNC_US);
360     ASSERT_EQ(belowSubWindow->GetWindowId(), testFocusChangedListener_->unfocusedWindow_);
361     ASSERT_EQ(mainWindow1->GetWindowId(), testFocusChangedListener_->focusedWindow_);
362 
363     ASSERT_EQ(WMError::WM_OK, belowSubWindow->Show());
364     usleep(WAIT_ASYNC_US);
365     ASSERT_EQ(mainWindow1->GetWindowId(), testFocusChangedListener_->unfocusedWindow_);
366     ASSERT_EQ(belowSubWindow->GetWindowId(), testFocusChangedListener_->focusedWindow_);
367     ASSERT_EQ(WMError::WM_OK, mainWindow2->Hide());
368     usleep(WAIT_ASYNC_US);
369     ASSERT_EQ(belowSubWindow->GetWindowId(), testFocusChangedListener_->unfocusedWindow_);
370     ASSERT_EQ(mainWindow1->GetWindowId(), testFocusChangedListener_->focusedWindow_);
371 
372     mainWindow1->Destroy();
373     mainWindow2->Destroy();
374     belowSubWindow->Destroy();
375 }
376 
377 /**
378 * @tc.name: FocusChangedTest06
379 * @tc.desc: hide unfocused window to test focus
380 * @tc.type: FUNC
381 */
382 HWTEST_F(WindowFocusTest, FocusChangedTest06, Function | MediumTest | Level3)
383 {
384     floatAppInfo_.name = "FocusChangedTest06_1";
385     floatAppInfo_.rect = { 10, 200, 300, 400 };
386     const sptr<Window>& mainWindow = Utils::CreateTestWindow(floatAppInfo_);
387     if (mainWindow == nullptr) {
388         return;
389     }
390     ASSERT_NE(nullptr, mainWindow);
391     ASSERT_EQ(WMError::WM_OK, mainWindow->Show());
392 
393     subAppInfo_.name = "FocusChangedTest06_2";
394     subAppInfo_.rect = { 100, 200, 100, 100 };
395     subAppInfo_.parentId = mainWindow->GetWindowId();
396     subAppInfo_.type = WindowType::WINDOW_TYPE_MEDIA;
397     const sptr<Window>& belowSubWindow = Utils::CreateTestWindow(subAppInfo_);
398     if (belowSubWindow == nullptr) {
399         return;
400     }
401     ASSERT_NE(nullptr, belowSubWindow);
402     ASSERT_EQ(WMError::WM_OK, belowSubWindow->Show());
403 
404     subAppInfo_.name = "FocusChangedTest06_3";
405     subAppInfo_.rect = { 400, 200, 100, 100 };
406     subAppInfo_.parentId = mainWindow->GetWindowId();
407     subAppInfo_.type = WindowType::WINDOW_TYPE_APP_SUB_WINDOW;
408     const sptr<Window>& aboveSubWindow = Utils::CreateTestWindow(subAppInfo_);
409     ASSERT_NE(nullptr, aboveSubWindow);
410     ASSERT_EQ(WMError::WM_OK, aboveSubWindow->Show());
411     usleep(WAIT_ASYNC_US);
412     ASSERT_EQ(aboveSubWindow->GetWindowId(), testFocusChangedListener_->focusedWindow_);
413 
414     ASSERT_EQ(WMError::WM_OK, belowSubWindow->Hide());
415     // Await 100ms and get callback result in listener.
416     usleep(WAIT_ASYNC_US);
417     ASSERT_EQ(aboveSubWindow->GetWindowId(), testFocusChangedListener_->focusedWindow_);
418 }
419 
420 /**
421 * @tc.name: FocusChangedTest07
422 * @tc.desc: destroy focused window to test focus
423 * @tc.type: FUNC
424 */
425 HWTEST_F(WindowFocusTest, FocusChangedTest07, Function | MediumTest | Level3)
426 {
427     floatAppInfo_.name = "FocusChangedTest07_1";
428     floatAppInfo_.rect = { 10, 200, 300, 400 };
429     const sptr<Window>& mainWindow1 = Utils::CreateTestWindow(floatAppInfo_);
430     if (mainWindow1 == nullptr) {
431         return;
432     }
433     ASSERT_NE(nullptr, mainWindow1);
434     ASSERT_EQ(WMError::WM_OK, mainWindow1->Show());
435 
436     floatAppInfo_.name = "FocusChangedTest07_2";
437     floatAppInfo_.rect = { 250, 150, 300, 500 };
438     const sptr<Window>& mainWindow2 = Utils::CreateTestWindow(floatAppInfo_);
439     if (mainWindow2 == nullptr) {
440         return;
441     }
442     ASSERT_NE(nullptr, mainWindow2);
443     ASSERT_EQ(WMError::WM_OK, mainWindow2->Show());
444 
445     floatAppInfo_.name = "FocusChangedTest07_3";
446     floatAppInfo_.rect = { 300, 400, 10, 400 };
447     const sptr<Window>& mainWindow3 = Utils::CreateTestWindow(floatAppInfo_);
448     if (mainWindow3 == nullptr) {
449         return;
450     }
451     ASSERT_NE(nullptr, mainWindow3);
452     ASSERT_EQ(WMError::WM_OK, mainWindow3->Show());
453 
454     subAppInfo_.name = "FocusChangedTest07_4";
455     subAppInfo_.rect = { 20, 100, 100, 100 };
456     subAppInfo_.parentId = mainWindow1->GetWindowId();
457     subAppInfo_.type = WindowType::WINDOW_TYPE_MEDIA;
458     const sptr<Window>& belowSubWindow1 = Utils::CreateTestWindow(subAppInfo_);
459     if (belowSubWindow1 == nullptr) {
460         return;
461     }
462     ASSERT_NE(nullptr, belowSubWindow1);
463 
464     subAppInfo_.name = "FocusChangedTest07_5";
465     subAppInfo_.rect = { 400, 200, 100, 100 };
466     subAppInfo_.parentId = mainWindow2->GetWindowId();
467     subAppInfo_.type = WindowType::WINDOW_TYPE_APP_SUB_WINDOW;
468     const sptr<Window>& aboveSubWindow = Utils::CreateTestWindow(subAppInfo_);
469     if (aboveSubWindow == nullptr) {
470         return;
471     }
472     ASSERT_NE(nullptr, aboveSubWindow);
473 
474     subAppInfo_.name = "FocusChangedTest07_6";
475     subAppInfo_.rect = { 310, 410, 100, 100 };
476     subAppInfo_.parentId = mainWindow3->GetWindowId();
477     subAppInfo_.type = WindowType::WINDOW_TYPE_MEDIA;
478     const sptr<Window>& belowSubWindow2 = Utils::CreateTestWindow(subAppInfo_);
479     if (belowSubWindow2 == nullptr) {
480         return;
481     }
482     ASSERT_NE(nullptr, belowSubWindow2);
483 
484     ASSERT_EQ(WMError::WM_OK, aboveSubWindow->Show());
485     ASSERT_EQ(WMError::WM_OK, belowSubWindow2->Show());
486     ASSERT_EQ(WMError::WM_OK, belowSubWindow1->Show());
487     usleep(WAIT_ASYNC_US);
488     ASSERT_EQ(belowSubWindow1->GetWindowId(), testFocusChangedListener_->focusedWindow_);
489 
490     ASSERT_EQ(WMError::WM_OK, mainWindow1->Destroy());
491     // Await 100ms and get callback result in listener.
492     usleep(WAIT_ASYNC_US);
493     ASSERT_EQ(belowSubWindow1->GetWindowId(), testFocusChangedListener_->unfocusedWindow_);
494     ASSERT_EQ(mainWindow3->GetWindowId(), testFocusChangedListener_->focusedWindow_);
495 
496     ASSERT_EQ(WMError::WM_OK, mainWindow3->Destroy());
497     usleep(WAIT_ASYNC_US);
498     ASSERT_EQ(mainWindow3->GetWindowId(), testFocusChangedListener_->unfocusedWindow_);
499     ASSERT_EQ(aboveSubWindow->GetWindowId(), testFocusChangedListener_->focusedWindow_);
500 
501     ASSERT_EQ(WMError::WM_OK, aboveSubWindow->Destroy());
502     usleep(WAIT_ASYNC_US);
503     ASSERT_EQ(aboveSubWindow->GetWindowId(), testFocusChangedListener_->unfocusedWindow_);
504     ASSERT_EQ(mainWindow2->GetWindowId(), testFocusChangedListener_->focusedWindow_);
505 
506     mainWindow2->Destroy();
507 }
508 
509 /**
510 * @tc.name: FocusChangedTest08
511 * @tc.desc: destroy unfocused window to test focus
512 * @tc.type: FUNC
513 */
514 HWTEST_F(WindowFocusTest, FocusChangedTest08, Function | MediumTest | Level3)
515 {
516     floatAppInfo_.name = "FocusChangedTest08_1";
517     floatAppInfo_.rect = { 10, 200, 300, 400 };
518     const sptr<Window>& mainWindow1 = Utils::CreateTestWindow(floatAppInfo_);
519     if (mainWindow1 == nullptr) {
520         return;
521     }
522     ASSERT_NE(nullptr, mainWindow1);
523     ASSERT_EQ(WMError::WM_OK, mainWindow1->Show());
524 
525     floatAppInfo_.name = "FocusChangedTest08_2";
526     floatAppInfo_.rect = { 250, 150, 300, 500 };
527     const sptr<Window>& mainWindow2 = Utils::CreateTestWindow(floatAppInfo_);
528     if (mainWindow2 == nullptr) {
529         return;
530     }
531     ASSERT_NE(nullptr, mainWindow2);
532     ASSERT_EQ(WMError::WM_OK, mainWindow2->Show());
533 
534     subAppInfo_.name = "FocusChangedTest08_3";
535     subAppInfo_.rect = { 20, 100, 100, 100 };
536     subAppInfo_.parentId = mainWindow1->GetWindowId();
537     subAppInfo_.type = WindowType::WINDOW_TYPE_MEDIA;
538     const sptr<Window>& belowSubWindow = Utils::CreateTestWindow(subAppInfo_);
539     if (belowSubWindow == nullptr) {
540         return;
541     }
542     ASSERT_NE(nullptr, belowSubWindow);
543     ASSERT_EQ(WMError::WM_OK, belowSubWindow->Show());
544     usleep(WAIT_ASYNC_US);
545     ASSERT_EQ(belowSubWindow->GetWindowId(), testFocusChangedListener_->focusedWindow_);
546 
547     ASSERT_EQ(WMError::WM_OK, mainWindow2->Destroy());
548     // Await 100ms and get callback result in listener.
549     usleep(WAIT_ASYNC_US);
550     ASSERT_EQ(belowSubWindow->GetWindowId(), testFocusChangedListener_->focusedWindow_);
551 
552     mainWindow1->Destroy();
553 }
554 
555 /**
556  * @tc.name: WindowShowWithoutFocusTest
557  * @tc.desc: add main window and sub window and show it to test focus
558  * @tc.type: FUNC
559  */
560 HWTEST_F(WindowFocusTest, WindowShowWithoutFocusTest, Function | MediumTest | Level3)
561 {
562     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
563         return;
564     }
565 
566     fullScreenAppInfo_.name = "WindowShowWithoutFocusTest_1";
567     const sptr<Window>& window1 = Utils::CreateTestWindow(fullScreenAppInfo_);
568     ASSERT_NE(nullptr, window1);
569 
570     floatAppInfo_.name = "WindowShowWithoutFocusTest_2";
571     const sptr<Window>& window2 = Utils::CreateTestWindow(floatAppInfo_);
572     ASSERT_NE(nullptr, window2);
573 
574     subAppInfo_.name = "WindowShowWithoutFocusTest_3";
575     subAppInfo_.parentId = window2->GetWindowId();
576     const sptr<Window>& subWindow = Utils::CreateTestWindow(subAppInfo_);
577     ASSERT_NE(nullptr, subWindow);
578 
579     ASSERT_EQ(WMError::WM_OK, window1->Show());
580     // Await 100ms and get callback result in listener.
581     usleep(WAIT_ASYNC_US);
582     ASSERT_EQ(window1->GetWindowId(), testFocusChangedListener_->focusedWindow_);
583 
584     ASSERT_EQ(WMError::WM_OK, window2->Show(0, false, false));
585     // Await 100ms and get callback result in listener.
586     usleep(WAIT_ASYNC_US);
587     ASSERT_EQ(window2->GetWindowId(), testFocusChangedListener_->focusedWindow_);
588 
589     ASSERT_EQ(WMError::WM_OK, subWindow->Show(0, false, false));
590     // Await 100ms and get callback result in listener.
591     usleep(WAIT_ASYNC_US);
592     ASSERT_EQ(subWindow->GetWindowId(), testFocusChangedListener_->focusedWindow_);
593 
594     window1->Destroy();
595     window2->Destroy();
596     subWindow->Destroy();
597 }
598 }
599 } // namespace Rosen
600 } // namespace OHOS
601