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 <algorithm>
18 
19 #include "display_manager.h"
20 #include "window_pair.h"
21 #include "minimize_app.h"
22 #include "common_test_utils.h"
23 #include "mock_IWindow.h"
24 using namespace testing;
25 using namespace testing::ext;
26 
27 namespace OHOS {
28 namespace Rosen {
29 class WindowPairTest : public testing::Test {
30 public:
31     static void SetUpTestCase();
32     static void TearDownTestCase();
33     void SetUp() override;
34     void TearDown() override;
35 };
36 
SetUpTestCase()37 void WindowPairTest::SetUpTestCase()
38 {
39     auto display = DisplayManager::GetInstance().GetDefaultDisplay();
40     ASSERT_TRUE((display != nullptr));
41     sptr<DisplayInfo> displayInfo = display->GetDisplayInfo();
42     ASSERT_TRUE((displayInfo != nullptr));
43 }
44 
TearDownTestCase()45 void WindowPairTest::TearDownTestCase()
46 {
47 }
48 
SetUp()49 void WindowPairTest::SetUp()
50 {
51 }
52 
TearDown()53 void WindowPairTest::TearDown()
54 {
55 }
56 
57 namespace {
58 /**
59  * @tc.name: NotifyShowRecent
60  * @tc.desc: Send split screen event to notify create recent view.
61  * @tc.type: FUNC
62  */
63 HWTEST_F(WindowPairTest, NotifyShowRecent01, Function | SmallTest | Level2)
64 {
65     sptr<WindowPair> windowPair = new WindowPair(0);
66     windowPair->primary_ = nullptr;
67     windowPair->secondary_ = nullptr;
68     windowPair->NotifyShowRecent(nullptr);
69     ASSERT_EQ(nullptr, windowPair->primary_);
70 
71     sptr<WindowProperty> property = new WindowProperty();
72     property->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
73     sptr<WindowNode> node0 = new WindowNode(property);
74     windowPair->primary_ = node0;
75     windowPair->NotifyShowRecent(node0);
76 
77     if (windowPair->secondary_ != nullptr) {
78         ASSERT_EQ(WindowType::WINDOW_TYPE_LAUNCHER_RECENT, windowPair->secondary_->GetWindowType());
79     }
80 }
81 
82 /**
83  * @tc.name: NotifyCreateOrDestroyDivider
84  * @tc.desc: Send split screen event to notify create or destroy divider window.
85  * @tc.type: FUNC
86  */
87 HWTEST_F(WindowPairTest, NotifyCreateOrDestroyDivider01, Function | SmallTest | Level2)
88 {
89     sptr<WindowPair> windowPair = new WindowPair(0);
90     windowPair->primary_ = nullptr;
91     windowPair->NotifyCreateOrDestroyDivider(nullptr, true);
92     ASSERT_EQ(nullptr, windowPair->primary_);
93 
94     sptr<WindowProperty> property = new WindowProperty();
95     property->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
96     sptr<WindowNode> node0 = new WindowNode(property);
97     windowPair->primary_ = node0;
98     windowPair->NotifyCreateOrDestroyDivider(node0, true);
99     ASSERT_EQ(nullptr, windowPair->divider_);
100 }
101 
102 /**
103  * @tc.name: IsPaired
104  * @tc.desc: Get whether the window pair is paired
105  * @tc.type: FUNC
106  */
107 HWTEST_F(WindowPairTest, IsPaired01, Function | SmallTest | Level2)
108 {
109     sptr<WindowPair> windowPair = new WindowPair(0);
110     windowPair->primary_ = nullptr;
111     ASSERT_EQ(false, windowPair->IsPaired());
112     windowPair->primary_ = new WindowNode();
113     windowPair->secondary_ = nullptr;
114     ASSERT_EQ(false, windowPair->IsPaired());
115 }
116 
117 /**
118  * @tc.name: IsPaired
119  * @tc.desc: Get whether the window pair is paired
120  * @tc.type: FUNC
121  */
122 HWTEST_F(WindowPairTest, IsPaired02, Function | SmallTest | Level2)
123 {
124     sptr<WindowPair> windowPair = new WindowPair(0);
125     sptr<WindowProperty> property1 = new WindowProperty();
126     property1->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
127     sptr<WindowProperty> property2 = new WindowProperty();
128     property2->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
129 
130     sptr<WindowNode> node1 = new WindowNode(property1);
131     windowPair->primary_ = node1;
132     sptr<WindowNode> node2 = new WindowNode(property2);
133     windowPair->secondary_ = node2;
134     windowPair->divider_ = node1;
135     ASSERT_EQ(true, windowPair->IsPaired());
136 }
137 
138 /**
139  * @tc.name: IsPaired
140  * @tc.desc: Get whether the window pair is paired
141  * @tc.type: FUNC
142  */
143 HWTEST_F(WindowPairTest, IsPaired03, Function | SmallTest | Level2)
144 {
145     sptr<WindowPair> windowPair = new WindowPair(0);
146     sptr<WindowProperty> property1 = new WindowProperty();
147     property1->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
148     sptr<WindowProperty> property2 = new WindowProperty();
149     property2->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
150 
151     sptr<WindowNode> node1 = new WindowNode(property1);
152     windowPair->primary_ = node1;
153     sptr<WindowNode> node2 = new WindowNode(property2);
154     windowPair->secondary_ = node2;
155     windowPair->divider_ = nullptr;
156     ASSERT_EQ(false, windowPair->IsPaired());
157 }
158 
159 /**
160  * @tc.name: Find
161  * @tc.desc: Find window node from window pair
162  * @tc.type: FUNC
163  */
164 HWTEST_F(WindowPairTest, Find01, Function | SmallTest | Level2)
165 {
166     sptr<WindowPair> windowPair = new WindowPair(0);
167     sptr<WindowNode> node1 = nullptr;
168     ASSERT_EQ(nullptr, windowPair->Find(node1));
169 }
170 
171 /**
172  * @tc.name: Find
173  * @tc.desc: Find window node from window pair
174  * @tc.type: FUNC
175  */
176 HWTEST_F(WindowPairTest, Find02, Function | SmallTest | Level2)
177 {
178     sptr<WindowPair> windowPair = new WindowPair(0);
179     sptr<WindowProperty> property1 = new WindowProperty();
180     property1->SetWindowId(1);
181     sptr<WindowNode> node1 = new WindowNode(property1);
182     windowPair->primary_ = node1;
183     ASSERT_EQ(node1, windowPair->Find(node1));
184 }
185 
186 /**
187  * @tc.name: Find
188  * @tc.desc: Find window node from window pair
189  * @tc.type: FUNC
190  */
191 HWTEST_F(WindowPairTest, Find03, Function | SmallTest | Level2)
192 {
193     sptr<WindowPair> windowPair = new WindowPair(0);
194     sptr<WindowProperty> property1 = new WindowProperty();
195     property1->SetWindowId(1);
196     sptr<WindowNode> node1 = new WindowNode(property1);
197     windowPair->primary_ = nullptr;
198     windowPair->secondary_ = node1;
199     ASSERT_EQ(node1, windowPair->Find(node1));
200 }
201 
202 /**
203  * @tc.name: Find
204  * @tc.desc: Find window node from window pair
205  * @tc.type: FUNC
206  */
207 HWTEST_F(WindowPairTest, Find04, Function | SmallTest | Level2)
208 {
209     sptr<WindowPair> windowPair = new WindowPair(0);
210     sptr<WindowProperty> property1 = new WindowProperty();
211     property1->SetWindowId(1);
212     sptr<WindowNode> node1 = new WindowNode(property1);
213     windowPair->primary_ = nullptr;
214     windowPair->secondary_ = nullptr;
215     windowPair->divider_ = node1;
216     ASSERT_EQ(node1, windowPair->Find(node1));
217 }
218 
219 /**
220  * @tc.name: GetSplitRatio
221  * @tc.desc: Get split ratio
222  * @tc.type: FUNC
223  */
224 HWTEST_F(WindowPairTest, GetSplitRatio01, Function | SmallTest | Level2)
225 {
226     sptr<WindowPair> windowPair = new WindowPair(0);
227     windowPair->ratio_ = 0;
228     ASSERT_EQ(0, windowPair->GetSplitRatio());
229     windowPair->ratio_ = 5;
230     ASSERT_EQ(5, windowPair->GetSplitRatio());
231 }
232 
233 /**
234  * @tc.name: IsForbidDockSliceMove
235  * @tc.desc: Get whether dock slice is forbidden to move
236  * @tc.type: FUNC
237  */
238 HWTEST_F(WindowPairTest, IsForbidDockSliceMove01, Function | SmallTest | Level2)
239 {
240     sptr<WindowPair> windowPair = new WindowPair(0);
241     windowPair->status_ = WindowPairStatus::PAIRED_DONE;
242     ASSERT_EQ(true, windowPair->IsForbidDockSliceMove());
243     windowPair->status_ = WindowPairStatus::EMPTY;
244     ASSERT_EQ(false, windowPair->IsForbidDockSliceMove());
245 }
246 
247 /**
248  * @tc.name: IsForbidDockSliceMove
249  * @tc.desc: Get whether dock slice is forbidden to move
250  * @tc.type: FUNC
251  */
252 HWTEST_F(WindowPairTest, IsForbidDockSliceMove02, Function | SmallTest | Level2)
253 {
254     sptr<WindowPair> windowPair = new WindowPair(0);
255     windowPair->status_ = WindowPairStatus::PAIRED_DONE;
256     sptr<WindowProperty> property1 = new WindowProperty();
257     property1->SetWindowFlags(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID));
258     windowPair->primary_ = new WindowNode(property1);
259     windowPair->secondary_ = new WindowNode(property1);
260     ASSERT_EQ(false, windowPair->IsForbidDockSliceMove());
261 }
262 
263 /**
264  * @tc.name: IsForbidDockSliceMove
265  * @tc.desc: Get whether dock slice is forbidden to move
266  * @tc.type: FUNC
267  */
268 HWTEST_F(WindowPairTest, IsForbidDockSliceMove03, Function | SmallTest | Level2)
269 {
270     sptr<WindowPair> windowPair = new WindowPair(0);
271     windowPair->status_ = WindowPairStatus::PAIRED_DONE;
272     sptr<WindowProperty> property1 = new WindowProperty();
273     property1->SetWindowFlags(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID));
274     windowPair->primary_ = nullptr;
275     windowPair->secondary_ = new WindowNode(property1);
276     ASSERT_EQ(true, windowPair->IsForbidDockSliceMove());
277 }
278 
279 /**
280  * @tc.name: IsForbidDockSliceMove
281  * @tc.desc: Get whether dock slice is forbidden to move
282  * @tc.type: FUNC
283  */
284 HWTEST_F(WindowPairTest, IsForbidDockSliceMove04, Function | SmallTest | Level2)
285 {
286     sptr<WindowPair> windowPair = new WindowPair(0);
287     windowPair->status_ = WindowPairStatus::PAIRED_DONE;
288     sptr<WindowProperty> property1 = new WindowProperty();
289     property1->SetWindowFlags(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_FORBID_SPLIT_MOVE));
290     windowPair->primary_ = new WindowNode(property1);
291     windowPair->secondary_ = new WindowNode(property1);
292     ASSERT_EQ(true, windowPair->IsForbidDockSliceMove());
293 }
294 
295 /**
296  * @tc.name: IsForbidDockSliceMove
297  * @tc.desc: Get whether dock slice is forbidden to move
298  * @tc.type: FUNC
299  */
300 HWTEST_F(WindowPairTest, IsForbidDockSliceMove05, Function | SmallTest | Level2)
301 {
302     sptr<WindowPair> windowPair = new WindowPair(0);
303     windowPair->status_ = WindowPairStatus::PAIRED_DONE;
304     sptr<WindowProperty> property1 = new WindowProperty();
305     property1->SetWindowFlags(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID));
306     windowPair->primary_ = new WindowNode(property1);
307     windowPair->secondary_ = nullptr;
308     ASSERT_EQ(true, windowPair->IsForbidDockSliceMove());
309 }
310 
311 /**
312  * @tc.name: IsForbidDockSliceMove
313  * @tc.desc: Get whether dock slice is forbidden to move
314  * @tc.type: FUNC
315  */
316 HWTEST_F(WindowPairTest, IsForbidDockSliceMove06, Function | SmallTest | Level2)
317 {
318     sptr<WindowPair> windowPair = new WindowPair(0);
319     windowPair->status_ = WindowPairStatus::PAIRED_DONE;
320     sptr<WindowProperty> property1 = new WindowProperty();
321     property1->SetWindowFlags(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID));
322     sptr<WindowProperty> property2 = new WindowProperty();
323     property2->SetWindowFlags(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_FORBID_SPLIT_MOVE));
324     windowPair->primary_ = new WindowNode(property1);
325     windowPair->secondary_ = new WindowNode(property2);
326     ASSERT_EQ(true, windowPair->IsForbidDockSliceMove());
327 }
328 
329 /**
330  * @tc.name: IsDockSliceInExitSplitModeArea
331  * @tc.desc: whether dock slice in exit split screen mode area
332  * @tc.type: FUNC
333  */
334 HWTEST_F(WindowPairTest, IsDockSliceInExitSplitModeArea01, Function | SmallTest | Level2)
335 {
336     sptr<WindowPair> windowPair = new WindowPair(0);
337     std::vector<int32_t> points {0, 0};
338     windowPair->primary_ = nullptr;
339     ASSERT_EQ(false, windowPair->IsDockSliceInExitSplitModeArea(points));
340 }
341 
342 /**
343  * @tc.name: IsDockSliceInExitSplitModeArea
344  * @tc.desc: whether dock slice in exit split screen mode area
345  * @tc.type: FUNC
346  */
347 HWTEST_F(WindowPairTest, IsDockSliceInExitSplitModeArea02, Function | SmallTest | Level2)
348 {
349     sptr<WindowPair> windowPair = new WindowPair(0);
350     std::vector<int32_t> points {2, 0};
351     sptr<WindowProperty> property1 = new WindowProperty();
352     property1->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
353     sptr<WindowProperty> property2 = new WindowProperty();
354     property2->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
355     sptr<WindowProperty> property3 = new WindowProperty();
356 
357     sptr<WindowNode> node1 = new WindowNode(property1);
358     windowPair->primary_ = node1;
359     sptr<WindowNode> node2 = new WindowNode(property2);
360     windowPair->secondary_ = node2;
361     Rect rect1 = {1, 1, 10, 20};
362     Rect rect2 = {1, 1, 20, 10};
363     property2->SetWindowRect(rect1);
364     property3->SetWindowRect(rect2);
365     windowPair->divider_ = new WindowNode(property2);
366 
367     ASSERT_EQ(true, windowPair->IsPaired());
368     ASSERT_EQ(true, windowPair->IsDockSliceInExitSplitModeArea(points));
369     windowPair->divider_ = new WindowNode(property3);
370     ASSERT_EQ(true, windowPair->IsDockSliceInExitSplitModeArea(points));
371 }
372 
373 /**
374  * @tc.name: IsDockSliceInExitSplitModeArea
375  * @tc.desc: whether dock slice in exit split screen mode area
376  * @tc.type: FUNC
377  */
378 HWTEST_F(WindowPairTest, IsDockSliceInExitSplitModeArea03, Function | SmallTest | Level2)
379 {
380     sptr<WindowPair> windowPair = new WindowPair(0);
381     std::vector<int32_t> points {0, 50};
382     sptr<WindowProperty> property1 = new WindowProperty();
383     property1->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
384     sptr<WindowProperty> property2 = new WindowProperty();
385     property2->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
386 
387     sptr<WindowNode> node1 = new WindowNode(property1);
388     windowPair->primary_ = node1;
389     sptr<WindowNode> node2 = new WindowNode(property2);
390     windowPair->secondary_ = node2;
391     Rect rect1 = {1, 1, 10, 20};
392     property2->SetWindowRect(rect1);
393     windowPair->divider_ = new WindowNode(property2);
394 
395     ASSERT_EQ(true, windowPair->IsPaired());
396     ASSERT_EQ(false, windowPair->IsDockSliceInExitSplitModeArea(points));
397 }
398 
399 /**
400  * @tc.name: IsSplitRelated
401  * @tc.desc: Gets whether the window is related to split window.
402  * @tc.type: FUNC
403  */
404 HWTEST_F(WindowPairTest, IsSplitRelated01, Function | SmallTest | Level2)
405 {
406     sptr<WindowPair> windowPair = new WindowPair(0);
407     sptr<WindowNode> node = nullptr;
408     ASSERT_EQ(false, windowPair->IsSplitRelated(node));
409 }
410 
411 /**
412  * @tc.name: IsSplitRelated
413  * @tc.desc: Gets whether the window is related to split window.
414  * @tc.type: FUNC
415  */
416 HWTEST_F(WindowPairTest, IsSplitRelated02, Function | SmallTest | Level2)
417 {
418     sptr<WindowPair> windowPair = new WindowPair(0);
419     sptr<WindowProperty> property1 = new WindowProperty();
420     property1->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
421     sptr<WindowNode> node1 = new WindowNode(property1);
422     ASSERT_EQ(true, windowPair->IsSplitRelated(node1));
423     property1->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
424     property1->SetWindowType(WindowType::WINDOW_TYPE_DOCK_SLICE);
425     sptr<WindowNode> node2 = new WindowNode(property1);
426     ASSERT_EQ(true, windowPair->IsSplitRelated(node2));
427     property1->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
428     property1->SetWindowType(WindowType::APP_WINDOW_BASE);
429     sptr<WindowNode> node3 = new WindowNode(property1);
430     ASSERT_EQ(false, windowPair->IsSplitRelated(node3));
431 }
432 
433 /**
434  * @tc.name: GetOrderedPair
435  * @tc.desc: Get all window node form pair in Z order.
436  * @tc.type: FUNC
437  */
438 HWTEST_F(WindowPairTest, GetOrderedPair01, Function | SmallTest | Level2)
439 {
440     sptr<WindowPair> windowPair = new WindowPair(0);
441     sptr<WindowNode> node1 = nullptr;
442     std::vector<sptr<WindowNode>> vec;
443     vec.clear();
444     ASSERT_EQ(vec, windowPair->GetOrderedPair(node1));
445 }
446 
447 /**
448  * @tc.name: GetOrderedPair
449  * @tc.desc: Get all window node form pair in Z order.
450  * @tc.type: FUNC
451  */
452 HWTEST_F(WindowPairTest, GetOrderedPair02, Function | SmallTest | Level2)
453 {
454     sptr<WindowPair> windowPair = new WindowPair(0);
455 
456     // create window property
457     sptr<WindowProperty> property0 = new WindowProperty();
458     property0->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
459     property0->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
460     property0->SetWindowId(1);
461     sptr<WindowProperty> property1 = new WindowProperty();
462     property1->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
463     property1->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
464     property1->SetWindowId(2);
465     sptr<WindowProperty> property2 = new WindowProperty();
466     property2->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
467     property2->SetWindowType(WindowType::WINDOW_TYPE_DOCK_SLICE);
468     property2->SetWindowId(3);
469 
470     // define primary_, secondary_, divider_
471     sptr<WindowNode> node1 = new WindowNode(property1);
472 
473     windowPair->primary_ = new WindowNode(property0);
474     windowPair->secondary_ = node1;
475     windowPair->divider_ = new WindowNode(property2);
476     ASSERT_EQ(3, windowPair->GetOrderedPair(node1).size());
477 }
478 
479 /**
480  * @tc.name: GetOrderedPair
481  * @tc.desc: Get all window node form pair in Z order.
482  * @tc.type: FUNC
483  */
484 HWTEST_F(WindowPairTest, GetOrderedPair03, Function | SmallTest | Level2)
485 {
486     sptr<WindowPair> windowPair = new WindowPair(0);
487 
488     // create window property
489     sptr<WindowProperty> property0 = new WindowProperty();
490     property0->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
491     property0->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
492     property0->SetWindowId(1);
493     sptr<WindowProperty> property1 = new WindowProperty();
494     property1->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
495     property1->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
496     property1->SetWindowId(2);
497     sptr<WindowProperty> property2 = new WindowProperty();
498     property2->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
499     property2->SetWindowType(WindowType::WINDOW_TYPE_DOCK_SLICE);
500     property2->SetWindowId(3);
501 
502     // define primary_, secondary_, divider_
503     sptr<WindowNode> node1 = new WindowNode(property0);
504     windowPair->primary_ = node1;
505     windowPair->secondary_ = new WindowNode(property1);
506     windowPair->divider_ = new WindowNode(property2);
507 
508     ASSERT_EQ(3, windowPair->GetOrderedPair(node1).size());
509 }
510 
511 /**
512  * @tc.name: GetOrderedPair
513  * @tc.desc: Get all window node form pair in Z order.
514  * @tc.type: FUNC
515  */
516 HWTEST_F(WindowPairTest, GetOrderedPair04, Function | SmallTest | Level2)
517 {
518     sptr<WindowPair> windowPair = new WindowPair(0);
519     // create window property
520     sptr<WindowProperty> property0 = new WindowProperty();
521     property0->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
522     property0->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
523     property0->SetWindowId(1);
524     sptr<WindowProperty> property1 = new WindowProperty();
525     property1->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
526     property1->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
527     property1->SetWindowId(2);
528     sptr<WindowProperty> property2 = new WindowProperty();
529     property2->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
530     property2->SetWindowType(WindowType::WINDOW_TYPE_DOCK_SLICE);
531     property2->SetWindowId(3);
532     // define primary_, secondary_, divider_
533     sptr<WindowNode> node1 = new WindowNode(property0);
534     windowPair->primary_ = node1;
535     windowPair->secondary_ = nullptr;
536     windowPair->divider_ = new WindowNode(property2);
537     ASSERT_EQ(2, windowPair->GetOrderedPair(node1).size());
538 }
539 
540 /**
541  * @tc.name: GetOrderedPair
542  * @tc.desc: Get all window node form pair in Z order.
543  * @tc.type: FUNC
544  */
545 HWTEST_F(WindowPairTest, GetOrderedPair05, Function | SmallTest | Level2)
546 {
547     sptr<WindowPair> windowPair = new WindowPair(0);
548     // create window property
549     sptr<WindowProperty> property0 = new WindowProperty();
550     property0->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
551     property0->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
552     property0->SetWindowId(1);
553     sptr<WindowProperty> property1 = new WindowProperty();
554     property1->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
555     property1->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
556     property1->SetWindowId(2);
557     sptr<WindowProperty> property2 = new WindowProperty();
558     property2->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
559     property2->SetWindowType(WindowType::WINDOW_TYPE_DOCK_SLICE);
560     property2->SetWindowId(3);
561     // define primary_, secondary_, divider_
562     sptr<WindowNode> node1 = new WindowNode(property1);
563     windowPair->primary_ = nullptr;
564     windowPair->secondary_ = node1;
565     windowPair->divider_ = new WindowNode(property2);
566     ASSERT_EQ(2, windowPair->GetOrderedPair(node1).size());
567 }
568 
569 /**
570  * @tc.name: GetOrderedPair
571  * @tc.desc: Get all window node form pair in Z order.
572  * @tc.type: FUNC
573  */
574 HWTEST_F(WindowPairTest, GetOrderedPair06, Function | SmallTest | Level2)
575 {
576     sptr<WindowPair> windowPair = new WindowPair(0);
577     // create window property
578     sptr<WindowProperty> property0 = new WindowProperty();
579     property0->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
580     property0->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
581     property0->SetWindowId(1);
582     sptr<WindowProperty> property1 = new WindowProperty();
583     property1->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
584     property1->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
585     property1->SetWindowId(2);
586     sptr<WindowProperty> property2 = new WindowProperty();
587     property2->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
588     property2->SetWindowType(WindowType::WINDOW_TYPE_DOCK_SLICE);
589     property2->SetWindowId(3);
590     // define primary_, secondary_, divider_
591     sptr<WindowNode> node1 = new WindowNode(property2);
592     windowPair->primary_ = nullptr;
593     windowPair->secondary_ = nullptr;
594     windowPair->divider_ = node1;
595     ASSERT_EQ(1, windowPair->GetOrderedPair(node1).size());
596 }
597 
598 /**
599  * @tc.name: GetOrderedPair
600  * @tc.desc: Get all window node form pair in Z order.
601  * @tc.type: FUNC
602  */
603 HWTEST_F(WindowPairTest, GetOrderedPair07, Function | SmallTest | Level2)
604 {
605     sptr<WindowPair> windowPair = new WindowPair(0);
606     // create window property
607     sptr<WindowProperty> property0 = new WindowProperty();
608     property0->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
609     property0->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
610     property0->SetWindowId(1);
611     sptr<WindowProperty> property1 = new WindowProperty();
612     property1->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
613     property1->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
614     property1->SetWindowId(2);
615     sptr<WindowProperty> property2 = new WindowProperty();
616     property2->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
617     property2->SetWindowType(WindowType::WINDOW_TYPE_DOCK_SLICE);
618     property2->SetWindowId(3);
619     // define primary_, secondary_, divider_
620     sptr<WindowNode> node1 = new WindowNode(property0);
621     windowPair->primary_ = node1;
622     windowPair->secondary_ = new WindowNode(property1);
623     windowPair->divider_ = nullptr;
624     ASSERT_EQ(2, windowPair->GetOrderedPair(node1).size());
625 }
626 
627 /**
628  * @tc.name: GetPairedWindows
629  * @tc.desc: Get all window node form pair.
630  * @tc.type: FUNC
631  */
632 HWTEST_F(WindowPairTest, GetPairedWindows01, Function | SmallTest | Level2)
633 {
634     sptr<WindowPair> windowPair = new WindowPair(0);
635     sptr<WindowProperty> property0 = new WindowProperty();
636     property0->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
637     sptr<WindowProperty> property1 = new WindowProperty();
638     property1->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
639 
640     // define primary_, secondary_
641     windowPair->primary_ = new WindowNode(property0);
642     windowPair->secondary_ = new WindowNode(property1);
643 
644     // define status_
645     windowPair->status_ = WindowPairStatus::EMPTY;
646 
647     ASSERT_EQ(0, windowPair->GetPairedWindows().size());
648     windowPair->status_ = WindowPairStatus::PAIRED_DONE;
649     ASSERT_EQ(2, windowPair->GetPairedWindows().size());
650     ASSERT_EQ(windowPair->secondary_, windowPair->GetPairedWindows().at(1));
651     ASSERT_EQ(windowPair->primary_, windowPair->GetPairedWindows().at(0));
652 }
653 
654 /**
655  * @tc.name: Clear
656  * @tc.desc: Clear window pair.
657  * @tc.type: FUNC
658  */
659 HWTEST_F(WindowPairTest, Clear01, Function | SmallTest | Level2)
660 {
661     sptr<WindowPair> windowPair = new WindowPair(0);
662     sptr<WindowProperty> property0 = new WindowProperty();
663     property0->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
664 
665     // define divider
666     windowPair->divider_ = new WindowNode(property0);
667     windowPair->Clear();
668     ASSERT_EQ(nullptr, windowPair->divider_);
669     ASSERT_EQ(WindowPairStatus::EMPTY, windowPair->status_);
670 }
671 
672 /**
673  * @tc.name: UpdateWindowPairStatus
674  * @tc.desc: Update pair status
675  * @tc.type: FUNC
676  */
677 HWTEST_F(WindowPairTest, UpdateWindowPairStatus01, Function | SmallTest | Level2)
678 {
679     sptr<WindowPair> windowPair = new WindowPair(0);
680     sptr<WindowProperty> property0 = new WindowProperty();
681 
682     // define primary_, secondary_, divider_
683     windowPair->primary_ = new WindowNode(property0);
684     windowPair->secondary_ = new WindowNode(property0);
685     windowPair->divider_ = new WindowNode(property0);
686 
687     // define status_
688     windowPair->status_ = WindowPairStatus::SINGLE_PRIMARY;
689 
690     windowPair->UpdateWindowPairStatus();
691     ASSERT_EQ(WindowPairStatus::PAIRED_DONE, windowPair->status_);
692 }
693 
694 /**
695  * @tc.name: UpdateWindowPairStatus
696  * @tc.desc: Update pair status
697  * @tc.type: FUNC
698  */
699 HWTEST_F(WindowPairTest, UpdateWindowPairStatus02, Function | SmallTest | Level2)
700 {
701     sptr<WindowPair> windowPair = new WindowPair(0);
702     sptr<WindowProperty> property0 = new WindowProperty();
703 
704     // define primary_, secondary_, divider_
705     windowPair->primary_ = new WindowNode(property0);
706     windowPair->secondary_ = new WindowNode(property0);
707     windowPair->divider_ = nullptr;
708 
709     // define status_
710     windowPair->status_ = WindowPairStatus::SINGLE_PRIMARY;
711 
712     windowPair->UpdateWindowPairStatus();
713     ASSERT_EQ(WindowPairStatus::PRIMARY_AND_SECONDARY, windowPair->status_);
714 }
715 
716 /**
717  * @tc.name: UpdateWindowPairStatus
718  * @tc.desc: Update pair status
719  * @tc.type: FUNC
720  */
721 HWTEST_F(WindowPairTest, UpdateWindowPairStatus03, Function | SmallTest | Level2)
722 {
723     sptr<WindowPair> windowPair = new WindowPair(0);
724     sptr<WindowProperty> property0 = new WindowProperty();
725 
726     // define primary_, secondary_, divider_
727     windowPair->primary_ = new WindowNode(property0);
728     windowPair->secondary_ = nullptr;
729     windowPair->divider_ = new WindowNode(property0);
730 
731     // define status_
732     windowPair->status_ = WindowPairStatus::PAIRED_DONE;
733 
734     windowPair->UpdateWindowPairStatus();
735     ASSERT_EQ(WindowPairStatus::EMPTY, windowPair->status_);
736     ASSERT_EQ(nullptr, windowPair->primary_);
737     ASSERT_EQ(nullptr, windowPair->secondary_);
738     ASSERT_EQ(nullptr, windowPair->divider_);
739 }
740 
741 /**
742  * @tc.name: UpdateWindowPairStatus
743  * @tc.desc: Update pair status
744  * @tc.type: FUNC
745  */
746 HWTEST_F(WindowPairTest, UpdateWindowPairStatus04, Function | SmallTest | Level2)
747 {
748     sptr<WindowPair> windowPair = new WindowPair(0);
749     sptr<WindowProperty> property0 = new WindowProperty();
750 
751     // define primary_, secondary_, divider_
752     windowPair->primary_ = nullptr;
753     windowPair->secondary_ = new WindowNode(property0);
754     windowPair->divider_ = new WindowNode(property0);
755 
756     // define status_
757     windowPair->status_ = WindowPairStatus::EMPTY;
758 
759     sptr<WindowNode> node1 = windowPair->secondary_;
760     sptr<WindowNode> node2 = windowPair->divider_;
761     windowPair->UpdateWindowPairStatus();
762     ASSERT_EQ(WindowPairStatus::SECONDARY_AND_DIVIDER, windowPair->status_);
763     ASSERT_EQ(nullptr, windowPair->primary_);
764     ASSERT_EQ(node1, windowPair->secondary_);
765     ASSERT_EQ(node2, windowPair->divider_);
766 }
767 
768 /**
769  * @tc.name: UpdateWindowPairStatus
770  * @tc.desc: Update pair status
771  * @tc.type: FUNC
772  */
773 HWTEST_F(WindowPairTest, UpdateWindowPairStatus05, Function | SmallTest | Level2)
774 {
775     sptr<WindowPair> windowPair = new WindowPair(0);
776     sptr<WindowProperty> property0 = new WindowProperty();
777 
778     // define primary_, secondary_, divider_
779     windowPair->primary_ = nullptr;
780     windowPair->secondary_ = nullptr;
781     windowPair->divider_ = new WindowNode(property0);
782 
783     // define status_
784     windowPair->status_ = WindowPairStatus::SINGLE_PRIMARY;
785 
786     sptr<WindowNode> node1 = windowPair->divider_;
787     windowPair->UpdateWindowPairStatus();
788     ASSERT_EQ(WindowPairStatus::SINGLE_SPLIT, windowPair->status_);
789     ASSERT_EQ(nullptr, windowPair->primary_);
790     ASSERT_EQ(nullptr, windowPair->secondary_);
791     ASSERT_EQ(node1, windowPair->divider_);
792 }
793 
794 /**
795  * @tc.name: SwitchPosition
796  * @tc.desc: Switch the position of two paired window.
797  * @tc.type: FUNC
798  */
799 HWTEST_F(WindowPairTest, SwitchPosition01, Function | SmallTest | Level2)
800 {
801     sptr<WindowPair> windowPair = new WindowPair(0);
802     sptr<WindowProperty> property0 = new WindowProperty();
803 
804     // define primary_, secondary_, divider_
805     windowPair->primary_ = nullptr;
806     windowPair->secondary_ = nullptr;
807     windowPair->divider_ = new WindowNode(property0);
808 
809     sptr<WindowNode> node1 = windowPair->divider_;
810     ASSERT_EQ(nullptr, windowPair->primary_);
811     ASSERT_EQ(nullptr, windowPair->secondary_);
812     ASSERT_EQ(node1, windowPair->divider_);
813 }
814 
815 /**
816  * @tc.name: SwitchPosition
817  * @tc.desc: Switch the position of two paired window.
818  * @tc.type: FUNC
819  */
820 HWTEST_F(WindowPairTest, SwitchPosition02, Function | SmallTest | Level2)
821 {
822     sptr<WindowPair> windowPair = new WindowPair(0);
823     sptr<WindowProperty> property0 = new WindowProperty();
824     property0->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
825     sptr<WindowProperty> property1 = new WindowProperty();
826     property1->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
827 
828     // define primary_, secondary_
829     windowPair->primary_ = new WindowNode(property0);
830     windowPair->secondary_ = new WindowNode(property1);
831 
832     windowPair->SwitchPosition();
833     ASSERT_EQ(WindowMode::WINDOW_MODE_SPLIT_PRIMARY, windowPair->primary_->GetWindowMode());
834     ASSERT_EQ(WindowMode::WINDOW_MODE_SPLIT_SECONDARY, windowPair->secondary_->GetWindowMode());
835 }
836 
837 /**
838  * @tc.name: SwitchPosition
839  * @tc.desc: Switch the position of two paired window.
840  * @tc.type: FUNC
841  */
842 HWTEST_F(WindowPairTest, SwitchPosition03, Function | SmallTest | Level2)
843 {
844     sptr<WindowPair> windowPair = new WindowPair(0);
845     sptr<WindowProperty> property0 = new WindowProperty();
846     property0->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
847     sptr<WindowProperty> property1 = new WindowProperty();
848     property1->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
849 
850     // define primary_, secondary_
851     windowPair->primary_ = new WindowNode(property0);
852     windowPair->secondary_ = new WindowNode(property1);
853 
854     windowPair->SwitchPosition();
855     ASSERT_EQ(WindowMode::WINDOW_MODE_SPLIT_PRIMARY, windowPair->primary_->GetWindowMode());
856     ASSERT_EQ(WindowMode::WINDOW_MODE_SPLIT_SECONDARY, windowPair->secondary_->GetWindowMode());
857 }
858 
859 /**
860  * @tc.name: HandlePairedNodesChange
861  * @tc.desc: Update paired window node
862  * @tc.type: FUNC
863  */
864 HWTEST_F(WindowPairTest, HandlePairedNodesChange01, Function | SmallTest | Level2)
865 {
866     sptr<WindowPair> windowPair = new WindowPair(0);
867     sptr<WindowProperty> property0 = new WindowProperty();
868     property0->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
869     sptr<WindowProperty> property1 = new WindowProperty();
870     property1->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
871 
872     // define primary_, secondary_
873     windowPair->primary_ = new WindowNode(property0);
874     windowPair->secondary_ = new WindowNode(property0);
875 
876     windowPair->HandlePairedNodesChange();
877     ASSERT_EQ(nullptr, windowPair->primary_);
878     ASSERT_EQ(nullptr, windowPair->secondary_);
879     ASSERT_EQ(WindowPairStatus::EMPTY, windowPair->status_);
880 }
881 
882 /**
883  * @tc.name: HandlePairedNodesChange
884  * @tc.desc: Update paired window node
885  * @tc.type: FUNC
886  */
887 HWTEST_F(WindowPairTest, HandlePairedNodesChange02, Function | SmallTest | Level2)
888 {
889     sptr<WindowPair> windowPair = new WindowPair(0);
890     sptr<WindowProperty> property0 = new WindowProperty();
891     property0->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
892     sptr<WindowProperty> property1 = new WindowProperty();
893     property1->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
894 
895     // define primary_, secondary_
896     windowPair->primary_ = new WindowNode(property0);
897     windowPair->secondary_ = new WindowNode(property1);
898 
899     sptr<WindowNode> tmp_node = windowPair->secondary_;
900     windowPair->HandlePairedNodesChange();
901     ASSERT_EQ(tmp_node, windowPair->primary_);
902     ASSERT_EQ(nullptr, windowPair->secondary_);
903     ASSERT_EQ(WindowPairStatus::SINGLE_PRIMARY, windowPair->status_);
904 }
905 
906 /**
907  * @tc.name: HandlePairedNodesChange
908  * @tc.desc: Update paired window node
909  * @tc.type: FUNC
910  */
911 HWTEST_F(WindowPairTest, HandlePairedNodesChange03, Function | SmallTest | Level2)
912 {
913     sptr<WindowPair> windowPair = new WindowPair(0);
914     sptr<WindowProperty> property0 = new WindowProperty();
915     property0->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
916 
917     // define primary_, secondary_
918     windowPair->primary_ = nullptr;
919     windowPair->secondary_ = new WindowNode(property0);
920 
921     windowPair->HandlePairedNodesChange();
922     ASSERT_EQ(nullptr, windowPair->primary_);
923     ASSERT_EQ(nullptr, windowPair->secondary_);
924     ASSERT_EQ(WindowPairStatus::EMPTY, windowPair->status_);
925 }
926 
927 /**
928  * @tc.name: HandlePairedNodesChange
929  * @tc.desc: Update paired window node
930  * @tc.type: FUNC
931  */
932 HWTEST_F(WindowPairTest, HandlePairedNodesChange04, Function | SmallTest | Level2)
933 {
934     sptr<WindowPair> windowPair = new WindowPair(0);
935     sptr<WindowProperty> property0 = new WindowProperty();
936     property0->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
937     sptr<WindowProperty> property1 = new WindowProperty();
938     property1->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
939     sptr<WindowProperty> property2 = new WindowProperty();
940     property2->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
941 
942     // define primary_, secondary_
943     windowPair->primary_ = new WindowNode(property2);
944     windowPair->secondary_ = new WindowNode(property0);
945 
946     sptr<WindowNode> tmp_node = windowPair->primary_;
947     windowPair->HandlePairedNodesChange();
948     ASSERT_EQ(nullptr, windowPair->primary_);
949     ASSERT_EQ(tmp_node, windowPair->secondary_);
950     ASSERT_EQ(WindowPairStatus::SINGLE_SECONDARY, windowPair->status_);
951 }
952 
953 /**
954  * @tc.name: HandlePairedNodesChange
955  * @tc.desc: Update paired window node
956  * @tc.type: FUNC
957  */
958 HWTEST_F(WindowPairTest, HandlePairedNodesChange05, Function | SmallTest | Level2)
959 {
960     sptr<WindowPair> windowPair = new WindowPair(0);
961     sptr<WindowProperty> property1 = new WindowProperty();
962     property1->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
963     sptr<WindowProperty> property2 = new WindowProperty();
964     property2->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
965 
966     // define primary_, secondary_
967     windowPair->primary_ = new WindowNode(property1);
968     windowPair->secondary_ = new WindowNode(property2);
969 
970     windowPair->HandlePairedNodesChange();
971     ASSERT_EQ(WindowMode::WINDOW_MODE_SPLIT_PRIMARY, windowPair->primary_->GetWindowMode());
972     ASSERT_EQ(WindowMode::WINDOW_MODE_SPLIT_SECONDARY, windowPair->secondary_->GetWindowMode());
973 }
974 
975 /**
976  * @tc.name: HandleRemoveWindow
977  * @tc.desc: Handle removed window
978  * @tc.type: FUNC
979  */
980 HWTEST_F(WindowPairTest, HandleRemoveWindow01, Function | SmallTest | Level2)
981 {
982     sptr<WindowPair> windowPair = new WindowPair(0);
983     sptr<WindowProperty> property1 = new WindowProperty();
984     property1->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
985     windowPair->primary_ = new WindowNode(property1);
986 
987     sptr<WindowNode> node = nullptr;
988     windowPair->HandleRemoveWindow(node);
989     ASSERT_EQ(WindowMode::WINDOW_MODE_SPLIT_PRIMARY, windowPair->primary_->GetWindowMode());
990 }
991 
992 /**
993  * @tc.name: HandleRemoveWindow
994  * @tc.desc: Handle removed window
995  * @tc.type: FUNC
996  */
997 HWTEST_F(WindowPairTest, HandleRemoveWindow02, Function | SmallTest | Level2)
998 {
999     sptr<WindowPair> windowPair = new WindowPair(0);
1000 
1001     sptr<WindowProperty> property1 = new WindowProperty();
1002     property1->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
1003 
1004     sptr<WindowNode> node1 = new WindowNode(property1);
1005     sptr<WindowNode> node2 = new WindowNode(property1);
1006 
1007     // define primary_, secondary_, status_
1008     windowPair->primary_ = nullptr;
1009     windowPair->secondary_ = nullptr;
1010     windowPair->divider_ = nullptr;
1011     windowPair->status_ = WindowPairStatus::PRIMARY_AND_SECONDARY;
1012 
1013     IWindowMocker* w = new IWindowMocker;
1014     sptr<IWindow> window(w);
1015     node1->SetWindowToken(window);
1016     EXPECT_CALL(*w, UpdateWindowMode(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1017     windowPair->HandleRemoveWindow(node1);
1018     ASSERT_EQ(nullptr, windowPair->primary_);
1019     sptr<IWindow> window1 = nullptr;
1020     node1->SetWindowToken(window1);
1021     windowPair->HandleRemoveWindow(node1);
1022     ASSERT_EQ(nullptr, windowPair->primary_);
1023 }
1024 
1025 /**
1026  * @tc.name: TakePairSnapshot
1027  * @tc.desc: take pair snapsht
1028  * @tc.type: FUNC
1029  */
1030 HWTEST_F(WindowPairTest, TakePairSnapshot01, Function | SmallTest | Level2)
1031 {
1032     sptr<WindowPair> windowPair = new WindowPair(0);
1033 
1034     sptr<WindowProperty> property1 = new WindowProperty();
1035     property1->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
1036     sptr<WindowProperty> property2 = new WindowProperty();
1037     property1->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
1038 
1039     sptr<WindowNode> node1 = new WindowNode(property1);
1040     sptr<WindowNode> node2 = new WindowNode(property2);
1041 
1042     // define primary_, secondary_, status_
1043     windowPair->primary_ = node1;
1044     windowPair->secondary_ = node2;
1045     windowPair->status_ = WindowPairStatus::PAIRED_DONE;
1046 
1047     ASSERT_EQ(true, windowPair->TakePairSnapshot());
1048     windowPair->primary_ = nullptr;
1049     ASSERT_EQ(false, windowPair->TakePairSnapshot());
1050     windowPair->primary_ = node1;
1051     windowPair->secondary_ = nullptr;
1052     ASSERT_EQ(false, windowPair->TakePairSnapshot());
1053     windowPair->status_ = WindowPairStatus::PRIMARY_AND_SECONDARY;
1054     ASSERT_EQ(false, windowPair->TakePairSnapshot());
1055 }
1056 
1057 /**
1058  * @tc.name: ClearPairSnapshot
1059  * @tc.desc: Clear Pair Snapshot
1060  * @tc.type: FUNC
1061  */
1062 HWTEST_F(WindowPairTest, ClearPairSnapshot01, Function | SmallTest | Level2)
1063 {
1064     sptr<WindowPair> windowPair = new WindowPair(0);
1065 
1066     sptr<WindowProperty> property1 = new WindowProperty();
1067     property1->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
1068     sptr<WindowProperty> property2 = new WindowProperty();
1069     property1->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
1070 
1071     sptr<WindowNode> node1 = new WindowNode(property1);
1072     sptr<WindowNode> node2 = new WindowNode(property2);
1073 
1074     // define primary_, secondary_,
1075     windowPair->primary_ = node1;
1076     windowPair->secondary_ = node2;
1077 
1078     windowPair->ClearPairSnapshot();
1079     ASSERT_EQ(nullptr, windowPair->primary_->snapshot_);
1080     ASSERT_EQ(nullptr, windowPair->secondary_->snapshot_);
1081 
1082     windowPair->primary_ = nullptr;
1083     ASSERT_EQ(false, windowPair->TakePairSnapshot());
1084     windowPair->primary_ = node1;
1085     windowPair->secondary_ = nullptr;
1086     ASSERT_EQ(false, windowPair->TakePairSnapshot());
1087     windowPair->status_ = WindowPairStatus::PRIMARY_AND_SECONDARY;
1088     ASSERT_EQ(false, windowPair->TakePairSnapshot());
1089 }
1090 /**
1091  * @tc.name: ExitSplitMode
1092  * @tc.desc: Exit Split Mode
1093  * @tc.type: FUNC
1094  */
1095 HWTEST_F(WindowPairTest, ExitSplitMode01, Function | SmallTest | Level2)
1096 {
1097     sptr<WindowPair> windowPair = new WindowPair(0);
1098     sptr<WindowProperty> property1 = new WindowProperty();
1099     property1->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
1100     sptr<WindowProperty> property2 = new WindowProperty();
1101     property2->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
1102 
1103     sptr<WindowNode> node1 = new WindowNode(property1);
1104     windowPair->primary_ = node1;
1105     sptr<WindowNode> node2 = new WindowNode(property2);
1106     windowPair->secondary_ = node2;
1107     windowPair->divider_ = nullptr;
1108     windowPair->ExitSplitMode();
1109     ASSERT_EQ(nullptr, windowPair->divider_);
1110 }
1111 /**
1112  * @tc.name: ExitSplitMode
1113  * @tc.desc: Exit Split Mode
1114  * @tc.type: FUNC
1115  */
1116 HWTEST_F(WindowPairTest, ExitSplitMode02, Function | SmallTest | Level2)
1117 {
1118     sptr<WindowPair> windowPair = new WindowPair(0);
1119     sptr<WindowProperty> property1 = new WindowProperty();
1120     property1->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
1121     sptr<WindowProperty> property2 = new WindowProperty();
1122     property2->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
1123     sptr<WindowProperty> property3 = new WindowProperty();
1124     property2->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1125 
1126     sptr<WindowNode> node1 = new WindowNode(property1);
1127     windowPair->primary_ = node1;
1128     sptr<WindowNode> node2 = new WindowNode(property2);
1129     windowPair->secondary_ = node2;
1130     sptr<WindowNode> node3 = new WindowNode(property3);
1131     const Rect divider_rect2 = {0, 20, 100, 1};
1132     const Rect primary_rect1 = {0, 0, 20, 20};
1133     const Rect secondary_rect1 = {0, 20, 50, 70};
1134     const Rect secondary_rect2 = {0, 20, 10, 10};
1135     node3->SetWindowRect(divider_rect2);
1136     node1->SetWindowRect(primary_rect1);
1137     node2->SetWindowRect(secondary_rect1);
1138     windowPair->divider_ = node3;
1139     windowPair->primary_ = node1;
1140     windowPair->secondary_ = node2;
1141     windowPair->ExitSplitMode();
1142     std::vector<wptr<WindowNode>> vec1 = MinimizeApp::needMinimizeAppNodes_[MinimizeReason::SPLIT_QUIT];
1143     ASSERT_EQ(0, vec1.size());
1144     node2->SetWindowRect(secondary_rect2);
1145     windowPair->secondary_ = node2;
1146     windowPair->ExitSplitMode();
1147     std::vector<wptr<WindowNode>> vec2 = MinimizeApp::needMinimizeAppNodes_[MinimizeReason::SPLIT_QUIT];
1148     ASSERT_EQ(0, vec2.size());
1149     windowPair->Clear();
1150 }
1151 /**
1152  * @tc.name: ExitSplitMode
1153  * @tc.desc: Exit Split Mode
1154  * @tc.type: FUNC
1155  */
1156 HWTEST_F(WindowPairTest, ExitSplitMode03, Function | SmallTest | Level2)
1157 {
1158     sptr<WindowPair> windowPair = new WindowPair(0);
1159     sptr<WindowProperty> property1 = new WindowProperty();
1160     property1->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
1161     sptr<WindowProperty> property2 = new WindowProperty();
1162     property2->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
1163     sptr<WindowProperty> property3 = new WindowProperty();
1164     property2->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1165 
1166     sptr<WindowNode> node1 = new WindowNode(property1);
1167     windowPair->primary_ = node1;
1168     sptr<WindowNode> node2 = new WindowNode(property2);
1169     windowPair->secondary_ = node2;
1170     sptr<WindowNode> node3 = new WindowNode(property3);
1171     const Rect divider_rect1 = {20, 0, 1, 100};
1172     const Rect primary_rect1 = {0, 0, 20, 20};
1173     const Rect secondary_rect1 = {0, 20, 50, 70};
1174     const Rect secondary_rect2 = {0, 20, 10, 20};
1175     node3->SetWindowRect(divider_rect1); // is_vertical false
1176     node2->SetWindowRect(secondary_rect1);
1177     node1->SetWindowRect(primary_rect1);
1178     windowPair->divider_ = node3;
1179     windowPair->primary_ = node1;
1180     windowPair->secondary_ = node2;
1181     windowPair->ExitSplitMode();
1182     std::vector<wptr<WindowNode>> vec1 = MinimizeApp::needMinimizeAppNodes_[MinimizeReason::SPLIT_QUIT];
1183     ASSERT_EQ(0, vec1.size());
1184     node2->SetWindowRect(secondary_rect2);
1185     windowPair->secondary_ = node2;
1186     std::vector<wptr<WindowNode>> vec2 = MinimizeApp::needMinimizeAppNodes_[MinimizeReason::SPLIT_QUIT];
1187     ASSERT_EQ(0, vec2.size());
1188     windowPair->Clear();
1189 }
1190 
1191 
1192 /**
1193  * @tc.name: IsDuringSplit
1194  * @tc.desc: check function IsDuringSplit
1195  * @tc.type: FUNC
1196  */
1197 HWTEST_F(WindowPairTest, IsDuringSplit, Function | SmallTest | Level2)
1198 {
1199     sptr<WindowPair> windowPair = new WindowPair(0);
1200     auto result = windowPair->IsDuringSplit();
1201     ASSERT_EQ(result, false);
1202 
1203     windowPair->status_ = WindowPairStatus::EMPTY;
1204     result = windowPair->IsDuringSplit();
1205     ASSERT_EQ(result, false);
1206 
1207     windowPair->status_ = WindowPairStatus::SINGLE_PRIMARY;
1208     result = windowPair->IsDuringSplit();
1209     ASSERT_EQ(result, true);
1210 
1211     windowPair->status_ = WindowPairStatus::PAIRED_DONE;
1212     windowPair->primary_ = nullptr;
1213     windowPair->secondary_ = nullptr;
1214     result = windowPair->IsDuringSplit();
1215     ASSERT_EQ(result, true);
1216 
1217     sptr<WindowNode> node1 = new WindowNode();
1218     node1->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1219     windowPair->primary_ = node1;
1220     result = windowPair->IsDuringSplit();
1221     ASSERT_EQ(result, true);
1222 
1223     sptr<WindowNode> node2 = new WindowNode();
1224     node2->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1225     windowPair->secondary_ = node2;
1226     result = windowPair->IsDuringSplit();
1227     ASSERT_EQ(result, false);
1228 
1229     windowPair->primary_->property_->SetWindowType(WindowType::WINDOW_TYPE_LAUNCHER_RECENT);
1230     windowPair->secondary_->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1231     result = windowPair->IsDuringSplit();
1232     ASSERT_EQ(result, true);
1233 
1234     windowPair->primary_->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1235     windowPair->secondary_->property_->SetWindowType(WindowType::WINDOW_TYPE_LAUNCHER_RECENT);
1236     ASSERT_EQ(result, true);
1237 }
1238 }
1239 }
1240 }
1241