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