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