1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <transaction/rs_transaction.h>
18 #include "iremote_object_mocker.h"
19 #include "mock_RSIWindowAnimationController.h"
20 #include "remote_animation.h"
21 #include "starting_window.h"
22 #include "window_helper.h"
23 #include "window_transition_info.h"
24 using namespace testing;
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace Rosen {
29 class StartingWindowTest : public testing::Test {
30 public:
31 static void SetUpTestCase();
32 static void TearDownTestCase();
33 void SetUp() override;
34 void TearDown() override;
35
36 sptr<WindowProperty> CreateWindowProperty();
37 private:
38 static sptr<WindowTransitionInfo> transitionInfo_;
39 RSSurfaceNode::SharedPtr CreateRSSurfaceNode();
40 static sptr<RSIWindowAnimationController> animationController_;
41 static sptr<WindowNode> node_;
42 };
43
44 sptr<WindowTransitionInfo> StartingWindowTest::transitionInfo_ = nullptr;
45 sptr<RSIWindowAnimationController> StartingWindowTest::animationController_ = nullptr;
46 sptr<WindowNode> StartingWindowTest::node_ = nullptr;
47
SetUpTestCase()48 void StartingWindowTest::SetUpTestCase()
49 {
50 }
51
TearDownTestCase()52 void StartingWindowTest::TearDownTestCase()
53 {
54 }
55
SetUp()56 void StartingWindowTest::SetUp()
57 {
58 transitionInfo_ = new WindowTransitionInfo();
59 animationController_ = new RSIWindowAnimationControllerMocker();
60 ASSERT_EQ(WMError::WM_OK, RemoteAnimation::SetWindowAnimationController(animationController_));
61 transitionInfo_->supportWindowModes_ = {
62 AppExecFwk::SupportWindowMode::FULLSCREEN,
63 AppExecFwk::SupportWindowMode::SPLIT,
64 AppExecFwk::SupportWindowMode::FLOATING
65 };
66 node_ = StartingWindow::CreateWindowNode(transitionInfo_, 101); // 101 is windowId
67 node_->SetWindowRect({0, 0, 100, 100});
68 }
69
TearDown()70 void StartingWindowTest::TearDown()
71 {
72 transitionInfo_ = nullptr;
73 node_ = nullptr;
74 }
75
CreateRSSurfaceNode()76 RSSurfaceNode::SharedPtr StartingWindowTest::CreateRSSurfaceNode()
77 {
78 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
79 rsSurfaceNodeConfig.SurfaceNodeName = "startingWindowTestSurfaceNode";
80 auto surfaceNode = RSSurfaceNode::Create(rsSurfaceNodeConfig);
81 return surfaceNode;
82 }
83
CreateWindowProperty()84 sptr<WindowProperty> StartingWindowTest::CreateWindowProperty()
85 {
86 sptr<WindowProperty> property = new WindowProperty();
87 return property;
88 }
89 namespace {
90 /**
91 * @tc.name: NeedToStopStartingWindow01
92 * @tc.desc: stop starting window test without main App window
93 * @tc.type: FUNC
94 */
95 HWTEST_F(StartingWindowTest, NeedToStopStartingWindow01, Function | SmallTest | Level2)
96 {
97 transitionInfo_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
98 sptr<WindowNode> node = new WindowNode(CreateWindowProperty());
99 ASSERT_EQ(true, WindowHelper::CheckSupportWindowMode(node->GetWindowMode(),
100 node->GetModeSupportInfo(), transitionInfo_));
101 }
102
103 /**
104 * @tc.name: NeedToStopStartingWindow02
105 * @tc.desc: need to stop starting window test with unsupport mode
106 * @tc.type: FUNC
107 */
108 HWTEST_F(StartingWindowTest, NeedToStopStartingWindow02, Function | SmallTest | Level2)
109 {
110 sptr<WindowNode> node = new WindowNode(CreateWindowProperty());
111 node->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
112 node->SetModeSupportInfo(WindowModeSupport::WINDOW_MODE_SUPPORT_FLOATING);
113 ASSERT_EQ(false, WindowHelper::CheckSupportWindowMode(node->GetWindowMode(),
114 node->GetModeSupportInfo(), transitionInfo_));
115 }
116
117 /**
118 * @tc.name: NeedToStopStartingWindow03
119 * @tc.desc: need to stop starting window test with support mode
120 * @tc.type: FUNC
121 */
122 HWTEST_F(StartingWindowTest, NeedToStopStartingWindow03, Function | SmallTest | Level2)
123 {
124 sptr<WindowNode> node = new WindowNode(CreateWindowProperty());
125 ASSERT_EQ(true, WindowHelper::CheckSupportWindowMode(node->GetWindowMode(),
126 node->GetModeSupportInfo(), transitionInfo_));
127 }
128
129 /**
130 * @tc.name: NeedToStopStartingWindow04
131 * @tc.desc: need to stop starting window test with support mode
132 * @tc.type: FUNC
133 */
134 HWTEST_F(StartingWindowTest, NeedToStopStartingWindow04, Function | SmallTest | Level2)
135 {
136 sptr<WindowNode> node = new WindowNode(CreateWindowProperty());
137 transitionInfo_->SetShowFlagWhenLocked(true);
138 node->SetModeSupportInfo(WindowModeSupport::WINDOW_MODE_SUPPORT_SPLIT_PRIMARY |
139 WindowModeSupport::WINDOW_MODE_SUPPORT_SPLIT_SECONDARY);
140 ASSERT_EQ(false, WindowHelper::CheckSupportWindowMode(node->GetWindowMode(),
141 node->GetModeSupportInfo(), transitionInfo_));
142 }
143
144 /**
145 * @tc.name: CreateWindowNode01
146 * @tc.desc: create starting window node test
147 * @tc.type: FUNC
148 */
149 HWTEST_F(StartingWindowTest, CreateWindowNode01, Function | SmallTest | Level2)
150 {
151 sptr<WindowTransitionInfo> info = nullptr;
152 ASSERT_EQ(nullptr, StartingWindow::CreateWindowNode(info, 0));
153 }
154
155 /**
156 * @tc.name: CreateWindowNode02
157 * @tc.desc: create starting window node test
158 * @tc.type: FUNC
159 */
160 HWTEST_F(StartingWindowTest, CreateWindowNode02, Function | SmallTest | Level2)
161 {
162 transitionInfo_->SetWindowMode(WindowMode::WINDOW_MODE_UNDEFINED);
163 sptr<WindowNode> node = StartingWindow::CreateWindowNode(transitionInfo_, 0);
164 ASSERT_NE(nullptr, node);
165 ASSERT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, node->GetWindowMode());
166 }
167
168 /**
169 * @tc.name: CreateWindowNode03
170 * @tc.desc: create starting window node test
171 * @tc.type: FUNC
172 */
173 HWTEST_F(StartingWindowTest, CreateWindowNode03, Function | SmallTest | Level2)
174 {
175 transitionInfo_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
176 sptr<WindowNode> node = StartingWindow::CreateWindowNode(transitionInfo_, 0);
177 ASSERT_NE(nullptr, node);
178 ASSERT_EQ(WindowMode::WINDOW_MODE_FLOATING, node->GetWindowMode());
179 }
180
181 /**
182 * @tc.name: CreateWindowNode04
183 * @tc.desc: create starting window node test
184 * @tc.type: FUNC
185 */
186 HWTEST_F(StartingWindowTest, CreateWindowNode04, Function | SmallTest | Level2)
187 {
188 transitionInfo_->SetShowFlagWhenLocked(true);
189 sptr<WindowNode> node = StartingWindow::CreateWindowNode(transitionInfo_, 0);
190 ASSERT_NE(nullptr, node);
191 }
192
193 /**
194 * @tc.name: DrawStartingWindow01
195 * @tc.desc: draw starting window node
196 * @tc.type: FUNC
197 */
198 HWTEST_F(StartingWindowTest, DrawStartingWindow01, Function | SmallTest | Level2)
199 {
200 std::shared_ptr<Media::PixelMap> pixelMap = std::make_shared<Media::PixelMap>();
201 sptr<WindowNode> node = nullptr;
202 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, StartingWindow::DrawStartingWindow(node, pixelMap, 0x00FFFFFF, true));
203 }
204
205 /**
206 * @tc.name: DrawStartingWindow02
207 * @tc.desc: draw starting window node
208 * @tc.type: FUNC
209 */
210 HWTEST_F(StartingWindowTest, DrawStartingWindow02, Function | SmallTest | Level2)
211 {
212 node_->leashWinSurfaceNode_ = nullptr;
213 std::shared_ptr<Media::PixelMap> pixelMap = std::make_shared<Media::PixelMap>();
214 ASSERT_EQ(WMError::WM_OK, StartingWindow::DrawStartingWindow(node_, pixelMap, 0x00FFFFFF, true));
215 }
216
217 /**
218 * @tc.name: DrawStartingWindow03
219 * @tc.desc: draw starting window node
220 * @tc.type: FUNC
221 */
222 HWTEST_F(StartingWindowTest, DrawStartingWindow03, Function | SmallTest | Level2)
223 {
224 std::shared_ptr<Media::PixelMap> pixelMap = std::make_shared<Media::PixelMap>();
225 ASSERT_EQ(WMError::WM_OK, StartingWindow::DrawStartingWindow(node_, pixelMap, 0x00FFFFFF, false));
226 }
227
228 /**
229 * @tc.name: DrawStartingWindow04
230 * @tc.desc: draw starting window node
231 * @tc.type: FUNC
232 */
233 HWTEST_F(StartingWindowTest, DrawStartingWindow04, Function | SmallTest | Level2)
234 {
235 node_->startingWinSurfaceNode_ = nullptr;
236 std::shared_ptr<Media::PixelMap> pixelMap = std::make_shared<Media::PixelMap>();
237 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, StartingWindow::DrawStartingWindow(node_, pixelMap, 0x00FFFFFF, true));
238 }
239
240 /**
241 * @tc.name: DrawStartingWindow05
242 * @tc.desc: draw starting window node
243 * @tc.type: FUNC
244 */
245 HWTEST_F(StartingWindowTest, DrawStartingWindow05, Function | SmallTest | Level2)
246 {
247 ASSERT_EQ(WMError::WM_OK, StartingWindow::DrawStartingWindow(node_, nullptr, 0x00FFFFFF, true));
248 }
249
250 /**
251 * @tc.name: DrawStartingWindow06
252 * @tc.desc: draw starting window node
253 * @tc.type: FUNC
254 */
255 HWTEST_F(StartingWindowTest, DrawStartingWindow06, Function | SmallTest | Level2)
256 {
257 std::shared_ptr<Media::PixelMap> pixelMap = std::make_shared<Media::PixelMap>();
258 ASSERT_EQ(WMError::WM_OK, StartingWindow::DrawStartingWindow(node_, pixelMap, 0x00FFFFFF, true));
259 }
260
261 /**
262 * @tc.name: HandleClientWindowCreateAndRelease01
263 * @tc.desc: handle client window create
264 * @tc.type: FUNC
265 */
266 HWTEST_F(StartingWindowTest, HandleClientWindowCreateAndRelease01, Function | SmallTest | Level2)
267 {
268 sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
269 sptr<IWindow> iWindow = iface_cast<IWindow>(iRemoteObjectMocker);
270 ASSERT_NE(nullptr, iWindow);
271 uint32_t windowId = 0;
272 auto surfaceNode = CreateRSSurfaceNode();
273 ASSERT_NE(nullptr, surfaceNode);
274 sptr<WindowProperty> windowProperty = new WindowProperty();
275 StartingWindow::HandleClientWindowCreate(node_, iWindow, windowId, surfaceNode, windowProperty, 0, 0);
276 ASSERT_EQ(node_->GetWindowId(), windowId);
277 StartingWindow::ReleaseStartWinSurfaceNode(node_);
278 }
279
280 /**
281 * @tc.name: HandleClientWindowCreate02
282 * @tc.desc: handle client window create
283 * @tc.type: FUNC
284 */
285 HWTEST_F(StartingWindowTest, HandleClientWindowCreate02, Function | SmallTest | Level2)
286 {
287 sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
288 sptr<IWindow> iWindow = iface_cast<IWindow>(iRemoteObjectMocker);
289 ASSERT_NE(nullptr, iWindow);
290 uint32_t windowId = 0;
291 auto surfaceNode = CreateRSSurfaceNode();
292 ASSERT_NE(nullptr, surfaceNode);
293 sptr<WindowProperty> windowProperty = new WindowProperty();
294 sptr<WindowNode> node = nullptr;
295 StartingWindow::HandleClientWindowCreate(node, iWindow, windowId, surfaceNode, windowProperty, 0, 0);
296 }
297
298 /**
299 * @tc.name: HandleClientWindowCreateAndRelease03
300 * @tc.desc: handle client window create and Release with null leashNode
301 * @tc.type: FUNC
302 */
303 HWTEST_F(StartingWindowTest, HandleClientWindowCreateAndRelease03, Function | SmallTest | Level2)
304 {
305 node_->leashWinSurfaceNode_ = nullptr;
306 uint32_t windowId = 0;
307 auto surfaceNode = CreateRSSurfaceNode();
308 ASSERT_NE(nullptr, surfaceNode);
309 sptr<WindowProperty> windowProperty = new WindowProperty();
310 sptr<IWindow> iWindow = nullptr;
311 StartingWindow::HandleClientWindowCreate(node_, iWindow, windowId, surfaceNode, windowProperty, 0, 0);
312 StartingWindow::ReleaseStartWinSurfaceNode(node_);
313 }
314
315 /**
316 * @tc.name: AddNodeOnRSTree01
317 * @tc.desc: Add node on rs tree test with surfaceNode nullptr and hot start
318 * @tc.type: FUNC
319 */
320 HWTEST_F(StartingWindowTest, AddNodeOnRSTree01, Function | SmallTest | Level2)
321 {
322 sptr<RSIWindowAnimationController> testController = nullptr;
323 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, RemoteAnimation::SetWindowAnimationController(testController));
324 AnimationConfig config;
325 StartingWindow::AddNodeOnRSTree(node_, config, true);
326 ASSERT_EQ(WMError::WM_OK, StartingWindow::DrawStartingWindow(node_, nullptr, 0x66FFFFFF, false));
327 usleep(200000);
328 }
329
330 /**
331 * @tc.name: AddNodeOnRSTree02
332 * @tc.desc: Add node on rs tree test with hot start and surfaceNode
333 * @tc.type: FUNC
334 */
335 HWTEST_F(StartingWindowTest, AddNodeOnRSTree02, Function | SmallTest | Level2)
336 {
337 auto surfaceNode = CreateRSSurfaceNode();
338 ASSERT_NE(nullptr, surfaceNode);
339 node_->surfaceNode_ = surfaceNode;
340 sptr<RSIWindowAnimationController> testController = nullptr;
341 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, RemoteAnimation::SetWindowAnimationController(testController));
342 AnimationConfig config;
343 StartingWindow::AddNodeOnRSTree(node_, config, true);
344 ASSERT_EQ(WMError::WM_OK, StartingWindow::DrawStartingWindow(node_, nullptr, 0x66FFFFFF, false));
345 usleep(200000);
346 }
347
348 /**
349 * @tc.name: AddNodeOnRSTree03
350 * @tc.desc: Add node on rs tree test
351 * @tc.type: FUNC
352 */
353 HWTEST_F(StartingWindowTest, AddNodeOnRSTree03, Function | SmallTest | Level2)
354 {
355 auto surfaceNode = CreateRSSurfaceNode();
356 ASSERT_NE(nullptr, surfaceNode);
357 node_->surfaceNode_ = surfaceNode;
358 node_->leashWinSurfaceNode_ = nullptr;
359 sptr<RSIWindowAnimationController> testController = nullptr;
360 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, RemoteAnimation::SetWindowAnimationController(testController));
361 AnimationConfig config;
362 StartingWindow::AddNodeOnRSTree(node_, config, true);
363 ASSERT_EQ(WMError::WM_OK, StartingWindow::DrawStartingWindow(node_, nullptr, 0x66FFFFFF, false));
364 usleep(200000);
365 }
366
367 /**
368 * @tc.name: AddNodeOnRSTree04
369 * @tc.desc: Add node on rs tree test with surfaceNode nullptr, with animation controller
370 * @tc.type: FUNC
371 */
372 HWTEST_F(StartingWindowTest, AddNodeOnRSTree04, Function | SmallTest | Level2)
373 {
374 sptr<RSIWindowAnimationController> testController = new RSIWindowAnimationControllerMocker();
375 ASSERT_EQ(WMError::WM_OK, RemoteAnimation::SetWindowAnimationController(testController));
376 AnimationConfig config;
377 StartingWindow::AddNodeOnRSTree(node_, config, true);
378 ASSERT_EQ(WMError::WM_OK, StartingWindow::DrawStartingWindow(node_, nullptr, 0x66FFFFFF, false));
379 usleep(200000);
380 }
381
382 /**
383 * @tc.name: AddNodeOnRSTree05
384 * @tc.desc: Add node on rs tree test
385 * @tc.type: FUNC
386 */
387 HWTEST_F(StartingWindowTest, AddNodeOnRSTree05, Function | SmallTest | Level2)
388 {
389 auto surfaceNode = CreateRSSurfaceNode();
390 ASSERT_NE(nullptr, surfaceNode);
391 node_->surfaceNode_ = surfaceNode;
392 sptr<RSIWindowAnimationController> testController = new RSIWindowAnimationControllerMocker();
393 ASSERT_EQ(WMError::WM_OK, RemoteAnimation::SetWindowAnimationController(testController));
394 AnimationConfig config;
395 StartingWindow::AddNodeOnRSTree(node_, config, true);
396 ASSERT_EQ(WMError::WM_OK, StartingWindow::DrawStartingWindow(node_, nullptr, 0x66FFFFFF, false));
397 usleep(200000);
398 }
399
400 /**
401 * @tc.name: AddNodeOnRSTree06
402 * @tc.desc: Add node on rs tree test
403 * @tc.type: FUNC
404 */
405 HWTEST_F(StartingWindowTest, AddNodeOnRSTree06, Function | SmallTest | Level2)
406 {
407 auto surfaceNode = CreateRSSurfaceNode();
408 ASSERT_NE(nullptr, surfaceNode);
409 node_->surfaceNode_ = surfaceNode;
410 node_->leashWinSurfaceNode_ = nullptr;
411 sptr<RSIWindowAnimationController> testController = new RSIWindowAnimationControllerMocker();
412 ASSERT_EQ(WMError::WM_OK, RemoteAnimation::SetWindowAnimationController(testController));
413 AnimationConfig config;
414 StartingWindow::AddNodeOnRSTree(node_, config, true);
415 ASSERT_EQ(WMError::WM_OK, StartingWindow::DrawStartingWindow(node_, nullptr, 0x66FFFFFF, false));
416 usleep(200000);
417 }
418 }
419 }
420 }
421