1 /*
2 * Copyright (c) 2025 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 "ability_context_impl.h"
19 #include "common_test_utils.h"
20 #include "extension_data_handler.h"
21 #include "iremote_object_mocker.h"
22 #include "mock_ability_context_impl.h"
23 #include "mock_session.h"
24 #include "mock_uicontent.h"
25 #include "mock_window_adapter.h"
26 #include "parameters.h"
27 #include "singleton_mocker.h"
28 #include "window_scene_session_impl.h"
29
30 using namespace testing;
31 using namespace testing::ext;
32
33 namespace OHOS {
34 namespace Rosen {
35 using Mocker = SingletonMocker<WindowAdapter, MockWindowAdapter>;
36 uint32_t MaxWith = 32;
37
38 class WindowSceneSessionImplAnimationTest : public testing::Test {
39 public:
40 static void SetUpTestCase();
41 static void TearDownTestCase();
42 void SetUp() override;
43 void TearDown() override;
44
45 std::shared_ptr<AbilityRuntime::AbilityContext> abilityContext_;
46 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
47
48 private:
49 RSSurfaceNode::SharedPtr CreateRSSurfaceNode();
50 static constexpr uint32_t WAIT_SYNC_IN_NS = 200000;
51 };
52
SetUpTestCase()53 void WindowSceneSessionImplAnimationTest::SetUpTestCase() {}
54
TearDownTestCase()55 void WindowSceneSessionImplAnimationTest::TearDownTestCase() {}
56
SetUp()57 void WindowSceneSessionImplAnimationTest::SetUp()
58 {
59 abilityContext_ = std::make_shared<AbilityRuntime::AbilityContextImpl>();
60 }
61
TearDown()62 void WindowSceneSessionImplAnimationTest::TearDown()
63 {
64 usleep(WAIT_SYNC_IN_NS);
65 abilityContext_ = nullptr;
66 }
67
CreateRSSurfaceNode()68 RSSurfaceNode::SharedPtr WindowSceneSessionImplAnimationTest::CreateRSSurfaceNode()
69 {
70 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
71 rsSurfaceNodeConfig.SurfaceNodeName = "startingWindowTestSurfaceNode";
72 auto surfaceNode = RSSurfaceNode::Create(rsSurfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
73 return surfaceNode;
74 }
75
76 namespace {
77 /**
78 * @tc.name: SetShadowRadius01
79 * @tc.desc: SetShadowRadius01 test
80 * @tc.type: FUNC
81 */
82 HWTEST_F(WindowSceneSessionImplAnimationTest, SetShadowRadius01, TestSize.Level1)
83 {
84 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
85 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
86 window->property_->SetWindowName("SetShadowRadius01");
87 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
88
89 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetShadowRadius(-1.0));
90 ASSERT_EQ(WMError::WM_OK, window->SetShadowRadius(0.0));
91 ASSERT_EQ(WMError::WM_OK, window->SetShadowRadius(1.0));
92 window->surfaceNode_ = nullptr;
93 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->SetShadowRadius(1.0));
94 }
95
96 /**
97 * @tc.name: SetShadowRadius02
98 * @tc.desc: SetShadowRadius02
99 * @tc.type: FUNC
100 */
101 HWTEST_F(WindowSceneSessionImplAnimationTest, SetShadowRadius02, TestSize.Level1)
102 {
103 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
104 option->SetWindowName("SetShadowRadius02");
105 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
106
107 windowSceneSessionImpl->surfaceNode_ = nullptr;
108 auto ret = windowSceneSessionImpl->SetShadowRadius(1.0f);
109 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
110 ret = windowSceneSessionImpl->SetShadowOffsetY(1.0f);
111 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
112
113 Transform trans;
114 windowSceneSessionImpl->hostSession_ = nullptr;
115 ret = windowSceneSessionImpl->SetTransform(trans);
116 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
117 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
118 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
119 windowSceneSessionImpl->property_->SetPersistentId(1);
120 windowSceneSessionImpl->hostSession_ = session;
121 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
122 ret = windowSceneSessionImpl->SetTransform(trans);
123 EXPECT_EQ(WMError::WM_OK, ret);
124 }
125
126 /**
127 * @tc.name: SetShadowColor
128 * @tc.desc: SetShadowColor test
129 * @tc.type: FUNC
130 */
131 HWTEST_F(WindowSceneSessionImplAnimationTest, SetShadowColor, TestSize.Level1)
132 {
133 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
134 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
135 window->property_->SetWindowName("SetShadowColor");
136 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
137
138 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetShadowColor("111ff22ee44"));
139 ASSERT_EQ(WMError::WM_OK, window->SetShadowColor("#ff22ee44"));
140 ASSERT_EQ(WMError::WM_OK, window->SetShadowColor("#000999"));
141 window->surfaceNode_ = nullptr;
142 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->SetShadowColor("#ff22ee44"));
143 }
144
145 /**
146 * @tc.name: SetShadowOffsetX01
147 * @tc.desc: SetShadowOffsetX01 test
148 * @tc.type: FUNC
149 */
150 HWTEST_F(WindowSceneSessionImplAnimationTest, SetShadowOffsetX01, TestSize.Level1)
151 {
152 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
153 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
154 window->property_->SetWindowName("SetShadowOffsetX01");
155 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
156
157 ASSERT_EQ(WMError::WM_OK, window->SetShadowOffsetX(1.0));
158 window->surfaceNode_ = nullptr;
159 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->SetShadowOffsetX(1.0));
160 }
161
162 /**
163 * @tc.name: SetShadowOffsetX02
164 * @tc.desc: SetShadowOffsetX02
165 * @tc.type: FUNC
166 */
167 HWTEST_F(WindowSceneSessionImplAnimationTest, SetShadowOffsetX02, TestSize.Level1)
168 {
169 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
170 option->SetWindowName("SetShadowOffsetX02");
171 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
172
173 auto ret = windowSceneSessionImpl->SetShadowOffsetX(1.0f);
174 EXPECT_EQ(WMError::WM_OK, ret);
175 std::string color = "#ff22ee44";
176 ret = windowSceneSessionImpl->SetShadowColor(color);
177 EXPECT_EQ(WMError::WM_OK, ret);
178 }
179
180 /**
181 * @tc.name: SetShadowOffsetY
182 * @tc.desc: SetShadowOffsetY test
183 * @tc.type: FUNC
184 */
185 HWTEST_F(WindowSceneSessionImplAnimationTest, SetShadowOffsetY, TestSize.Level1)
186 {
187 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
188 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
189 window->property_->SetWindowName("SetShadowOffsetY");
190 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
191
192 ASSERT_EQ(WMError::WM_OK, window->SetShadowOffsetY(1.0));
193 window->surfaceNode_ = nullptr;
194 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->SetShadowOffsetY(1.0));
195 }
196
197 /**
198 * @tc.name: SetWindowShadowRadius
199 * @tc.desc: SetWindowShadowRadius
200 * @tc.type: FUNC
201 */
202 HWTEST_F(WindowSceneSessionImplAnimationTest, SetWindowShadowRadius, TestSize.Level1)
203 {
204 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
205 option->SetWindowName("SetWindowShadowRadius");
206 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
207 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetWindowShadowRadius(0.0f));
208 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
209 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
210 window->property_->SetPersistentId(1);
211 window->hostSession_ = session;
212
213 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
214 window->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
215
216 window->surfaceNode_ = nullptr;
217 auto ret = window->SetWindowShadowRadius(1.0f);
218 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
219
220 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
221 window->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
222 ret = window->SetWindowShadowRadius(1.0f);
223 EXPECT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, ret);
224
225 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
226 window->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
227 ret = window->SetWindowShadowRadius(1.0f);
228 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
229
230 window->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
231 auto surfaceNodeMocker = CreateRSSurfaceNode();
232 ASSERT_NE(nullptr, surfaceNodeMocker);
233 window->surfaceNode_ = surfaceNodeMocker;
234 ret = window->SetWindowShadowRadius(-1.0f);
235 EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret);
236
237 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
238 ret = window->SetWindowShadowRadius(1.0f);
239 EXPECT_EQ(WMError::WM_OK, ret);
240
241 const std::string feature = "large_screen";
242 std::string deviceType = OHOS::system::GetParameter("const.product.devicetype", "");
243 auto context = std::make_shared<MockAbilityContextImpl>();
244 window->context_ = context;
245 context->hapModuleInfo_ = std::make_shared<AppExecFwk::HapModuleInfo>();
246 context->hapModuleInfo_->requiredDeviceFeatures = {{deviceType, {feature}}};
247 ret = window->SetWindowShadowRadius(1.0f);
248 EXPECT_EQ(WMError::WM_OK, ret);
249 }
250
251 /**
252 * @tc.name: SetCornerRadius
253 * @tc.desc: SetCornerRadius test
254 * @tc.type: FUNC
255 */
256 HWTEST_F(WindowSceneSessionImplAnimationTest, SetCornerRadius, TestSize.Level1)
257 {
258 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
259 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
260 window->property_->SetWindowName("SetCornerRadius");
261 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
262
263 ASSERT_EQ(WMError::WM_OK, window->SetCornerRadius(1.0));
264 window->surfaceNode_ = nullptr;
265 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->SetCornerRadius(1.0));
266 }
267
268 /**
269 * @tc.name: SetWindowCornerRadius
270 * @tc.desc: SetWindowCornerRadius
271 * @tc.type: FUNC
272 */
273 HWTEST_F(WindowSceneSessionImplAnimationTest, SetWindowCornerRadius, TestSize.Level1)
274 {
275 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
276 option->SetWindowName("SetWindowCornerRadius");
277 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
278 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetWindowCornerRadius(0.0f));
279 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
280 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
281 window->property_->SetPersistentId(1);
282 window->hostSession_ = session;
283
284 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
285 window->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
286 auto ret = window->SetWindowCornerRadius(1.0f);
287 EXPECT_EQ(WMError::WM_OK, ret);
288
289 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
290 window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
291 ret = window->SetWindowCornerRadius(1.0f);
292 EXPECT_EQ(WMError::WM_OK, ret);
293 ret = window->SetWindowCornerRadius(-1.0f);
294 EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret);
295
296 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
297 window->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
298 ret = window->SetWindowCornerRadius(1.0f);
299 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
300
301 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
302 window->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
303 ret = window->SetWindowCornerRadius(1.0f);
304 EXPECT_EQ(WMError::WM_OK, ret);
305
306 window->windowSystemConfig_.windowUIType_ = WindowUIType::INVALID_WINDOW;
307 window->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
308 ret = window->SetWindowCornerRadius(1.0f);
309 EXPECT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, ret);
310
311 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
312 window->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
313 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
314 ret = window->SetWindowCornerRadius(1.0f);
315 EXPECT_EQ(WMError::WM_OK, ret);
316 }
317
318 /**
319 * @tc.name: GetWindowCornerRadius
320 * @tc.desc: GetWindowCornerRadius
321 * @tc.type: FUNC
322 */
323 HWTEST_F(WindowSceneSessionImplAnimationTest, GetWindowCornerRadius, TestSize.Level1)
324 {
325 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
326 option->SetWindowName("GetWindowCornerRadius");
327 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
328 float cornerRadius = 0.0f;
329 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->GetWindowCornerRadius(cornerRadius));
330
331 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
332 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
333 window->hostSession_ = session;
334 window->state_ = WindowState::STATE_CREATED;
335 ASSERT_NE(nullptr, window->property_);
336 window->property_->SetPersistentId(1);
337 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
338 window->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
339 window->property_->SetWindowCornerRadius(WINDOW_CORNER_RADIUS_INVALID);
340 window->windowSystemConfig_.defaultCornerRadius_ = WINDOW_CORNER_RADIUS_INVALID;
341 auto ret = window->GetWindowCornerRadius(cornerRadius);
342 EXPECT_EQ(WMError::WM_OK, ret);
343 EXPECT_EQ(0.0f, cornerRadius);
344
345 window->windowSystemConfig_.defaultCornerRadius_ = 1.0f; // 1.0f is valid default corner radius
346 ret = window->GetWindowCornerRadius(cornerRadius);
347 EXPECT_EQ(WMError::WM_OK, ret);
348 EXPECT_EQ(window->windowSystemConfig_.defaultCornerRadius_, cornerRadius);
349
350 window->property_->SetWindowCornerRadius(1.0f); // 1.0f is valid window corner radius
351 ret = window->GetWindowCornerRadius(cornerRadius);
352 EXPECT_EQ(WMError::WM_OK, ret);
353 EXPECT_EQ(1.0f, cornerRadius); // 1.0f is valid window corner radius
354
355 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
356 window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
357 ret = window->GetWindowCornerRadius(cornerRadius);
358 EXPECT_EQ(WMError::WM_OK, ret);
359 EXPECT_EQ(1.0f, cornerRadius); // 1.0f is valid window corner radius
360
361 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
362 window->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
363 ret = window->GetWindowCornerRadius(cornerRadius);
364 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
365
366 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
367 window->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
368 ret = window->GetWindowCornerRadius(cornerRadius);
369 EXPECT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, ret);
370
371 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
372 window->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
373 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
374 ret = window->GetWindowCornerRadius(cornerRadius);
375 EXPECT_EQ(WMError::WM_OK, ret);
376 EXPECT_EQ(1.0f, cornerRadius); // 1.0f is valid window corner radius
377 }
378
379 /**
380 * @tc.name: SetBlur01
381 * @tc.desc: SetBlur01 test
382 * @tc.type: FUNC
383 */
384 HWTEST_F(WindowSceneSessionImplAnimationTest, SetBlur01, TestSize.Level1)
385 {
386 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
387 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
388 window->property_->SetWindowName("SetBlur01");
389
390 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetBlur(-1.0));
391 ASSERT_EQ(WMError::WM_OK, window->SetBlur(1.0));
392 ASSERT_EQ(WMError::WM_OK, window->SetBlur(0.0));
393 window->surfaceNode_ = nullptr;
394 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->SetBlur(1.0));
395 }
396
397 /**
398 * @tc.name: SetBlur02
399 * @tc.desc: SetBlur02
400 * @tc.type: FUNC
401 */
402 HWTEST_F(WindowSceneSessionImplAnimationTest, SetBlur02, TestSize.Level1)
403 {
404 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
405 option->SetWindowName("SetBlur02");
406 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
407
408 windowSceneSessionImpl->surfaceNode_ = nullptr;
409 auto ret = windowSceneSessionImpl->SetBlur(1.0f);
410 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
411 ret = windowSceneSessionImpl->SetBackdropBlur(1.0f);
412 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
413 ret = windowSceneSessionImpl->SetBackdropBlurStyle(WindowBlurStyle::WINDOW_BLUR_OFF);
414 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
415 }
416
417 /**
418 * @tc.name: SetBackdropBlur
419 * @tc.desc: SetBackdropBlur test
420 * @tc.type: FUNC
421 */
422 HWTEST_F(WindowSceneSessionImplAnimationTest, SetBackdropBlur, TestSize.Level1)
423 {
424 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
425 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
426 window->property_->SetWindowName("SetBackdropBlur");
427 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
428
429 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetBackdropBlur(-1.0));
430 ASSERT_EQ(WMError::WM_OK, window->SetBackdropBlur(1.0));
431 ASSERT_EQ(WMError::WM_OK, window->SetBackdropBlur(0.0));
432 window->surfaceNode_ = nullptr;
433 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->SetBackdropBlur(1.0));
434 }
435
436 /**
437 * @tc.name: SetBackdropBlurStyle
438 * @tc.desc: SetBackdropBlurStyle test
439 * @tc.type: FUNC
440 */
441 HWTEST_F(WindowSceneSessionImplAnimationTest, SetBackdropBlurStyle, TestSize.Level1)
442 {
443 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
444 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
445 window->property_->SetWindowName("SetBackdropBlurStyle");
446 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
447 window->property_->SetDisplayId(3);
448
449 ASSERT_EQ(WMError::WM_OK, window->SetBackdropBlurStyle(WindowBlurStyle::WINDOW_BLUR_OFF));
450 window->Destroy(true);
451 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetBackdropBlurStyle(WindowBlurStyle::WINDOW_BLUR_THICK));
452 window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
453 window->surfaceNode_ = nullptr;
454 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->SetBackdropBlurStyle(WindowBlurStyle::WINDOW_BLUR_OFF));
455 }
456
457 /**
458 * @tc.name: SetAlpha01
459 * @tc.desc: SetAlpha
460 * @tc.type: FUNC
461 */
462 HWTEST_F(WindowSceneSessionImplAnimationTest, SetAlpha01, TestSize.Level1)
463 {
464 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
465 option->SetWindowName("SetAlpha01");
466 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
467 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
468 windowSceneSession->property_->SetPersistentId(11);
469 windowSceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
470 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, windowSceneSession->SetAlpha(1.0));
471 }
472
473 /**
474 * @tc.name: SetAlpha02
475 * @tc.desc: SetAlpha
476 * @tc.type: FUNC
477 */
478 HWTEST_F(WindowSceneSessionImplAnimationTest, SetAlpha02, TestSize.Level1)
479 {
480 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
481 option->SetWindowName("SetAlpha02");
482 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
483 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
484
485 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestMode", "CreateTestAbility"};
486 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
487 windowSceneSession->hostSession_ = session;
488 windowSceneSession->property_->SetPersistentId(1);
489 windowSceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
490 ASSERT_EQ(WMError::WM_OK, windowSceneSession->SetAlpha(1.0));
491 }
492
493 /**
494 * @tc.name: SetTransform01
495 * @tc.desc: set transform
496 * @tc.type: FUNC
497 * @tc.require:issueI7IJVV
498 */
499 HWTEST_F(WindowSceneSessionImplAnimationTest, SetTransform01, TestSize.Level1)
500 {
501 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
502 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
503 option->SetWindowName("SetTransform01");
504 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
505 window->property_->SetPersistentId(1);
506 Transform trans_;
507 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetTransform(trans_));
508 }
509
510 /**
511 * @tc.name: SetTransform02
512 * @tc.desc: set transform
513 * @tc.type: FUNC
514 */
515 HWTEST_F(WindowSceneSessionImplAnimationTest, SetTransform02, TestSize.Level1)
516 {
517 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
518 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
519 option->SetWindowName("SetTransform02");
520 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
521
522 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
523 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
524 window->hostSession_ = session;
525 window->property_->SetPersistentId(1);
526 window->state_ = WindowState::STATE_CREATED;
527 Transform trans_;
528 ASSERT_EQ(WMError::WM_OK, window->SetTransform(trans_));
529 ASSERT_EQ(trans_, window->GetTransform());
530 }
531
532 /**
533 * @tc.name: SyncShadowsToComponent
534 * @tc.desc: SyncShadowsToComponent
535 * @tc.type: FUNC
536 */
537 HWTEST_F(WindowSceneSessionImplAnimationTest, SyncShadowsToComponent, TestSize.Level1)
538 {
539 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
540 option->SetWindowName("SyncShadowsToComponent");
541 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
542
543 ShadowsInfo shadowsInfo = { 20.0, "#FF0000", 0.0, 0.0, true, true, true, true };
544 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SyncShadowsToComponent(shadowsInfo));
545
546 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
547 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
548 window->property_->SetPersistentId(1);
549 window->hostSession_ = session;
550
551 auto ret = window->SyncShadowsToComponent(shadowsInfo);
552 EXPECT_EQ(WMError::WM_OK, ret);
553 }
554 } // namespace
555 } // namespace Rosen
556 } // namespace OHOS