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 "iremote_object_mocker.h"
18 #include "mock_rs_iwindow_animation_controller.h"
19 #include "remote_animation.h"
20 #include "starting_window.h"
21 #include "window_controller.h"
22
23 using namespace testing;
24 using namespace testing::ext;
25
26 namespace OHOS {
27 namespace Rosen {
28 class WindowControllerTest : public testing::Test {
29 public:
30 static void SetUpTestCase();
31 static void TearDownTestCase();
32 void SetUp() override;
33 void TearDown() override;
34
35 static sptr<WindowController> windowController_;
36 static sptr<WindowRoot> windowRoot_;
37 static sptr<InputWindowMonitor> inputWindowMonitor_;
38 static sptr<WindowNode> node_;
39 static sptr<WindowTransitionInfo> transitionInfo_;
40 };
41
42 sptr<WindowController> WindowControllerTest::windowController_ = nullptr;
43 sptr<WindowRoot> WindowControllerTest::windowRoot_ = nullptr;
44 sptr<InputWindowMonitor> WindowControllerTest::inputWindowMonitor_ = nullptr;
45 sptr<WindowNode> WindowControllerTest::node_ = nullptr;
46 sptr<WindowTransitionInfo> WindowControllerTest::transitionInfo_ = nullptr;
47
RootCallback(Event event,const sptr<IRemoteObject> & remoteObject)48 void RootCallback(Event event, const sptr<IRemoteObject>& remoteObject)
49 {
50 return;
51 }
52
SetUpTestCase()53 void WindowControllerTest::SetUpTestCase()
54 {
55 windowRoot_ = new WindowRoot(RootCallback);
56 windowRoot_->displayIdMap_[0].push_back(0);
57 inputWindowMonitor_ = new InputWindowMonitor(windowRoot_);
58 windowController_ = new WindowController(windowRoot_, inputWindowMonitor_);
59 transitionInfo_ = new WindowTransitionInfo();
60 transitionInfo_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
61 node_ = StartingWindow::CreateWindowNode(transitionInfo_, 101); // 101 is windowId
62 node_->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
63 }
64
TearDownTestCase()65 void WindowControllerTest::TearDownTestCase()
66 {
67 }
68
SetUp()69 void WindowControllerTest::SetUp()
70 {
71 }
72
TearDown()73 void WindowControllerTest::TearDown()
74 {
75 }
76
77 namespace {
78 /**
79 * @tc.name: StartingWindow
80 * @tc.desc: Window controller starting window
81 * @tc.type: FUNC
82 */
83 HWTEST_F(WindowControllerTest, StartingWindow, Function | SmallTest | Level3)
84 {
85 windowRoot_->windowNodeMap_.clear();
86 windowController_->StartingWindow(nullptr, nullptr, 0, false);
87 ASSERT_EQ(0, windowRoot_->windowNodeMap_.size());
88
89 transitionInfo_->SetWindowMode(WindowMode::WINDOW_MODE_UNDEFINED);
90 windowController_->StartingWindow(transitionInfo_, nullptr, 0, false);
91 ASSERT_EQ(0, windowRoot_->windowNodeMap_.size());
92
93 sptr<IRemoteObject> abilityTokenMocker = new IRemoteObjectMocker();
94 transitionInfo_->SetAbilityToken(abilityTokenMocker);
95 windowController_->StartingWindow(transitionInfo_, nullptr, 0, false);
96 windowController_->StartingWindow(transitionInfo_, nullptr, 0, true);
97 ASSERT_EQ(1, windowRoot_->windowNodeMap_.size());
98
99 windowRoot_->windowNodeMap_.clear();
100 sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
101 RemoteAnimation::windowAnimationController_ = iface_cast<RSIWindowAnimationController>(iRemoteObjectMocker);
102 windowController_->StartingWindow(transitionInfo_, nullptr, 0, true);
103 ASSERT_EQ(1, windowRoot_->windowNodeMap_.size());
104
105 windowRoot_->windowNodeMap_.clear();
106 windowRoot_->windowNodeMap_.insert(std::make_pair(node_->GetWindowId(), node_));
107 node_->abilityToken_ = abilityTokenMocker;
108 node_->stateMachine_.currState_ = WindowNodeState::SHOW_ANIMATION_PLAYING;
109 windowController_->StartingWindow(transitionInfo_, nullptr, 0, false);
110 ASSERT_EQ(1, windowRoot_->windowNodeMap_.size());
111
112 node_->stateMachine_.currState_ = WindowNodeState::STARTING_CREATED;
113 windowController_->StartingWindow(transitionInfo_, nullptr, 0, false);
114 transitionInfo_->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
115 windowController_->StartingWindow(transitionInfo_, nullptr, 0, false);
116 transitionInfo_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
117 node_->property_->modeSupportInfo_ = WindowModeSupport::WINDOW_MODE_SUPPORT_ALL;
118 windowController_->StartingWindow(transitionInfo_, nullptr, 0, false);
119 ASSERT_EQ(1, windowRoot_->windowNodeMap_.size());
120
121 // Cancel starting window
122 windowController_->CancelStartingWindow(nullptr);
123 windowController_->CancelStartingWindow(abilityTokenMocker);
124
125 node_->startingWindowShown_ = true;
126 windowController_->CancelStartingWindow(abilityTokenMocker);
127 ASSERT_EQ(0, windowRoot_->windowNodeMap_.size());
128
129 windowRoot_->windowNodeMap_.clear();
130 RemoteAnimation::windowAnimationController_ = nullptr;
131 }
132 /**
133 * @tc.name: NotifyWindowTransition
134 * @tc.desc: Window controller notify window transtition
135 * @tc.type: FUNC
136 */
137 HWTEST_F(WindowControllerTest, NotifyWindowTransition, Function | SmallTest | Level3)
138 {
139 sptr<WindowTransitionInfo> srcInfo = nullptr;
140 sptr<WindowTransitionInfo> dstInfo = nullptr;
141 ASSERT_EQ(WMError::WM_ERROR_NO_REMOTE_ANIMATION, windowController_->NotifyWindowTransition(srcInfo, dstInfo));
142
143 srcInfo = new WindowTransitionInfo();
144 sptr<IRemoteObject> srcAbilityTokenMocker = new IRemoteObjectMocker();
145 srcInfo->SetAbilityToken(srcAbilityTokenMocker);
146 sptr<WindowNode> srcNode = StartingWindow::CreateWindowNode(srcInfo, 102); // 102 is windowId
147 srcNode->property_->modeSupportInfo_ = WindowModeSupport::WINDOW_MODE_SUPPORT_ALL;
148
149 dstInfo = new WindowTransitionInfo();
150 sptr<IRemoteObject> dstAbilityTokenMocker = new IRemoteObjectMocker();
151 dstInfo->SetAbilityToken(dstAbilityTokenMocker);
152 sptr<WindowNode> dstNode = StartingWindow::CreateWindowNode(dstInfo, 103); // 103 is windowId
153 dstNode->property_->modeSupportInfo_ = WindowModeSupport::WINDOW_MODE_SUPPORT_ALL;
154
155 windowRoot_->windowNodeMap_.clear();
156 windowRoot_->windowNodeMap_.insert(std::make_pair(srcNode->GetWindowId(), srcNode));
157 windowRoot_->windowNodeMap_.insert(std::make_pair(dstNode->GetWindowId(), dstNode));
158
159 sptr<DisplayInfo> displayInfo = new DisplayInfo();
160 sptr<WindowNodeContainer> container = new WindowNodeContainer(displayInfo, 0);
161 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(0, container));
162
163 sptr<MockRSIWindowAnimationController> mock = new MockRSIWindowAnimationController();
164 RemoteAnimation::windowAnimationController_ = mock;
165 RemoteAnimation::windowRoot_ = windowRoot_;
166 RemoteAnimation::animationFirst_ = true;
167
168 srcInfo->SetTransitionReason(TransitionReason::MINIMIZE);
169 srcNode->stateMachine_.currState_ = WindowNodeState::HIDDEN;
170 ASSERT_EQ(WMError::WM_ERROR_NO_REMOTE_ANIMATION, windowController_->NotifyWindowTransition(srcInfo, dstInfo));
171
172 srcInfo->SetTransitionReason(TransitionReason::MINIMIZE);
173 srcNode->stateMachine_.currState_ = WindowNodeState::STARTING_CREATED;
174 EXPECT_CALL(*mock, OnMinimizeWindow(_, _)).Times(1);
175 ASSERT_EQ(WMError::WM_OK, windowController_->NotifyWindowTransition(srcInfo, dstInfo));
176
177 srcInfo->SetTransitionReason(TransitionReason::CLOSE);
178 srcNode->stateMachine_.currState_ = WindowNodeState::STARTING_CREATED;
179 EXPECT_CALL(*mock, OnCloseWindow(_, _)).Times(1);
180 ASSERT_EQ(WMError::WM_OK, windowController_->NotifyWindowTransition(srcInfo, dstInfo));
181
182 srcInfo->SetTransitionReason(TransitionReason::BACK_TRANSITION);
183 srcNode->stateMachine_.currState_ = WindowNodeState::STARTING_CREATED;
184 EXPECT_CALL(*mock, OnAppTransition(_, _, _)).Times(1);
185 ASSERT_EQ(WMError::WM_OK, windowController_->NotifyWindowTransition(srcInfo, dstInfo));
186
187 srcInfo->SetTransitionReason(TransitionReason::ABILITY_TRANSITION);
188 dstNode->stateMachine_.currState_ = WindowNodeState::STARTING_CREATED;
189 dstNode->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
190 dstNode->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
191 EXPECT_CALL(*mock, OnStartApp(_, _, _)).Times(1);
192 ASSERT_EQ(WMError::WM_OK, windowController_->NotifyWindowTransition(srcInfo, dstInfo));
193
194 dstNode->stateMachine_.currState_ = WindowNodeState::STARTING_CREATED;
195 dstNode->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
196 EXPECT_CALL(*mock, OnStartApp(_, _, _)).Times(1);
197 ASSERT_EQ(WMError::WM_OK, windowController_->NotifyWindowTransition(srcInfo, dstInfo));
198
199 windowRoot_->windowNodeContainerMap_.clear();
200 RemoteAnimation::windowAnimationController_ = nullptr;
201 }
202 /**
203 * @tc.name: FocusWindow
204 * @tc.desc: Window controller focus window
205 * @tc.type: FUNC
206 */
207 HWTEST_F(WindowControllerTest, FocusWindow, Function | SmallTest | Level3)
208 {
209 sptr<IRemoteObject> abilityToken = nullptr;
210 windowController_->GetFocusWindowInfo(abilityToken);
211
212 sptr<DisplayInfo> displayInfo = new DisplayInfo();
213 sptr<WindowNodeContainer> container = new WindowNodeContainer(displayInfo, 0);
214 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(0, container));
215
216 sptr<WindowNode> windowNode;
217 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, windowController_->GetFocusWindowNode(0, windowNode));
218
219 windowRoot_->windowNodeMap_.clear();
220 windowRoot_->windowNodeMap_.insert(std::make_pair(node_->GetWindowId(), node_));
221 container->focusedWindow_ = node_->GetWindowId();
222 node_->currentVisibility_ = false;
223 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, windowController_->GetFocusWindowNode(0, windowNode));
224
225 node_->currentVisibility_ = true;
226 ASSERT_EQ(WMError::WM_OK, windowController_->GetFocusWindowNode(0, windowNode));
227 windowRoot_->windowNodeContainerMap_.clear();
228 }
229 /**
230 * @tc.name: CreateWindow
231 * @tc.desc: Window controller create window
232 * @tc.type: FUNC
233 */
234 HWTEST_F(WindowControllerTest, CreateWindow, Function | SmallTest | Level3)
235 {
236 sptr<IWindow> window;
237 sptr<WindowProperty> property = new WindowProperty();
238 std::shared_ptr<RSSurfaceNode> surfaceNode;
239
240 uint32_t windowId;
241 property->SetParentId(INVALID_WINDOW_ID);
242 ASSERT_EQ(WMError::WM_OK, windowController_->CreateWindow(window, property, surfaceNode, windowId, nullptr, 0, 0));
243
244 property->SetParentId(1);
245 property->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
246 ASSERT_EQ(WMError::WM_ERROR_INVALID_TYPE,
247 windowController_->CreateWindow(window, property, surfaceNode, windowId, nullptr, 0, 0));
248
249 property->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
250 ASSERT_EQ(WMError::WM_OK, windowController_->CreateWindow(window, property, surfaceNode, windowId, nullptr, 0, 0));
251
252 property->SetWindowType(WindowType::WINDOW_TYPE_SYSTEM_SUB_WINDOW);
253 ASSERT_EQ(WMError::WM_OK, windowController_->CreateWindow(window, property, surfaceNode, windowId, nullptr, 0, 0));
254 windowRoot_->windowNodeMap_.clear();
255
256 sptr<IRemoteObject> abilityTokenMocker = new IRemoteObjectMocker();
257 node_->abilityToken_ = abilityTokenMocker;
258
259 property->SetParentId(INVALID_WINDOW_ID);
260 property->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
261 ASSERT_EQ(WMError::WM_OK,
262 windowController_->CreateWindow(window, property, surfaceNode, windowId, abilityTokenMocker, 0, 0));
263
264 property->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
265 ASSERT_EQ(WMError::WM_OK,
266 windowController_->CreateWindow(window, property, surfaceNode, windowId, abilityTokenMocker, 0, 0));
267
268 property->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
269 node_->startingWindowShown_ = false;
270 ASSERT_EQ(WMError::WM_OK,
271 windowController_->CreateWindow(window, property, surfaceNode, windowId, abilityTokenMocker, 0, 0));
272 windowRoot_->windowNodeMap_.clear();
273 }
274 /**
275 * @tc.name: NotifyAfterAddWindow
276 * @tc.desc: Window controller notify after add window
277 * @tc.type: FUNC
278 */
279 HWTEST_F(WindowControllerTest, NotifyAfterAddWindow, Function | SmallTest | Level3)
280 {
281 ASSERT_NE(nullptr, windowController_);
282 sptr<WindowNode> node0 = new WindowNode();
283 windowController_->NotifyAfterAddWindow(node0);
284 ASSERT_EQ(0, node0->children_.size());
285
286 sptr<WindowNode> node1 = new WindowNode();
287 node1->currentVisibility_ = false;
288 sptr<WindowNode> node2= new WindowNode();
289 node2->currentVisibility_ = true;
290
291 node0->children_.push_back(node1);
292 node0->children_.push_back(node2);
293 windowController_->NotifyAfterAddWindow(node0);
294 ASSERT_EQ(2, node0->children_.size());
295 ASSERT_EQ(nullptr, node0->children_[0]->abilityToken_);
296 }
297 /**
298 * @tc.name: AddWindowNode
299 * @tc.desc: Window controller add window node
300 * @tc.type: FUNC
301 */
302 HWTEST_F(WindowControllerTest, AddWindowNode, Function | SmallTest | Level3)
303 {
304 sptr<WindowProperty> property = new WindowProperty();
305 property->SetWindowId(0);
306 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowController_->AddWindowNode(property));
307
308 windowRoot_->windowNodeMap_.clear();
309 windowRoot_->windowNodeMap_.insert(std::make_pair(node_->GetWindowId(), node_));
310 property->SetWindowId(node_->GetWindowId());
311 node_->currentVisibility_ = true;
312 node_->startingWindowShown_ = false;
313 ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, windowController_->AddWindowNode(property));
314 windowRoot_->windowNodeMap_.clear();
315 }
316 /**
317 * @tc.name: InputCallingWindow
318 * @tc.desc: Window controller input calling window
319 * @tc.type: FUNC
320 */
321 HWTEST_F(WindowControllerTest, InputCallingWindow, Function | SmallTest | Level3)
322 {
323 windowController_->callingWindowId_ = 0;
324 windowRoot_->windowNodeMap_.clear();
325 sptr<WindowNode> node = new WindowNode();
326 node->property_->callingWindow_ = 0;
327 node->property_->displayId_ = DISPLAY_ID_INVALID;
328 windowController_->ResizeSoftInputCallingWindowIfNeed(node);
329 ASSERT_EQ(0, windowController_->callingWindowId_);
330
331 sptr<DisplayInfo> displayInfo = new DisplayInfo();
332 sptr<WindowNodeContainer> container = new WindowNodeContainer(displayInfo, 0);
333 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(0, container));
334 node->property_->displayId_ = 0;
335 windowController_->ResizeSoftInputCallingWindowIfNeed(node);
336 ASSERT_EQ(0, windowController_->callingWindowId_);
337
338 windowRoot_->windowNodeMap_.insert(std::make_pair(node_->GetWindowId(), node_));
339 container->focusedWindow_ = node_->GetWindowId();
340 node_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
341 node_->currentVisibility_ = false;
342 windowController_->ResizeSoftInputCallingWindowIfNeed(node);
343 ASSERT_EQ(0, windowController_->callingWindowId_);
344
345 node_->currentVisibility_ = true;
346 node_->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
347 windowController_->ResizeSoftInputCallingWindowIfNeed(node);
348
349 node_->currentVisibility_ = true;
350 node_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
351 windowController_->ResizeSoftInputCallingWindowIfNeed(node);
352 ASSERT_EQ(0, windowController_->callingWindowId_);
353
354 windowController_->callingWindowId_ = node_->GetWindowId();
355 windowController_->callingWindowRestoringRect_ = {0, 0, 0, 0};
356 windowController_->RestoreCallingWindowSizeIfNeed();
357 ASSERT_EQ(0, windowController_->callingWindowId_);
358
359 windowController_->callingWindowRestoringRect_ = {0, 0, 1, 1};
360 windowController_->callingWindowId_ = 0;
361 windowController_->RestoreCallingWindowSizeIfNeed();
362
363 windowController_->callingWindowId_ = node_->GetWindowId();
364 windowController_->RestoreCallingWindowSizeIfNeed();
365 ASSERT_EQ(0, windowController_->callingWindowId_);
366
367 windowController_->callingWindowId_ = node_->GetWindowId();
368 node_->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
369 windowController_->RestoreCallingWindowSizeIfNeed();
370 ASSERT_EQ(0, windowController_->callingWindowId_);
371
372 windowRoot_->windowNodeMap_.clear();
373 windowRoot_->windowNodeContainerMap_.clear();
374 }
375 /**
376 * @tc.name: SetDefaultDisplayInfo
377 * @tc.desc: Window controller set default display info
378 * @tc.type: FUNC
379 */
380 HWTEST_F(WindowControllerTest, SetDefaultDisplayInfo, Function | SmallTest | Level3)
381 {
382 const int32_t displayWidth = 100;
383 const int32_t displayHeight = 200;
384 windowController_->defaultDisplayRect_ = { 0, 0, 0, 0 };
385
386 sptr<DisplayInfo> displayInfo = nullptr;
387 windowController_->SetDefaultDisplayInfo(0, displayInfo);
388 ASSERT_EQ(0, windowController_->defaultDisplayRect_.width_);
389 ASSERT_EQ(0, windowController_->defaultDisplayRect_.height_);
390
391 displayInfo = new DisplayInfo();
392 displayInfo->id_ = 1;
393 displayInfo->width_ = displayWidth;
394 displayInfo->height_ = displayHeight;
395
396 windowController_->SetDefaultDisplayInfo(0, displayInfo);
397 ASSERT_EQ(0, windowController_->defaultDisplayRect_.width_);
398 ASSERT_EQ(0, windowController_->defaultDisplayRect_.height_);
399
400 displayInfo->id_ = 0;
401 windowController_->SetDefaultDisplayInfo(0, displayInfo);
402 ASSERT_EQ(displayWidth, windowController_->defaultDisplayRect_.width_);
403 ASSERT_EQ(displayHeight, windowController_->defaultDisplayRect_.height_);
404 }
405 /**
406 * @tc.name: ProcessDisplayCompression
407 * @tc.desc: Window controller process display compression
408 * @tc.type: FUNC
409 */
410 HWTEST_F(WindowControllerTest, ProcessDisplayCompression, Function | SmallTest | Level3)
411 {
412 ASSERT_NE(nullptr, windowController_);
413 DisplayId defaultDisplayId = 0;
414 sptr<DisplayInfo> displayInfo = new DisplayInfo();
415 displayInfo->id_ = 1;
416 windowController_->ProcessDisplayCompression(defaultDisplayId, displayInfo);
417 ASSERT_EQ(nullptr, windowController_->maskingSurfaceNode_);
418
419 displayInfo->id_ = defaultDisplayId;
420 displayInfo->waterfallDisplayCompressionStatus_ = false;
421 windowController_->ProcessDisplayCompression(defaultDisplayId, displayInfo);
422 ASSERT_EQ(nullptr, windowController_->maskingSurfaceNode_);
423
424 displayInfo->waterfallDisplayCompressionStatus_ = true;
425 windowController_->ProcessDisplayCompression(defaultDisplayId, displayInfo);
426 ASSERT_NE(nullptr, windowController_->maskingSurfaceNode_);
427 }
428 /**
429 * @tc.name: StopBootAnimationIfNeed
430 * @tc.desc: Window controller stop boot animation if need
431 * @tc.type: FUNC
432 */
433 HWTEST_F(WindowControllerTest, StopBootAnimationIfNeed, Function | SmallTest | Level3)
434 {
435 ASSERT_NE(nullptr, windowController_);
436
437 sptr<WindowNode> node = nullptr;
438 windowController_->isBootAnimationStopped_ = true;
439 windowController_->StopBootAnimationIfNeed(node);
440 ASSERT_EQ(true, windowController_->isBootAnimationStopped_);
441
442 windowController_->isBootAnimationStopped_ = false;
443 windowController_->StopBootAnimationIfNeed(node);
444 ASSERT_EQ(false, windowController_->isBootAnimationStopped_);
445
446 node = new WindowNode();
447 node->SetDisplayId(DISPLAY_ID_INVALID + 1);
448 windowController_->StopBootAnimationIfNeed(node);
449 ASSERT_EQ(false, windowController_->isBootAnimationStopped_);
450
451 node->SetDisplayId(DISPLAY_ID_INVALID);
452 windowController_->StopBootAnimationIfNeed(node);
453 ASSERT_EQ(false, windowController_->isBootAnimationStopped_);
454 }
455 /**
456 * @tc.name: GetEmbedNodeId
457 * @tc.desc: Window controller get embed node id
458 * @tc.type: FUNC
459 */
460 HWTEST_F(WindowControllerTest, GetEmbedNodeId, Function | SmallTest | Level3)
461 {
462 std::vector<sptr<WindowNode>> windowNodes;
463 sptr<WindowNode> node0 = nullptr;
464 sptr<WindowNode> node1 = new WindowNode();
465 node1->property_->windowId_ = 1;
466 sptr<WindowNode> node2 = new WindowNode();
467 node2->property_->windowId_ = 2;
468 sptr<WindowNode> node3 = new WindowNode();
469 node3->property_->windowId_ = 3;
470
471 node1->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
472 ASSERT_EQ(0, windowController_->GetEmbedNodeId(windowNodes, node1));
473
474 node1->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_COMPONENT);
475 ASSERT_EQ(0, windowController_->GetEmbedNodeId(windowNodes, node1));
476
477 windowNodes.push_back(node0);
478 windowNodes.push_back(node2);
479 windowNodes.push_back(node1);
480 windowNodes.push_back(node2);
481 windowNodes.push_back(node3);
482
483 node1->SetWindowRect({50, 50, 50, 50});
484 node3->SetWindowRect({0, 0, 200, 200});
485 ASSERT_EQ(node3->GetWindowId(), windowController_->GetEmbedNodeId(windowNodes, node1));
486 }
487 /**
488 * @tc.name: BindDialogTarget
489 * @tc.desc: Window controller bind dialog target
490 * @tc.type: FUNC
491 */
492 HWTEST_F(WindowControllerTest, BindDialogTarget, Function | SmallTest | Level3)
493 {
494 windowRoot_->windowNodeMap_.clear();
495
496 uint32_t id = 0;
497 sptr<IRemoteObject> abilityTokenMocker = new IRemoteObjectMocker();
498 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowController_->BindDialogTarget(id, abilityTokenMocker));
499
500 windowRoot_->windowNodeMap_.insert(std::make_pair(node_->GetWindowId(), node_));
501 id = node_->GetWindowId();
502 ASSERT_EQ(WMError::WM_OK, windowController_->BindDialogTarget(id, abilityTokenMocker));
503 windowRoot_->windowNodeMap_.clear();
504 }
505 }
506 }
507 }
508