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 #include <gtest/gtest.h>
16
17 #include "display_manager.h"
18 #include "display_manager_config.h"
19 #include "future.h"
20 #include "wm_math.h"
21 #include "window_node.h"
22 #include "window_node_container.h"
23
24 using namespace testing;
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace Rosen {
29 class WindowNodeTest : public testing::Test {
30 public:
31 static void SetUpTestCase();
32 static void TearDownTestCase();
33 virtual void SetUp() override;
34 virtual void TearDown() override;
35 };
36
SetUpTestCase()37 void WindowNodeTest::SetUpTestCase()
38 {
39 }
40
TearDownTestCase()41 void WindowNodeTest::TearDownTestCase()
42 {
43 }
44
SetUp()45 void WindowNodeTest::SetUp()
46 {
47 }
48
TearDown()49 void WindowNodeTest::TearDown()
50 {
51 }
52 class WindowListener : public IWindow {
53 public:
UpdateWindowRect(const struct Rect & rect,bool decoStatus,WindowSizeChangeReason reason)54 virtual WMError UpdateWindowRect(const struct Rect& rect, bool decoStatus, WindowSizeChangeReason reason) override
55 {
56 return WMError::WM_OK;
57 };
UpdateWindowMode(WindowMode mode)58 virtual WMError UpdateWindowMode(WindowMode mode) override
59 {
60 return WMError::WM_OK;
61 };
UpdateWindowModeSupportInfo(uint32_t modeSupportInfo)62 virtual WMError UpdateWindowModeSupportInfo(uint32_t modeSupportInfo) override
63 {
64 return WMError::WM_OK;
65 };
UpdateFocusStatus(bool focused)66 virtual WMError UpdateFocusStatus(bool focused) override
67 {
68 return WMError::WM_OK;
69 };
UpdateAvoidArea(const sptr<AvoidArea> & avoidArea,AvoidAreaType type)70 virtual WMError UpdateAvoidArea(const sptr<AvoidArea>& avoidArea, AvoidAreaType type) override
71 {
72 return WMError::WM_OK;
73 };
UpdateWindowState(WindowState state)74 virtual WMError UpdateWindowState(WindowState state) override
75 {
76 return WMError::WM_OK;
77 };
UpdateWindowDragInfo(const PointInfo & point,DragEvent event)78 virtual WMError UpdateWindowDragInfo(const PointInfo& point, DragEvent event) override
79 {
80 return WMError::WM_OK;
81 };
UpdateDisplayId(DisplayId from,DisplayId to)82 virtual WMError UpdateDisplayId(DisplayId from, DisplayId to) override
83 {
84 return WMError::WM_OK;
85 };
UpdateOccupiedAreaChangeInfo(const sptr<OccupiedAreaChangeInfo> & info)86 virtual WMError UpdateOccupiedAreaChangeInfo(const sptr<OccupiedAreaChangeInfo>& info) override
87 {
88 return WMError::WM_OK;
89 };
UpdateActiveStatus(bool isActive)90 virtual WMError UpdateActiveStatus(bool isActive) override
91 {
92 return WMError::WM_OK;
93 };
GetWindowProperty()94 virtual sptr<WindowProperty> GetWindowProperty() override
95 {
96 return nullptr;
97 };
NotifyTouchOutside()98 virtual WMError NotifyTouchOutside() override
99 {
100 return WMError::WM_OK;
101 };
NotifyScreenshot()102 virtual WMError NotifyScreenshot() override
103 {
104 return WMError::WM_OK;
105 };
DumpInfo(const std::vector<std::string> & params)106 virtual WMError DumpInfo(const std::vector<std::string>& params) override
107 {
108 return WMError::WM_OK;
109 };
NotifyDestroy(void)110 virtual WMError NotifyDestroy(void) override
111 {
112 return WMError::WM_OK;
113 };
NotifyForeground(void)114 WMError NotifyForeground(void) override
115 {
116 return WMError::WM_OK;
117 };
NotifyBackground(void)118 WMError NotifyBackground(void) override
119 {
120 return WMError::WM_OK;
121 };
NotifyWindowClientPointUp(const std::shared_ptr<MMI::PointerEvent> & pointerEvent)122 virtual WMError NotifyWindowClientPointUp(const std::shared_ptr<MMI::PointerEvent>& pointerEvent) override
123 {
124 return WMError::WM_OK;
125 };
UpdateZoomTransform(const Transform & trans,bool isDisplayZoomOn)126 WMError UpdateZoomTransform(const Transform& trans, bool isDisplayZoomOn) override
127 {
128 return WMError::WM_OK;
129 };
RestoreSplitWindowMode(uint32_t mode)130 virtual WMError RestoreSplitWindowMode(uint32_t mode) override
131 {
132 return WMError::WM_OK;
133 };
134
AsObject()135 virtual sptr<IRemoteObject> AsObject() override
136 {
137 return nullptr;
138 };
139 };
140
CreateWindowProperty(uint32_t windowId,const std::string & windowName)141 sptr<WindowProperty> CreateWindowProperty(uint32_t windowId, const std::string& windowName)
142 {
143 sptr<WindowProperty> property = new WindowProperty();
144 property->SetWindowId(windowId);
145 property->SetWindowName(windowName);
146 return property;
147 }
148
CreateRSSurfaceNode(std::string windowNode)149 RSSurfaceNode::SharedPtr CreateRSSurfaceNode(std::string windowNode)
150 {
151 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
152 rsSurfaceNodeConfig.SurfaceNodeName = windowNode;
153 auto surfaceNode = RSSurfaceNode::Create(rsSurfaceNodeConfig);
154 return surfaceNode;
155 }
156 namespace {
157 /**
158 * @tc.name: NewWindowNode01
159 * @tc.desc: new window node with WindowProperty
160 * @tc.type: FUNC
161 */
162 HWTEST_F(WindowNodeTest, NewWindowNode01, Function | SmallTest | Level3)
163 {
164 sptr<WindowNode> windowNode1 = new WindowNode();
165 ASSERT_NE(nullptr, windowNode1);
166 ASSERT_EQ("", windowNode1->GetWindowName());
167
168 std::string windowName = "WindowNode01";
169 auto property = CreateWindowProperty(1, windowName);
170 ASSERT_NE(nullptr, property);
171
172 sptr<WindowNode> windowNode2 = new WindowNode(property);
173 ASSERT_NE(nullptr, windowNode2);
174 ASSERT_EQ(windowName, windowNode2->GetWindowName());
175 }
176 /**
177 * @tc.name: NewWindowNode02
178 * @tc.desc: new window node with WindowProperty, RSSurfaceNode, IWindow
179 * @tc.type: FUNC
180 */
181 HWTEST_F(WindowNodeTest, NewWindowNode02, Function | SmallTest | Level1)
182 {
183 std::string windowName = "WindowNode02";
184 auto property = CreateWindowProperty(2, windowName);
185 ASSERT_NE(nullptr, property);
186
187 auto surfaceNode = CreateRSSurfaceNode(windowName);
188 ASSERT_NE(nullptr, surfaceNode);
189
190 sptr<WindowListener> iWindow = new WindowListener();
191 ASSERT_NE(nullptr, iWindow);
192
193 sptr<WindowNode> windowNode = new WindowNode(property, iWindow, surfaceNode);
194 ASSERT_NE(nullptr, windowNode);
195 ASSERT_EQ(windowName, windowNode->GetWindowName());
196 }
197 /**
198 * @tc.name: NewWindowNode03
199 * @tc.desc: new window node with WindowProperty, RSSurfaceNode, IWindow, pid , uid
200 * @tc.type: FUNC
201 */
202 HWTEST_F(WindowNodeTest, NewWindowNode03, Function | SmallTest | Level1)
203 {
204 std::string windowName = "WindowNode03";
205 auto property = CreateWindowProperty(3, windowName);
206 ASSERT_NE(nullptr, property);
207 auto surfaceNode = CreateRSSurfaceNode(windowName);
208 ASSERT_NE(nullptr, surfaceNode);
209 sptr<WindowListener> iWindow = new Rosen::WindowListener();
210 ASSERT_NE(nullptr, iWindow);
211
212 int32_t pid = 1;
213 int32_t uid = 2;
214 sptr<WindowNode> windowNode = new WindowNode(property, iWindow, surfaceNode, pid, uid);
215 ASSERT_NE(nullptr, windowNode);
216
217 ASSERT_EQ(1, windowNode->GetInputEventCallingPid());
218 ASSERT_EQ(1, windowNode->GetCallingPid());
219 ASSERT_EQ(2, windowNode->GetCallingUid());
220 }
221 /**
222 * @tc.name: SetDisplayId01
223 * @tc.desc: SetDisplayId & GetDisplayId
224 * @tc.type: FUNC
225 */
226 HWTEST_F(WindowNodeTest, SetDisplayId01, Function | SmallTest | Level1)
227 {
228 std::string windowName = "WindowNode04";
229 auto property = CreateWindowProperty(4, windowName);
230 ASSERT_NE(nullptr, property);
231
232 sptr<WindowNode> windowNode = new WindowNode(property);
233 ASSERT_NE(nullptr, windowNode);
234 ASSERT_EQ(0, windowNode->GetDisplayId());
235
236 windowNode->SetDisplayId(1);
237 ASSERT_EQ(1, windowNode->GetDisplayId());
238 }
239 /**
240 * @tc.name: SetEntireWindowTouchHotArea01
241 * @tc.desc: SetEntireWindowTouchHotArea & GetEntireWindowTouchHotArea
242 * @tc.type: FUNC
243 */
244 HWTEST_F(WindowNodeTest, SetEntireWindowTouchHotArea01, Function | SmallTest | Level1)
245 {
246 std::string windowName = "WindowNode05";
247 auto property = CreateWindowProperty(5, windowName);
248 ASSERT_NE(nullptr, property);
249
250 sptr<WindowNode> windowNode = new WindowNode(property);
251 ASSERT_NE(nullptr, windowNode);
252
253 ASSERT_EQ(0, windowNode->GetEntireWindowTouchHotArea().posX_);
254 ASSERT_EQ(0, windowNode->GetEntireWindowTouchHotArea().posY_);
255 ASSERT_EQ(0, windowNode->GetEntireWindowTouchHotArea().width_);
256 ASSERT_EQ(0, windowNode->GetEntireWindowTouchHotArea().height_);
257
258 Rect testValue = { 10, 10, 255, 255 };
259 windowNode->SetEntireWindowTouchHotArea(testValue);
260 ASSERT_EQ(testValue.posX_, windowNode->GetEntireWindowTouchHotArea().posX_);
261 ASSERT_EQ(testValue.posY_, windowNode->GetEntireWindowTouchHotArea().posY_);
262 ASSERT_EQ(testValue.width_, windowNode->GetEntireWindowTouchHotArea().width_);
263 ASSERT_EQ(testValue.height_, windowNode->GetEntireWindowTouchHotArea().height_);
264 }
265 /**
266 * @tc.name: SetEntireWindowPointerHotArea01
267 * @tc.desc: SetEntireWindowPointerHotArea & GetEntireWindowPointerHotArea
268 * @tc.type: FUNC
269 */
270 HWTEST_F(WindowNodeTest, SetEntireWindowPointerHotArea01, Function | SmallTest | Level1)
271 {
272 std::string windowName = "WindowNode06";
273 auto property = CreateWindowProperty(6, windowName);
274 ASSERT_NE(nullptr, property);
275
276 sptr<WindowNode> windowNode = new WindowNode(property);
277 ASSERT_NE(nullptr, windowNode);
278
279 Rect rect1 = {0, 0, 0, 0};
280 windowNode->SetEntireWindowPointerHotArea(rect1);
281 ASSERT_EQ(0, windowNode->GetEntireWindowPointerHotArea().posX_);
282 ASSERT_EQ(0, windowNode->GetEntireWindowPointerHotArea().posY_);
283 ASSERT_EQ(0, windowNode->GetEntireWindowPointerHotArea().width_);
284 ASSERT_EQ(0, windowNode->GetEntireWindowPointerHotArea().height_);
285
286 Rect rect2 = {10, 10, 255, 255};
287 windowNode->SetEntireWindowPointerHotArea(rect2);
288 ASSERT_EQ(10, windowNode->GetEntireWindowPointerHotArea().posX_);
289 ASSERT_EQ(10, windowNode->GetEntireWindowPointerHotArea().posY_);
290 ASSERT_EQ(255, windowNode->GetEntireWindowPointerHotArea().width_);
291 ASSERT_EQ(255, windowNode->GetEntireWindowPointerHotArea().height_);
292 }
293 /**
294 * @tc.name: SetWindowRect01
295 * @tc.desc: SetWindowRect & GetWindowRect
296 * @tc.type: FUNC
297 */
298 HWTEST_F(WindowNodeTest, SetWindowRect01, Function | SmallTest | Level1)
299 {
300 std::string windowName = "WindowNode07";
301 auto property = CreateWindowProperty(7, windowName);
302 ASSERT_NE(nullptr, property);
303
304 sptr<WindowNode> windowNode = new WindowNode(property);
305 ASSERT_NE(nullptr, windowNode);
306
307 Rect rect1 = {0, 0, 0, 0};
308 windowNode->SetWindowRect(rect1);
309 ASSERT_EQ(0, windowNode->GetWindowRect().posX_);
310 ASSERT_EQ(0, windowNode->GetWindowRect().posY_);
311 ASSERT_EQ(0, windowNode->GetWindowRect().width_);
312 ASSERT_EQ(0, windowNode->GetWindowRect().height_);
313
314 Rect rect2 = {10, 10, 255, 255};
315 windowNode->SetWindowRect(rect2);
316 ASSERT_EQ(10, windowNode->GetWindowRect().posX_);
317 ASSERT_EQ(10, windowNode->GetWindowRect().posY_);
318 ASSERT_EQ(255, windowNode->GetWindowRect().width_);
319 ASSERT_EQ(255, windowNode->GetWindowRect().height_);
320 }
321 /**
322 * @tc.name: SetDecoStatus01
323 * @tc.desc: SetDecoStatus & GetDecoStatus
324 * @tc.type: FUNC
325 */
326 HWTEST_F(WindowNodeTest, SetDecoStatus01, Function | SmallTest | Level1)
327 {
328 std::string windowName = "WindowNode08";
329 auto property = CreateWindowProperty(8, windowName);
330 ASSERT_NE(nullptr, property);
331 sptr<WindowNode> windowNode = new WindowNode(property);
332 ASSERT_NE(nullptr, windowNode);
333
334 windowNode->SetDecoStatus(true);
335 ASSERT_EQ(true, windowNode->GetDecoStatus());
336 windowNode->SetDecoStatus(false);
337 ASSERT_EQ(false, windowNode->GetDecoStatus());
338 }
339 /**
340 * @tc.name: SetRequestRect01
341 * @tc.desc: SetRequestRect & GetRequestRect
342 * @tc.type: FUNC
343 */
344 HWTEST_F(WindowNodeTest, SetRequestRect01, Function | SmallTest | Level1)
345 {
346 std::string windowName = "WindowNode09";
347 auto property = CreateWindowProperty(9, windowName);
348 ASSERT_NE(nullptr, property);
349 sptr<WindowNode> windowNode = new WindowNode(property);
350 ASSERT_NE(nullptr, windowNode);
351
352 Rect rect1 = { 0, 0, 0, 0 };
353 windowNode->SetRequestRect(rect1);
354 ASSERT_EQ(0, windowNode->GetRequestRect().posX_);
355 ASSERT_EQ(0, windowNode->GetRequestRect().posY_);
356 ASSERT_EQ(0, windowNode->GetRequestRect().width_);
357 ASSERT_EQ(0, windowNode->GetRequestRect().height_);
358
359 Rect rect2 = { 10, 10, 255, 255 };
360 windowNode->SetRequestRect(rect2);
361 ASSERT_EQ(10, windowNode->GetRequestRect().posX_);
362 ASSERT_EQ(10, windowNode->GetRequestRect().posY_);
363 ASSERT_EQ(255, windowNode->GetRequestRect().width_);
364 ASSERT_EQ(255, windowNode->GetRequestRect().height_);
365 }
366 /**
367 * @tc.name: SetWindowProperty01
368 * @tc.desc: SetWindowProperty & GetWindowProperty
369 * @tc.type: FUNC
370 */
371 HWTEST_F(WindowNodeTest, SetWindowProperty01, Function | SmallTest | Level1)
372 {
373 std::string windowName = "WindowNode09";
374 auto property = CreateWindowProperty(9, windowName);
375 ASSERT_NE(nullptr, property);
376 sptr<WindowNode> windowNode = new WindowNode(property);
377 ASSERT_NE(nullptr, windowNode);
378 ASSERT_EQ(property, windowNode->GetWindowProperty());
379
380 auto property2 = CreateWindowProperty(10, windowName);
381 ASSERT_NE(nullptr, property2);
382 windowNode->SetWindowProperty(property2);
383 ASSERT_EQ(property2, windowNode->GetWindowProperty());
384 }
385 /**
386 * @tc.name: SetSystemBarProperty01
387 * @tc.desc: SetSystemBarProperty & GetSystemBarProperty
388 * @tc.type: FUNC
389 */
390 HWTEST_F(WindowNodeTest, SetSystemBarProperty01, Function | SmallTest | Level1)
391 {
392 std::string windowName = "WindowNode10";
393 auto property = CreateWindowProperty(10, windowName);
394 ASSERT_NE(nullptr, property);
395 sptr<WindowNode> windowNode = new WindowNode(property);
396 ASSERT_NE(nullptr, windowNode);
397
398 SystemBarProperty systemBarProperty1;
399 SystemBarProperty systemBarProperty2;
400 SystemBarProperty systemBarProperty3;
401 windowNode->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, systemBarProperty1);
402 windowNode->SetSystemBarProperty(WindowType::WINDOW_TYPE_NAVIGATION_BAR, systemBarProperty2);
403 windowNode->SetSystemBarProperty(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, systemBarProperty3);
404
405 auto systemBarProperties = windowNode->GetSystemBarProperty();
406 ASSERT_EQ(systemBarProperty1, systemBarProperties.find(WindowType::WINDOW_TYPE_STATUS_BAR)->second);
407 ASSERT_EQ(systemBarProperty2, systemBarProperties.find(WindowType::WINDOW_TYPE_NAVIGATION_BAR)->second);
408 ASSERT_EQ(systemBarProperties.end(), systemBarProperties.find(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW));
409 }
410 /**
411 * @tc.name: SetWindowMode01
412 * @tc.desc: SetWindowMode & GetWindowMode
413 * @tc.type: FUNC
414 */
415 HWTEST_F(WindowNodeTest, SetWindowMode01, Function | SmallTest | Level1)
416 {
417 std::string windowName = "WindowNode11";
418 auto property = CreateWindowProperty(11, windowName);
419 ASSERT_NE(nullptr, property);
420 sptr<WindowNode> windowNode = new WindowNode(property);
421 ASSERT_NE(nullptr, windowNode);
422 ASSERT_EQ(WindowMode::WINDOW_MODE_UNDEFINED, windowNode->GetWindowMode());
423
424 windowNode->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
425 ASSERT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, windowNode->GetWindowMode());
426 }
427 /**
428 * @tc.name: SetBrightness01
429 * @tc.desc: SetBrightness & GetBrightness
430 * @tc.type: FUNC
431 */
432 HWTEST_F(WindowNodeTest, SetBrightness01, Function | SmallTest | Level1)
433 {
434 std::string windowName = "WindowNode12";
435 auto property = CreateWindowProperty(12, windowName);
436 ASSERT_NE(nullptr, property);
437 sptr<WindowNode> windowNode = new WindowNode(property);
438 ASSERT_NE(nullptr, windowNode);
439
440 ASSERT_EQ(UNDEFINED_BRIGHTNESS, windowNode->GetBrightness());
441
442 windowNode->SetBrightness(0.5f);
443 ASSERT_EQ(0.5f, windowNode->GetBrightness());
444 windowNode->SetBrightness(1.1f);
445 ASSERT_EQ(1.1f, windowNode->GetBrightness());
446 }
447 /**
448 * @tc.name: SetTurnScreenOn01
449 * @tc.desc: SetTurnScreenOn & IsTurnScreenOn
450 * @tc.type: FUNC
451 */
452 HWTEST_F(WindowNodeTest, SetTurnScreenOn01, Function | SmallTest | Level1)
453 {
454 std::string windowName = "WindowNode13";
455 auto property = CreateWindowProperty(13, windowName);
456 ASSERT_NE(nullptr, property);
457 sptr<WindowNode> windowNode = new WindowNode(property);
458 ASSERT_NE(nullptr, windowNode);
459
460 ASSERT_EQ(false, windowNode->IsTurnScreenOn());
461 windowNode->SetTurnScreenOn(true);
462 ASSERT_EQ(true, windowNode->IsTurnScreenOn());
463 }
464 /**
465 * @tc.name: SetKeepScreenOn01
466 * @tc.desc: SetKeepScreenOn & IsKeepScreenOn
467 * @tc.type: FUNC
468 */
469 HWTEST_F(WindowNodeTest, SetKeepScreenOn01, Function | SmallTest | Level1)
470 {
471 std::string windowName = "WindowNode14";
472 auto property = CreateWindowProperty(14, windowName);
473 ASSERT_NE(nullptr, property);
474 sptr<WindowNode> windowNode = new WindowNode(property);
475 ASSERT_NE(nullptr, windowNode);
476
477 ASSERT_EQ(false, windowNode->IsKeepScreenOn());
478 windowNode->SetKeepScreenOn(true);
479 ASSERT_EQ(true, windowNode->IsKeepScreenOn());
480 }
481 /**
482 * @tc.name: SetCallingWindow01
483 * @tc.desc: SetCallingWindow & GetCallingWindow
484 * @tc.type: FUNC
485 */
486 HWTEST_F(WindowNodeTest, SetCallingWindow01, Function | SmallTest | Level1)
487 {
488 std::string windowName = "WindowNode15";
489 auto property = CreateWindowProperty(15, windowName);
490 ASSERT_NE(nullptr, property);
491 sptr<WindowNode> windowNode = new WindowNode(property);
492 ASSERT_NE(nullptr, windowNode);
493
494 ASSERT_EQ(INVALID_WINDOW_ID, windowNode->GetCallingWindow());
495 windowNode->SetCallingWindow(100);
496 ASSERT_EQ(100, windowNode->GetCallingWindow());
497 }
498 /**
499 * @tc.name: SetCallingPid01
500 * @tc.desc: SetCallingPid & GetCallingPid, SetInputEventCallingPid & GetInputEventCallingPid
501 * @tc.type: FUNC
502 */
503 HWTEST_F(WindowNodeTest, SetCallingPid01, Function | SmallTest | Level1)
504 {
505 std::string windowName = "WindowNode16";
506 auto property = CreateWindowProperty(16, windowName);
507 ASSERT_NE(nullptr, property);
508 sptr<WindowNode> windowNode = new WindowNode(property);
509 ASSERT_NE(nullptr, windowNode);
510
511 ASSERT_EQ(0, windowNode->GetCallingPid());
512 ASSERT_EQ(0, windowNode->GetInputEventCallingPid());
513
514 windowNode->SetCallingPid(1);
515 ASSERT_EQ(1, windowNode->GetCallingPid());
516 ASSERT_EQ(1, windowNode->GetInputEventCallingPid());
517
518 windowNode->SetInputEventCallingPid(2);
519 ASSERT_EQ(1, windowNode->GetCallingPid());
520 ASSERT_EQ(2, windowNode->GetInputEventCallingPid());
521 }
522 /**
523 * @tc.name: SetCallingUid01
524 * @tc.desc: SetCallingUid & GetCallingUid
525 * @tc.type: FUNC
526 */
527 HWTEST_F(WindowNodeTest, SetCallingUid01, Function | SmallTest | Level1)
528 {
529 std::string windowName = "WindowNode17";
530 auto property = CreateWindowProperty(17, windowName);
531 ASSERT_NE(nullptr, property);
532 sptr<WindowNode> windowNode = new WindowNode(property);
533 ASSERT_NE(nullptr, windowNode);
534
535 ASSERT_EQ(0, windowNode->GetCallingUid());
536
537 windowNode->SetCallingUid(1);
538 ASSERT_EQ(1, windowNode->GetCallingUid());
539 }
540 /**
541 * @tc.name: SetWindowSizeChangeReason01
542 * @tc.desc: SetWindowSizeChangeReason & GetWindowSizeChangeReason & ResetWindowSizeChangeReason
543 * @tc.type: FUNC
544 */
545 HWTEST_F(WindowNodeTest, SetWindowSizeChangeReason01, Function | SmallTest | Level1)
546 {
547 std::string windowName = "WindowNode19";
548 auto property = CreateWindowProperty(19, windowName);
549 ASSERT_NE(nullptr, property);
550 sptr<WindowNode> windowNode = new WindowNode(property);
551 ASSERT_NE(nullptr, windowNode);
552
553 ASSERT_EQ(WindowSizeChangeReason::UNDEFINED, windowNode->GetWindowSizeChangeReason());
554 windowNode->SetWindowSizeChangeReason(WindowSizeChangeReason::MAXIMIZE);
555 ASSERT_EQ(WindowSizeChangeReason::MAXIMIZE, windowNode->GetWindowSizeChangeReason());
556 windowNode->ResetWindowSizeChangeReason();
557 ASSERT_EQ(WindowSizeChangeReason::UNDEFINED, windowNode->GetWindowSizeChangeReason());
558 }
559 /**
560 * @tc.name: SetRequestedOrientation01
561 * @tc.desc: SetRequestedOrientation & GetRequestedOrientation
562 * @tc.type: FUNC
563 */
564 HWTEST_F(WindowNodeTest, SetRequestedOrientation01, Function | SmallTest | Level1)
565 {
566 std::string windowName = "WindowNode20";
567 auto property = CreateWindowProperty(20, windowName);
568 ASSERT_NE(nullptr, property);
569 sptr<WindowNode> windowNode = new WindowNode(property);
570 ASSERT_NE(nullptr, windowNode);
571
572 ASSERT_EQ(Orientation::UNSPECIFIED, windowNode->GetRequestedOrientation());
573 windowNode->SetRequestedOrientation(Orientation::REVERSE_VERTICAL);
574 ASSERT_EQ(Orientation::REVERSE_VERTICAL, windowNode->GetRequestedOrientation());
575 }
576 /**
577 * @tc.name: SetShowingDisplays01
578 * @tc.desc: SetShowingDisplays & GetShowingDisplays
579 * @tc.type: FUNC
580 */
581 HWTEST_F(WindowNodeTest, SetShowingDisplays01, Function | SmallTest | Level1)
582 {
583 std::string windowName = "WindowNode21";
584 auto property = CreateWindowProperty(21, windowName);
585 ASSERT_NE(nullptr, property);
586 sptr<WindowNode> windowNode = new WindowNode(property);
587 ASSERT_NE(nullptr, windowNode);
588
589 auto displays = windowNode->GetShowingDisplays();
590 ASSERT_EQ(true, displays.empty());
591
592 std::vector<DisplayId> emptyDisplayIds;
593 windowNode->SetShowingDisplays(emptyDisplayIds);
594 ASSERT_EQ(true, windowNode->GetShowingDisplays().empty());
595
596 displays.push_back(static_cast<DisplayId>(0));
597 windowNode->SetShowingDisplays(displays);
598 ASSERT_EQ(1, windowNode->GetShowingDisplays().size());
599 }
600 /**
601 * @tc.name: SetModeSupportInfo01
602 * @tc.desc: SetModeSupportInfo & GetModeSupportInfo
603 * @tc.type: FUNC
604 */
605 HWTEST_F(WindowNodeTest, SetModeSupportInfo01, Function | SmallTest | Level1)
606 {
607 std::string windowName = "WindowNode22";
608 auto property = CreateWindowProperty(22, windowName);
609 ASSERT_NE(nullptr, property);
610 sptr<WindowNode> windowNode = new WindowNode(property);
611 ASSERT_NE(nullptr, windowNode);
612
613 ASSERT_EQ(WindowModeSupport::WINDOW_MODE_SUPPORT_ALL, windowNode->GetModeSupportInfo());
614 windowNode->SetModeSupportInfo(WindowModeSupport::WINDOW_MODE_SUPPORT_FULLSCREEN);
615 ASSERT_EQ(WindowModeSupport::WINDOW_MODE_SUPPORT_FULLSCREEN, windowNode->GetModeSupportInfo());
616 }
617 /**
618 * @tc.name: SetDragType01
619 * @tc.desc: SetDragType & GetDragType
620 * @tc.type: FUNC
621 */
622 HWTEST_F(WindowNodeTest, SetDragType01, Function | SmallTest | Level1)
623 {
624 std::string windowName = "WindowNode23";
625 auto property = CreateWindowProperty(23, windowName);
626 ASSERT_NE(nullptr, property);
627 sptr<WindowNode> windowNode = new WindowNode(property);
628 ASSERT_NE(nullptr, windowNode);
629
630 ASSERT_EQ(DragType::DRAG_UNDEFINED, windowNode->GetDragType());
631 windowNode->SetDragType(DragType::DRAG_BOTTOM_OR_TOP);
632 ASSERT_EQ(DragType::DRAG_BOTTOM_OR_TOP, windowNode->GetDragType());
633 }
634 /**
635 * @tc.name: SetOriginRect01
636 * @tc.desc: SetOriginRect & GetOriginRect
637 * @tc.type: FUNC
638 */
639 HWTEST_F(WindowNodeTest, SetOriginRect01, Function | SmallTest | Level1)
640 {
641 std::string windowName = "WindowNode24";
642 auto property = CreateWindowProperty(24, windowName);
643 ASSERT_NE(nullptr, property);
644 sptr<WindowNode> windowNode = new WindowNode(property);
645 ASSERT_NE(nullptr, windowNode);
646
647 auto defaultRect = windowNode->GetOriginRect();
648 ASSERT_EQ(0, defaultRect.posX_);
649 ASSERT_EQ(0, defaultRect.posX_);
650 ASSERT_EQ(0, defaultRect.width_);
651 ASSERT_EQ(0, defaultRect.height_);
652
653 Rect testRect = { 10, 10, 150, 150 };
654 windowNode->SetOriginRect(testRect);
655 auto resultRect = windowNode->GetOriginRect();
656 ASSERT_EQ(testRect, resultRect);
657 }
658 /**
659 * @tc.name: SetTouchHotAreas01
660 * @tc.desc: SetTouchHotAreas & GetTouchHotAreas
661 * @tc.type: FUNC
662 */
663 HWTEST_F(WindowNodeTest, SetTouchHotAreas01, Function | SmallTest | Level1)
664 {
665 std::string windowName = "WindowNode25";
666 auto property = CreateWindowProperty(25, windowName);
667 ASSERT_NE(nullptr, property);
668 sptr<WindowNode> windowNode = new WindowNode(property);
669 ASSERT_NE(nullptr, windowNode);
670
671 std::vector<Rect> testRects;
672 windowNode->GetTouchHotAreas(testRects);
673 ASSERT_EQ(true, testRects.empty());
674
675 Rect rect1 = { 10, 10, 10, 10 };
676 testRects.push_back(rect1);
677 windowNode->SetTouchHotAreas(testRects);
678
679 std::vector<Rect> resultRect;
680 windowNode->GetTouchHotAreas(resultRect);
681 ASSERT_EQ(1, resultRect.size());
682 ASSERT_EQ(rect1, resultRect[0]);
683 }
684 /**
685 * @tc.name: SetPointerHotAreas01
686 * @tc.desc: SetPointerHotAreas & GetPointerHotAreas
687 * @tc.type: FUNC
688 */
689 HWTEST_F(WindowNodeTest, SetPointerHotAreas01, Function | SmallTest | Level1)
690 {
691 std::string windowName = "WindowNode26";
692 auto property = CreateWindowProperty(26, windowName);
693 ASSERT_NE(nullptr, property);
694 sptr<WindowNode> windowNode = new WindowNode(property);
695 ASSERT_NE(nullptr, windowNode);
696
697 std::vector<Rect> testRects;
698 windowNode->GetPointerHotAreas(testRects);
699 ASSERT_EQ(true, testRects.empty());
700
701 Rect rect1 = { 10, 10, 10, 10 };
702 testRects.push_back(rect1);
703 windowNode->SetPointerHotAreas(testRects);
704 std::vector<Rect> resultRect;
705 windowNode->GetPointerHotAreas(resultRect);
706 ASSERT_EQ(1, resultRect.size());
707 ASSERT_EQ(rect1, resultRect[0]);
708 }
709 /**
710 * @tc.name: SetPointerHotAreas01
711 * @tc.desc: SetWindowSizeLimits & GetWindowSizeLimits
712 * @tc.type: FUNC
713 */
714 HWTEST_F(WindowNodeTest, SetWindowSizeLimits01, Function | SmallTest | Level1)
715 {
716 std::string windowName = "WindowNode27";
717 auto property = CreateWindowProperty(27, windowName);
718 ASSERT_NE(nullptr, property);
719 sptr<WindowNode> windowNode = new WindowNode(property);
720 ASSERT_NE(nullptr, windowNode);
721
722 auto defaultValue = windowNode->GetWindowSizeLimits();
723 ASSERT_EQ(0, defaultValue.minWidth_);
724 ASSERT_EQ(0, defaultValue.minHeight_);
725 ASSERT_EQ(0.0f, defaultValue.minRatio_);
726 ASSERT_EQ(UINT32_MAX, defaultValue.maxWidth_);
727 ASSERT_EQ(UINT32_MAX, defaultValue.maxHeight_);
728 ASSERT_EQ(FLT_MAX, defaultValue.maxRatio_);
729
730 WindowSizeLimits testValue = { 200, 200, 50, 50, 2.0f, 2.0f };
731 windowNode->SetWindowSizeLimits(testValue);
732
733 auto resultValue = windowNode->GetWindowSizeLimits();
734 ASSERT_EQ(testValue.minWidth_, resultValue.minWidth_);
735 ASSERT_EQ(testValue.minHeight_, resultValue.minHeight_);
736 ASSERT_EQ(testValue.minRatio_, resultValue.minRatio_);
737 ASSERT_EQ(testValue.maxWidth_, resultValue.maxWidth_);
738 ASSERT_EQ(testValue.maxHeight_, resultValue.maxHeight_);
739 ASSERT_EQ(testValue.maxRatio_, resultValue.maxRatio_);
740 }
741 /**
742 * @tc.name: SetWindowUpdatedSizeLimits01
743 * @tc.desc: SetWindowUpdatedSizeLimits & GetWindowUpdatedSizeLimits
744 * @tc.type: FUNC
745 */
746 HWTEST_F(WindowNodeTest, SetWindowUpdatedSizeLimits01, Function | SmallTest | Level1)
747 {
748 std::string windowName = "WindowNode28";
749 auto property = CreateWindowProperty(28, windowName);
750 ASSERT_NE(nullptr, property);
751 sptr<WindowNode> windowNode = new WindowNode(property);
752 ASSERT_NE(nullptr, windowNode);
753
754 auto defaultValue = windowNode->GetWindowUpdatedSizeLimits();
755 ASSERT_EQ(0, defaultValue.minWidth_);
756 ASSERT_EQ(0, defaultValue.minHeight_);
757 ASSERT_EQ(0.0f, defaultValue.minRatio_);
758 ASSERT_EQ(UINT32_MAX, defaultValue.maxWidth_);
759 ASSERT_EQ(UINT32_MAX, defaultValue.maxHeight_);
760 ASSERT_EQ(FLT_MAX, defaultValue.maxRatio_);
761
762 WindowSizeLimits testValue = { 200, 200, 50, 50, 2.0f, 2.0f };
763 windowNode->SetWindowUpdatedSizeLimits(testValue);
764
765 auto resultValue = windowNode->GetWindowUpdatedSizeLimits();
766 ASSERT_EQ(testValue.minWidth_, resultValue.minWidth_);
767 ASSERT_EQ(testValue.minHeight_, resultValue.minHeight_);
768 ASSERT_EQ(testValue.minRatio_, resultValue.minRatio_);
769 ASSERT_EQ(testValue.maxWidth_, resultValue.maxWidth_);
770 ASSERT_EQ(testValue.maxHeight_, resultValue.maxHeight_);
771 ASSERT_EQ(testValue.maxRatio_, resultValue.maxRatio_);
772 }
773 /**
774 * @tc.name: SetSnapshot01
775 * @tc.desc: SetSnapshot & GetSnapshot
776 * @tc.type: FUNC
777 */
778 HWTEST_F(WindowNodeTest, SetSnapshot01, Function | SmallTest | Level1)
779 {
780 std::string windowName = "WindowNode29";
781 auto property = CreateWindowProperty(29, windowName);
782 ASSERT_NE(nullptr, property);
783 sptr<WindowNode> windowNode = new WindowNode(property);
784 ASSERT_NE(nullptr, windowNode);
785
786 auto defaultValue = windowNode->GetSnapshot();
787 ASSERT_EQ(0, defaultValue.use_count());
788
789 std::shared_ptr<Media::PixelMap> pixelMap = std::make_shared<Media::PixelMap>();
790 windowNode->SetSnapshot(std::move(pixelMap));
791
792 auto resultValue = windowNode->GetSnapshot();
793 ASSERT_EQ(2, resultValue.use_count());
794 }
795 /**
796 * @tc.name: UpdateZoomTransform01
797 * @tc.desc: UpdateZoomTransform & GetZoomTransform
798 * @tc.type: FUNC
799 */
800 HWTEST_F(WindowNodeTest, UpdateZoomTransform01, Function | SmallTest | Level1)
801 {
802 std::string windowName = "WindowNode30";
803 auto property = CreateWindowProperty(30, windowName);
804 ASSERT_NE(nullptr, property);
805 sptr<WindowNode> windowNode = new WindowNode(property);
806 ASSERT_NE(nullptr, windowNode);
807
808 Transform transformData;
809 auto defaultValue = windowNode->GetZoomTransform();
810 ASSERT_EQ(transformData, defaultValue);
811
812 transformData.pivotX_ = 1.0f;
813 transformData.pivotY_ = 1.0f;
814 windowNode->UpdateZoomTransform(transformData, false);
815
816 auto resultValue = windowNode->GetZoomTransform();
817 ASSERT_EQ(1.0f, resultValue.pivotX_);
818 ASSERT_EQ(1.0f, resultValue.pivotY_);
819 }
820 /**
821 * @tc.name: SetTransform01
822 * @tc.desc: SetTransform & ComputeTransform
823 * @tc.type: FUNC
824 */
825 HWTEST_F(WindowNodeTest, SetTransform01, Function | SmallTest | Level1)
826 {
827 std::string windowName = "WindowNode31";
828 auto property = CreateWindowProperty(31, windowName);
829 ASSERT_NE(nullptr, property);
830 sptr<WindowNode> windowNode = new WindowNode(property);
831 ASSERT_NE(nullptr, windowNode);
832
__anon2b9f7fed0202(TransformHelper::Matrix4 expectVal, TransformHelper::Matrix4 checkValue) 833 auto isSameValueMat4 = [](TransformHelper::Matrix4 expectVal, TransformHelper::Matrix4 checkValue) -> bool {
834 uint32_t m = 0, n = 0;
835 for (uint32_t i = 0; i < 16; i++) {
836 m = i / 4;
837 n = i % 4;
838 if (m > 4 || n > 4 || (expectVal.mat_[m][n] != checkValue.mat_[m][n])) {
839 return false;
840 }
841 }
842 return true;
843 };
844
845 Transform transformData;
846 auto defaultTrans = windowNode->property_->trans_;
847 auto defaultWorldTransformMat4 = windowNode->property_->worldTransformMat_;
848 ASSERT_EQ(transformData, defaultTrans);
849 ASSERT_EQ(true, isSameValueMat4(TransformHelper::Matrix4::Identity, defaultWorldTransformMat4));
850
851 transformData.pivotX_ = 1.0f;
852 transformData.pivotY_ = 1.0f;
853 transformData.translateX_ = 1.0f;
854 transformData.translateY_ = 1.0f;
855 windowNode->SetTransform(transformData);
856 windowNode->ComputeTransform();
857
858 auto resultTrans = windowNode->property_->trans_;
859 auto resultWorldTransformMat4 = windowNode->property_->worldTransformMat_;
860 ASSERT_EQ(1.0f, resultTrans.pivotX_);
861 ASSERT_EQ(1.0f, resultTrans.pivotY_);
862
863 ASSERT_EQ(1.0f, resultWorldTransformMat4.mat_[3][0]);
864 ASSERT_EQ(1.0f, resultWorldTransformMat4.mat_[3][1]);
865 }
866 }
867 }
868 }