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