1 /*
2 * Copyright (c) 2023-2023 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 <gmock/gmock.h>
19 #include "parameters.h"
20 #include "ability_context_impl.h"
21 #include "picture_in_picture_controller.h"
22 #include "picture_in_picture_manager.h"
23 #include "window.h"
24 #include "wm_common.h"
25 #include "xcomponent_controller.h"
26
27 using namespace testing;
28 using namespace testing::ext;
29
30 namespace OHOS {
31 namespace Rosen {
32 class MockWindow : public Window {
33 public:
MockWindow()34 MockWindow() {};
~MockWindow()35 ~MockWindow() {};
36 MOCK_METHOD3(Show, WMError(uint32_t reason, bool withAnimation, bool withFocus));
37 MOCK_METHOD0(Destroy, WMError());
38 MOCK_METHOD0(NotifyPrepareClosePiPWindow, WMError());
39 MOCK_METHOD4(SetAutoStartPiP, void(bool isAutoStart, uint32_t priority, uint32_t width, uint32_t height));
40 MOCK_CONST_METHOD0(GetWindowState, WindowState());
41 };
42
43 class MockXComponentController : public XComponentController {
44 public:
MockXComponentController()45 MockXComponentController() {}
~MockXComponentController()46 ~MockXComponentController() {}
47 MOCK_METHOD2(GetGlobalPosition, XComponentControllerErrorCode(float& offsetX, float& offsetY));
48 MOCK_METHOD2(GetSize, XComponentControllerErrorCode(float& width, float& height));
49 MOCK_METHOD1(SetExtController,
50 XComponentControllerErrorCode(std::shared_ptr<XComponentController> xComponentController));
51 MOCK_METHOD1(ResetExtController,
52 XComponentControllerErrorCode(std::shared_ptr<XComponentController> xComponentController));
53 };
54
55 class PictureInPictureControllerTest : public testing::Test {
56 public:
57 static void SetUpTestCase();
58 static void TearDownTestCase();
59 void SetUp() override;
60 void TearDown() override;
61 };
62
SetUpTestCase()63 void PictureInPictureControllerTest::SetUpTestCase() {}
64
TearDownTestCase()65 void PictureInPictureControllerTest::TearDownTestCase() {}
66
SetUp()67 void PictureInPictureControllerTest::SetUp() {}
68
TearDown()69 void PictureInPictureControllerTest::TearDown() {}
70
71 namespace {
72
73 /**
74 * @tc.name: GetPipPriority
75 * @tc.desc: GetPipPriority
76 * @tc.type: FUNC
77 */
78 HWTEST_F(PictureInPictureControllerTest, GetPipPriority, Function | SmallTest | Level2)
79 {
80 auto mw = sptr<MockWindow>::MakeSptr();
81 ASSERT_NE(nullptr, mw);
82 auto option = sptr<PipOption>::MakeSptr();
83 ASSERT_NE(nullptr, option);
84 auto pipControl = sptr<PictureInPictureController>::MakeSptr(option, mw, 100, nullptr);
85 uint32_t pipTypeTemplate = 5;
86 uint32_t testValue = 0;
87 ASSERT_EQ(testValue, pipControl->GetPipPriority(pipTypeTemplate));
88 pipTypeTemplate = 3;
89 ASSERT_EQ(testValue, pipControl->GetPipPriority(pipTypeTemplate));
90 pipTypeTemplate = 0;
91 ASSERT_EQ(testValue, pipControl->GetPipPriority(pipTypeTemplate));
92 pipTypeTemplate = 1;
93 testValue = 1;
94 ASSERT_EQ(testValue, pipControl->GetPipPriority(pipTypeTemplate));
95 }
96
97 /**
98 * @tc.name: ShowPictureInPictureWindow01
99 * @tc.desc: ShowPictureInPictureWindow
100 * @tc.type: FUNC
101 */
102 HWTEST_F(PictureInPictureControllerTest, ShowPictureInPictureWindow01, Function | SmallTest | Level2)
103 {
104 StartPipType startType = StartPipType::NULL_START;
105 sptr<MockWindow> mw = new (std::nothrow) MockWindow();
106 ASSERT_NE(nullptr, mw);
107 sptr<MockWindow> mw1 = new (std::nothrow) MockWindow();
108 ASSERT_NE(nullptr, mw1);
109 sptr<PipOption> option = new (std::nothrow) PipOption();
110 ASSERT_NE(nullptr, option);
111 sptr<PictureInPictureController> pipControl =
112 new (std::nothrow) PictureInPictureController(option, mw, 100, nullptr);
113
114 pipControl->pipOption_ = nullptr;
115 ASSERT_EQ(WMError::WM_ERROR_PIP_CREATE_FAILED, pipControl->ShowPictureInPictureWindow(startType));
116 pipControl->pipOption_ = option;
117
118 pipControl->window_ = nullptr;
119 ASSERT_EQ(WMError::WM_ERROR_PIP_STATE_ABNORMALLY, pipControl->ShowPictureInPictureWindow(startType));
120 pipControl->window_ = mw;
121
122 auto listener = sptr<IPiPLifeCycle>::MakeSptr();
123 ASSERT_NE(nullptr, listener);
124 pipControl->RegisterPiPLifecycle(listener);
125 EXPECT_CALL(*(mw), Show(_, _, _)).Times(1).WillOnce(Return(WMError::WM_DO_NOTHING));
126 ASSERT_EQ(WMError::WM_ERROR_PIP_INTERNAL_ERROR, pipControl->ShowPictureInPictureWindow(startType));
127 EXPECT_CALL(*(mw), Show(_, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
128 ASSERT_EQ(WMError::WM_OK, pipControl->ShowPictureInPictureWindow(startType));
129 EXPECT_CALL(*(mw), Show(_, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
130 startType = StartPipType::AUTO_START;
131 ASSERT_EQ(WMError::WM_OK, pipControl->ShowPictureInPictureWindow(startType));
132 startType = StartPipType::NULL_START;
133 pipControl->pipOption_->SetContentSize(10, 10);
134 EXPECT_CALL(*(mw), Show(_, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
135 ASSERT_EQ(WMError::WM_OK, pipControl->ShowPictureInPictureWindow(startType));
136 pipControl->pipOption_->SetContentSize(0, 10);
137 EXPECT_CALL(*(mw), Show(_, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
138 ASSERT_EQ(WMError::WM_OK, pipControl->ShowPictureInPictureWindow(startType));
139 pipControl->pipOption_->SetContentSize(10, 0);
140 EXPECT_CALL(*(mw), Show(_, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
141 ASSERT_EQ(WMError::WM_OK, pipControl->ShowPictureInPictureWindow(startType));
142 pipControl->pipOption_->SetContentSize(0, 0);
143 EXPECT_CALL(*(mw), Show(_, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
144 ASSERT_EQ(WMError::WM_OK, pipControl->ShowPictureInPictureWindow(startType));
145 }
146
147 /**
148 * @tc.name: StopPictureInPicture01
149 * @tc.desc: StopPictureInPicture
150 * @tc.type: FUNC
151 */
152 HWTEST_F(PictureInPictureControllerTest, StopPictureInPicture01, Function | SmallTest | Level2)
153 {
154 sptr<MockWindow> mw = new (std::nothrow) MockWindow();
155 ASSERT_NE(nullptr, mw);
156 sptr<PipOption> option = new (std::nothrow) PipOption();
157 ASSERT_NE(nullptr, option);
158 sptr<PictureInPictureController> pipControl =
159 new (std::nothrow) PictureInPictureController(option, mw, 100, nullptr);
160
161 pipControl->curState_ = PiPWindowState::STATE_STOPPING;
162 pipControl->isStoppedFromClient_ = true;
163 ASSERT_EQ(WMError::WM_ERROR_PIP_STATE_ABNORMALLY, pipControl->StopPictureInPicture(true, StopPipType::NULL_STOP));
164
165 pipControl->isStoppedFromClient_ = false;
166 ASSERT_EQ(WMError::WM_ERROR_PIP_REPEAT_OPERATION, pipControl->StopPictureInPicture(true, StopPipType::NULL_STOP));
167
168 pipControl->curState_ = PiPWindowState::STATE_STOPPED;
169 ASSERT_EQ(WMError::WM_ERROR_PIP_REPEAT_OPERATION, pipControl->StopPictureInPicture(true, StopPipType::NULL_STOP));
170 pipControl->curState_ = PiPWindowState::STATE_UNDEFINED;
171 ASSERT_EQ(WMError::WM_ERROR_PIP_STATE_ABNORMALLY, pipControl->StopPictureInPicture(false, StopPipType::NULL_STOP));
172
173 pipControl->window_ = nullptr;
174 ASSERT_EQ(WMError::WM_ERROR_PIP_STATE_ABNORMALLY, pipControl->StopPictureInPicture(true, StopPipType::NULL_STOP));
175
176 pipControl->window_ = mw;
177 pipControl->isStoppedFromClient_ = true;
178 pipControl->curState_ = PiPWindowState::STATE_STOPPING;
179 ASSERT_EQ(WMError::WM_OK, pipControl->StopPictureInPicture(false, StopPipType::NULL_STOP));
180
181 pipControl->window_ = mw;
182 pipControl->curState_ = PiPWindowState::STATE_STARTED;
183 ASSERT_EQ(PiPWindowState::STATE_STARTED, pipControl->GetControllerState());
184 ASSERT_EQ(WMError::WM_OK, pipControl->StopPictureInPicture(true, StopPipType::NULL_STOP));
185 ASSERT_NE(PiPWindowState::STATE_STARTED, pipControl->GetControllerState());
186 }
187
188 /**
189 * @tc.name: CreatePictureInPictureWindow
190 * @tc.desc: CreatePictureInPictureWindow
191 * @tc.type: FUNC
192 */
193 HWTEST_F(PictureInPictureControllerTest, CreatePictureInPictureWindow01, Function | SmallTest | Level2)
194 {
195 auto mw = sptr<MockWindow>::MakeSptr();
196 ASSERT_NE(nullptr, mw);
197 auto option = sptr<PipOption>::MakeSptr();
198 ASSERT_NE(nullptr, option);
199 auto pipControl = sptr<PictureInPictureController>::MakeSptr(option, mw, 100, nullptr);
200
201 pipControl->pipOption_ = nullptr;
202 StartPipType startType = StartPipType::AUTO_START;
203 EXPECT_EQ(WMError::WM_ERROR_PIP_CREATE_FAILED, pipControl->CreatePictureInPictureWindow(startType));
204 pipControl->pipOption_ = option;
205 option->SetContext(nullptr);
206 ASSERT_EQ(nullptr, option->GetContext());
207 EXPECT_EQ(WMError::WM_ERROR_PIP_CREATE_FAILED, pipControl->CreatePictureInPictureWindow(startType));
208 AbilityRuntime::AbilityContextImpl* contextPtr = new AbilityRuntime::AbilityContextImpl();
209 option->SetContext(contextPtr);
210 pipControl->mainWindow_ = nullptr;
211 EXPECT_EQ(WMError::WM_ERROR_PIP_CREATE_FAILED, pipControl->CreatePictureInPictureWindow(startType));
212 delete contextPtr;
213 }
214
215 /**
216 * @tc.name: CreatePictureInPictureWindow
217 * @tc.desc: CreatePictureInPictureWindow
218 * @tc.type: FUNC
219 */
220 HWTEST_F(PictureInPictureControllerTest, CreatePictureInPictureWindow02, Function | SmallTest | Level2)
221 {
222 auto mw = sptr<MockWindow>::MakeSptr();
223 ASSERT_NE(nullptr, mw);
224 auto option = sptr<PipOption>::MakeSptr();
225 ASSERT_NE(nullptr, option);
226 auto pipControl = sptr<PictureInPictureController>::MakeSptr(option, mw, 100, nullptr);
227 pipControl->pipOption_ = option;
228 StartPipType startType = StartPipType::AUTO_START;
229 AbilityRuntime::AbilityContextImpl* contextPtr = new AbilityRuntime::AbilityContextImpl();
230 option->SetContext(contextPtr);
231
232 std::shared_ptr<MockXComponentController> xComponentController = std::make_shared<MockXComponentController>();
233 ASSERT_NE(nullptr, xComponentController);
234 pipControl->pipOption_->SetXComponentController(nullptr);
235 pipControl->pipOption_->SetTypeNodeEnabled(false);
236 pipControl->mainWindow_ = nullptr;
237 EXPECT_EQ(WMError::WM_ERROR_PIP_CREATE_FAILED, pipControl->CreatePictureInPictureWindow(startType));
238 pipControl->pipOption_->SetXComponentController(xComponentController);
239 ASSERT_EQ(pipControl->pipOption_->GetXComponentController(), xComponentController);
240 EXPECT_EQ(WMError::WM_ERROR_PIP_CREATE_FAILED, pipControl->CreatePictureInPictureWindow(startType));
241 pipControl->pipOption_->SetXComponentController(nullptr);
242 pipControl->mainWindow_ = mw;
243 EXPECT_EQ(WMError::WM_ERROR_PIP_CREATE_FAILED, pipControl->CreatePictureInPictureWindow(startType));
244 delete contextPtr;
245 }
246
247 /**
248 * @tc.name: CreatePictureInPictureWindow
249 * @tc.desc: CreatePictureInPictureWindow
250 * @tc.type: FUNC
251 */
252 HWTEST_F(PictureInPictureControllerTest, CreatePictureInPictureWindow03, Function | SmallTest | Level2)
253 {
254 auto mw = sptr<MockWindow>::MakeSptr();
255 ASSERT_NE(nullptr, mw);
256 auto option = sptr<PipOption>::MakeSptr();
257 ASSERT_NE(nullptr, option);
258 auto pipControl = sptr<PictureInPictureController>::MakeSptr(option, mw, 100, nullptr);
259 pipControl->pipOption_ = option;
260 AbilityRuntime::AbilityContextImpl* contextPtr = new AbilityRuntime::AbilityContextImpl();
261 option->SetContext(contextPtr);
262 std::shared_ptr<MockXComponentController> xComponentController = std::make_shared<MockXComponentController>();
263 pipControl->pipOption_->SetXComponentController(xComponentController);
264 ASSERT_EQ(pipControl->pipOption_->GetXComponentController(), xComponentController);
265 pipControl->pipOption_->SetTypeNodeEnabled(true);
266 pipControl->mainWindow_ = mw;
267 StartPipType startType = StartPipType::NULL_START;
268 EXPECT_CALL(*(mw), GetWindowState()).Times(2).WillOnce(Return(WindowState::STATE_CREATED));
269 EXPECT_EQ(WMError::WM_ERROR_PIP_CREATE_FAILED, pipControl->CreatePictureInPictureWindow(startType));
270 startType = StartPipType::AUTO_START;
271 delete contextPtr;
272 }
273
274 /**
275 * @tc.name: StartPictureInPicture
276 * @tc.desc: StartPictureInPicture
277 * @tc.type: FUNC
278 */
279 HWTEST_F(PictureInPictureControllerTest, StartPictureInPicture01, Function | SmallTest | Level2)
280 {
281 StartPipType startType = StartPipType::AUTO_START;
282 auto mw = sptr<MockWindow>::MakeSptr();
283 ASSERT_NE(nullptr, mw);
284 auto option = sptr<PipOption>::MakeSptr();
285 ASSERT_NE(nullptr, option);
286 auto pipControl = sptr<PictureInPictureController>::MakeSptr(option, mw, 100, nullptr);
287
288 pipControl->pipOption_ = nullptr;
289 EXPECT_EQ(WMError::WM_ERROR_PIP_CREATE_FAILED, pipControl->StartPictureInPicture(startType));
290 pipControl->pipOption_ = option;
291 option->SetContext(nullptr);
292 ASSERT_EQ(nullptr, option->GetContext());
293 EXPECT_EQ(WMError::WM_ERROR_PIP_CREATE_FAILED, pipControl->StartPictureInPicture(startType));
294 AbilityRuntime::AbilityContextImpl* contextPtr = new AbilityRuntime::AbilityContextImpl();
295 option->SetContext(contextPtr);
296 pipControl->curState_ = PiPWindowState::STATE_STARTING;
297 EXPECT_EQ(WMError::WM_ERROR_PIP_REPEAT_OPERATION, pipControl->StartPictureInPicture(startType));
298 pipControl->curState_ = PiPWindowState::STATE_STARTED;
299 EXPECT_EQ(WMError::WM_ERROR_PIP_REPEAT_OPERATION, pipControl->StartPictureInPicture(startType));
300 delete contextPtr;
301 }
302
303 /**
304 * @tc.name: StartPictureInPicture
305 * @tc.desc: StartPictureInPicture
306 * @tc.type: FUNC
307 */
308 HWTEST_F(PictureInPictureControllerTest, StartPictureInPicture02, Function | SmallTest | Level2)
309 {
310 StartPipType startType = StartPipType::AUTO_START;
311 auto mw = sptr<MockWindow>::MakeSptr();
312 ASSERT_NE(nullptr, mw);
313 auto option = sptr<PipOption>::MakeSptr();
314 ASSERT_NE(nullptr, option);
315 auto pipControl = sptr<PictureInPictureController>::MakeSptr(option, mw, 100, nullptr);
316 pipControl->pipOption_ = option;
317 AbilityRuntime::AbilityContextImpl* contextPtr = new AbilityRuntime::AbilityContextImpl();
318 option->SetContext(contextPtr);
319 pipControl->curState_ = PiPWindowState::STATE_UNDEFINED;
320
321 pipControl->pipOption_->SetNavigationId("navId");
322 pipControl->mainWindow_ = nullptr;
323 EXPECT_EQ(WMError::WM_ERROR_PIP_CREATE_FAILED, pipControl->StartPictureInPicture(startType));
324 pipControl->pipOption_->SetNavigationId("");
325 auto pipControl1 = sptr<PictureInPictureController>::MakeSptr(option, mw, 100, nullptr);
326 auto pipControl2 = sptr<PictureInPictureController>::MakeSptr(option, mw, 200, nullptr);
327 PictureInPictureManager::SetActiveController(pipControl1);
328 PictureInPictureManager::IsActiveController(pipControl2);
329 pipControl->mainWindowId_ = 100;
330 PictureInPictureManager::IsAttachedToSameWindow(100);
331 pipControl->window_ = nullptr;
332 EXPECT_EQ(WMError::WM_ERROR_PIP_CREATE_FAILED, pipControl->StartPictureInPicture(startType));
333 pipControl->window_ = mw;
334 pipControl->pipOption_ = nullptr;
335 EXPECT_EQ(WMError::WM_ERROR_PIP_CREATE_FAILED, pipControl->StartPictureInPicture(startType));
336 pipControl->pipOption_ = option;
337 PictureInPictureManager::RemoveActiveController(pipControl1);
338 PictureInPictureManager::IsActiveController(pipControl);
339 pipControl->StartPictureInPicture(startType);
340 delete contextPtr;
341 }
342
343 /**
344 * @tc.name: StartPictureInPictureInner
345 * @tc.desc: StartPictureInPictureInner
346 * @tc.type: FUNC
347 */
348 HWTEST_F(PictureInPictureControllerTest, StartPictureInPictureInner, Function | SmallTest | Level2)
349 {
350 StartPipType startType = StartPipType::USER_START;
351 auto mw = sptr<MockWindow>::MakeSptr();
352 ASSERT_NE(nullptr, mw);
353 auto option = sptr<PipOption>::MakeSptr();
354 ASSERT_NE(nullptr, option);
355 auto pipControl = sptr<PictureInPictureController>::MakeSptr(option, mw, 100, nullptr);
356 pipControl->pipOption_->SetTypeNodeEnabled(true);
357 ASSERT_NE(WMError::WM_OK, pipControl->StartPictureInPictureInner(startType));
358 }
359
360 /**
361 * @tc.name: StopPictureInPictureFromClient
362 * @tc.desc: StopPictureInPictureFromClient
363 * @tc.type: FUNC
364 */
365 HWTEST_F(PictureInPictureControllerTest, StopPictureInPictureFromClient, Function | SmallTest | Level2)
366 {
367 sptr<MockWindow> mw = new (std::nothrow) MockWindow();
368 ASSERT_NE(nullptr, mw);
369 sptr<MockWindow> mw1 = new (std::nothrow) MockWindow();
370 ASSERT_NE(nullptr, mw1);
371 sptr<PipOption> option = new (std::nothrow) PipOption();
372 ASSERT_NE(nullptr, option);
373 sptr<PictureInPictureController> pipControl =
374 new (std::nothrow) PictureInPictureController(option, mw, 100, nullptr);
375
376 pipControl->window_ = mw1;
377 ASSERT_NE(WMError::WM_ERROR_PIP_STATE_ABNORMALLY, pipControl->StopPictureInPictureFromClient());
378 pipControl->window_ = nullptr;
379 ASSERT_NE(WMError::WM_OK, pipControl->StopPictureInPictureFromClient());
380 pipControl->window_ = mw1;
381 pipControl->curState_ = PiPWindowState::STATE_STOPPING;
382 EXPECT_EQ(WMError::WM_ERROR_PIP_REPEAT_OPERATION, pipControl->StopPictureInPictureFromClient());
383 pipControl->curState_ = PiPWindowState::STATE_STOPPED;
384 EXPECT_EQ(WMError::WM_ERROR_PIP_REPEAT_OPERATION, pipControl->StopPictureInPictureFromClient());
385 pipControl->curState_ = PiPWindowState::STATE_RESTORING;
386 EXPECT_EQ(WMError::WM_ERROR_PIP_REPEAT_OPERATION, pipControl->StopPictureInPictureFromClient());
387 pipControl->curState_ = PiPWindowState::STATE_UNDEFINED;
388 EXPECT_CALL(*(mw1), NotifyPrepareClosePiPWindow()).Times(1).WillOnce(Return(WMError::WM_DO_NOTHING));
389 EXPECT_EQ(WMError::WM_ERROR_PIP_DESTROY_FAILED, pipControl->StopPictureInPictureFromClient());
390 EXPECT_CALL(*(mw1), NotifyPrepareClosePiPWindow()).Times(1).WillOnce(Return(WMError::WM_OK));
391 EXPECT_EQ(WMError::WM_OK, pipControl->StopPictureInPictureFromClient());
392 }
393
394 /**
395 * @tc.name: GetPipWindow
396 * @tc.desc: GetPipWindow/SetPipWindow
397 * @tc.type: FUNC
398 */
399 HWTEST_F(PictureInPictureControllerTest, GetPipWindow, Function | SmallTest | Level2)
400 {
401 sptr<MockWindow> mw = new MockWindow();
402 sptr<PipOption> option = new PipOption();
403 sptr<Window> window_;
404 sptr<Window> window;
405 sptr<PictureInPictureController> pipControl = new PictureInPictureController(option, mw, 100, nullptr);
406
407 pipControl->SetPipWindow(window);
408 auto ret = pipControl->GetPipWindow();
409 ASSERT_EQ(pipControl->window_, ret);
410 }
411
412 /**
413 * @tc.name: SetAutoStartEnabled
414 * @tc.desc: SetAutoStartEnabled
415 * @tc.type: FUNC
416 */
417 HWTEST_F(PictureInPictureControllerTest, SetAutoStartEnabled, Function | SmallTest | Level2)
418 {
419 bool enable = true;
420 sptr<MockWindow> mw = new (std::nothrow) MockWindow();
421 ASSERT_NE(nullptr, mw);
422 sptr<PipOption> option = new (std::nothrow) PipOption();
423 ASSERT_NE(nullptr, option);
424 sptr<PictureInPictureController> pipControl =
425 new (std::nothrow) PictureInPictureController(option, mw, 100, nullptr);
426
427 pipControl->mainWindow_ = nullptr;
428 pipControl->SetAutoStartEnabled(enable);
429 pipControl->mainWindow_ = mw;
430 pipControl->pipOption_ = nullptr;
431 pipControl->SetAutoStartEnabled(enable);
432 pipControl->pipOption_ = option;
433
434 pipControl->isAutoStartEnabled_ = enable;
435 ASSERT_EQ(true, pipControl->isAutoStartEnabled_);
436 pipControl->pipOption_->SetTypeNodeEnabled(true);
437 ASSERT_EQ(true, pipControl->IsTypeNodeEnabled());
438 EXPECT_CALL(*(mw), SetAutoStartPiP(_, _, _, _)).WillRepeatedly(Return());
439 pipControl->SetAutoStartEnabled(enable);
440 enable = false;
441 pipControl->isAutoStartEnabled_ = enable;
442 ASSERT_EQ(false, pipControl->isAutoStartEnabled_);
443 pipControl->pipOption_->SetTypeNodeEnabled(true);
444 ASSERT_EQ(true, pipControl->IsTypeNodeEnabled());
445 EXPECT_CALL(*(mw), SetAutoStartPiP(_, _, _, _)).WillRepeatedly(Return());
446 pipControl->SetAutoStartEnabled(enable);
447 pipControl->pipOption_->SetTypeNodeEnabled(false);
448 ASSERT_EQ(false, pipControl->IsTypeNodeEnabled());
449 EXPECT_CALL(*(mw), SetAutoStartPiP(_, _, _, _)).WillRepeatedly(Return());
450 pipControl->SetAutoStartEnabled(enable);
451 pipControl->pipOption_->SetNavigationId("");
452 ASSERT_EQ("", pipControl->pipOption_->GetNavigationId());
453 pipControl->SetAutoStartEnabled(enable);
454 }
455
456 /**
457 * @tc.name: IsAutoStartEnabled
458 * @tc.desc: IsAutoStartEnabled
459 * @tc.type: FUNC
460 */
461 HWTEST_F(PictureInPictureControllerTest, IsAutoStartEnabled, Function | SmallTest | Level2)
462 {
463 bool enable = true;
464 sptr<MockWindow> mw = new MockWindow();
465 sptr<PipOption> option = new PipOption();
466 sptr<PictureInPictureController> pipControl = new PictureInPictureController(option, mw, 100, nullptr);
467
468 pipControl->IsAutoStartEnabled(enable);
469 auto ret = pipControl->GetControllerState();
470 ASSERT_EQ(PiPWindowState::STATE_UNDEFINED, ret);
471 }
472
473 /**
474 * @tc.name: UpdateContentSize01
475 * @tc.desc: UpdateContentSize
476 * @tc.type: FUNC
477 */
478 HWTEST_F(PictureInPictureControllerTest, UpdateContentSize01, Function | SmallTest | Level2)
479 {
480 sptr<MockWindow> mw = new (std::nothrow) MockWindow();
481 ASSERT_NE(nullptr, mw);
482 sptr<PipOption> option = new (std::nothrow) PipOption();
483 ASSERT_NE(nullptr, option);
484 sptr<PictureInPictureController> pipControl =
485 new (std::nothrow) PictureInPictureController(option, mw, 100, nullptr);
486
487 int32_t width = 0;
488 int32_t height = 0;
489 pipControl->UpdateContentSize(width, height);
490 height = 150;
491 pipControl->UpdateContentSize(width, height);
492 height = 0;
493 width = 100;
494 pipControl->UpdateContentSize(width, height);
495 height = 150;
496 pipControl->UpdateContentSize(width, height);
497
498 pipControl->curState_ = PiPWindowState::STATE_UNDEFINED;
499 pipControl->UpdateContentSize(width, height);
500 pipControl->curState_ = PiPWindowState::STATE_STARTED;
501 pipControl->UpdateContentSize(width, height);
502 }
503
504 /**
505 * @tc.name: UpdateContentSize02
506 * @tc.desc: UpdateContentSize
507 * @tc.type: FUNC
508 */
509 HWTEST_F(PictureInPictureControllerTest, UpdateContentSize02, Function | SmallTest | Level2)
510 {
511 auto mw = sptr<MockWindow>::MakeSptr();
512 ASSERT_NE(nullptr, mw);
513 auto option = sptr<PipOption>::MakeSptr();
514 ASSERT_NE(nullptr, option);
515 std::shared_ptr<MockXComponentController> xComponentController = std::make_shared<MockXComponentController>();
516 ASSERT_NE(nullptr, xComponentController);
517 auto pipControl = sptr<PictureInPictureController>::MakeSptr(option, mw, 100, nullptr);
518
519 pipControl->curState_ = PiPWindowState::STATE_STARTED;
520 pipControl->window_ = nullptr;
521 int32_t width = 10;
522 int32_t height = 20;
523 pipControl->UpdateContentSize(width, height);
524 pipControl->window_ = mw;
525
526 pipControl->pipOption_->SetTypeNodeEnabled(true);
527 ASSERT_EQ(true, pipControl->IsTypeNodeEnabled());
528 pipControl->mainWindowXComponentController_ = xComponentController;
529 pipControl->UpdateContentSize(width, height);
530 pipControl->pipOption_->SetTypeNodeEnabled(false);
531 pipControl->windowRect_ = { 0, 0, 0, 0 };
532 pipControl->IsContentSizeChanged(0, 0, 0, 0);
533 pipControl->UpdateContentSize(width, height);
534 pipControl->IsContentSizeChanged(10, 10, 10, 10);
535 pipControl->UpdateContentSize(width, height);
536 pipControl->mainWindowXComponentController_ = nullptr;
537 pipControl->UpdateContentSize(width, height);
538 }
539
540 /**
541 * @tc.name: UpdatePiPControlStatus
542 * @tc.desc: UpdatePiPControlStatus
543 * @tc.type: FUNC
544 */
545 HWTEST_F(PictureInPictureControllerTest, UpdatePiPControlStatus, Function | SmallTest | Level2)
546 {
547 auto mw = sptr<MockWindow>::MakeSptr();
548 ASSERT_NE(nullptr, mw);
549 auto option = sptr<PipOption>::MakeSptr();
550 ASSERT_NE(nullptr, option);
551 auto pipControl = sptr<PictureInPictureController>::MakeSptr(option, mw, 100, nullptr);
552 auto controlType = PiPControlType::VIDEO_PLAY_PAUSE;
553 auto status = PiPControlStatus::ENABLED;
554 pipControl->UpdatePiPControlStatus(controlType, status);
555 ASSERT_EQ(1, pipControl->pipOption_->GetControlEnable().size());
556 status = PiPControlStatus::PLAY;
557 pipControl->UpdatePiPControlStatus(controlType, status);
558 ASSERT_EQ(1, pipControl->pipOption_->GetControlStatus().size());
559 pipControl->window_ = nullptr;
560 pipControl->UpdatePiPControlStatus(controlType, status);
561 pipControl->window_ = mw;
562 pipControl->UpdatePiPControlStatus(controlType, status);
563 }
564
565 /**
566 * @tc.name: IsContentSizeChanged
567 * @tc.desc: IsContentSizeChanged
568 * @tc.type: FUNC
569 */
570 HWTEST_F(PictureInPictureControllerTest, IsContentSizeChanged, Function | SmallTest | Level2)
571 {
572 sptr<MockWindow> mw = new (std::nothrow) MockWindow();
573 ASSERT_NE(nullptr, mw);
574 sptr<PipOption> option = new (std::nothrow) PipOption();
575 ASSERT_NE(nullptr, option);
576 sptr<PictureInPictureController> pipControl =
577 new (std::nothrow) PictureInPictureController(option, mw, 100, nullptr);
578 pipControl->windowRect_ = { 0, 0, 0, 0 };
579 ASSERT_EQ(true, pipControl->IsContentSizeChanged(10.5, 0, 0, 0));
580 ASSERT_EQ(true, pipControl->IsContentSizeChanged(0, 10.5, 0, 0));
581 ASSERT_EQ(true, pipControl->IsContentSizeChanged(0, 0, 10.5, 0));
582 ASSERT_EQ(true, pipControl->IsContentSizeChanged(0, 0, 0, 10.5));
583 ASSERT_EQ(true, pipControl->IsContentSizeChanged(10.5, 10.5, 0, 0));
584 ASSERT_EQ(true, pipControl->IsContentSizeChanged(10.5, 0, 10.5, 0));
585 ASSERT_EQ(true, pipControl->IsContentSizeChanged(10.5, 0, 0, 10.5));
586 ASSERT_EQ(true, pipControl->IsContentSizeChanged(0, 10.5, 10.5, 0));
587 ASSERT_EQ(true, pipControl->IsContentSizeChanged(0, 10.5, 0, 10.5));
588 ASSERT_EQ(true, pipControl->IsContentSizeChanged(0, 0, 10.5, 10.5));
589 ASSERT_EQ(true, pipControl->IsContentSizeChanged(10.5, 10.5, 10.5, 0));
590 ASSERT_EQ(true, pipControl->IsContentSizeChanged(10.5, 10.5, 0, 10.5));
591 ASSERT_EQ(true, pipControl->IsContentSizeChanged(10.5, 0, 10.5, 10.5));
592 ASSERT_EQ(true, pipControl->IsContentSizeChanged(0, 10.5, 10.5, 10.5));
593 ASSERT_EQ(true, pipControl->IsContentSizeChanged(10.5, 10.5, 10.5, 10.5));
594 ASSERT_EQ(false, pipControl->IsContentSizeChanged(0, 0, 0, 0));
595 }
596
597 /**
598 * @tc.name: DoActionEvent
599 * @tc.desc: DoActionEvent
600 * @tc.type: FUNC
601 */
602 HWTEST_F(PictureInPictureControllerTest, DoActionEvent, Function | SmallTest | Level2)
603 {
604 std::string actionName = "";
605 int32_t status = 0;
606 auto mw = sptr<MockWindow>::MakeSptr();
607 ASSERT_NE(nullptr, mw);
608 auto option = sptr<PipOption>::MakeSptr();
609 ASSERT_NE(nullptr, option);
610 auto pipControl = sptr<PictureInPictureController>::MakeSptr(option, mw, 100, nullptr);
611 sptr<IPiPActionObserver> listener = nullptr;
612
613 pipControl->DoActionEvent(actionName, status);
614 ASSERT_EQ(0, pipControl->pipOption_->GetControlStatus().size());
615 actionName = "nextVideo";
616 pipControl->DoActionEvent(actionName, status);
617 ASSERT_EQ(1, pipControl->pipOption_->GetControlStatus().size());
618 }
619
620 /**
621 * @tc.name: DoControlEvent
622 * @tc.desc: DoControlEvent
623 * @tc.type: FUNC
624 */
625 HWTEST_F(PictureInPictureControllerTest, DoControlEvent, Function | SmallTest | Level2)
626 {
627 auto controlType = PiPControlType::VIDEO_PLAY_PAUSE;
628 auto status = PiPControlStatus::PLAY;
629 auto mw = sptr<MockWindow>::MakeSptr();
630 ASSERT_NE(nullptr, mw);
631 auto option = sptr<PipOption>::MakeSptr();
632 ASSERT_NE(nullptr, option);
633 auto pipControl = sptr<PictureInPictureController>::MakeSptr(option, mw, 100, nullptr);
634 sptr<IPiPControlObserver> listener = nullptr;
635
636 pipControl->pipOption_ = nullptr;
637 pipControl->DoControlEvent(controlType, status);
638 pipControl->pipOption_ = option;
639 pipControl->DoControlEvent(controlType, status);
640 pipControl->RegisterPiPControlObserver(listener);
641 pipControl->DoControlEvent(controlType, status);
642 ASSERT_EQ(1, pipControl->pipOption_->GetControlStatus().size());
643 }
644
645 /**
646 * @tc.name: PreRestorePictureInPicture
647 * @tc.desc: PreRestorePictureInPicture
648 * @tc.type: FUNC
649 */
650 HWTEST_F(PictureInPictureControllerTest, PreRestorePictureInPicture, Function | SmallTest | Level2)
651 {
652 sptr<IPiPLifeCycle> listener = nullptr;
653 auto mw = sptr<MockWindow>::MakeSptr();
654 ASSERT_NE(nullptr, mw);
655 auto option = sptr<PipOption>::MakeSptr();
656 ASSERT_NE(nullptr, option);
657 auto pipControl = sptr<PictureInPictureController>::MakeSptr(option, mw, 100, nullptr);
658 pipControl->curState_ = PiPWindowState::STATE_STARTED;
659 pipControl->RegisterPiPLifecycle(listener);
660 pipControl->PreRestorePictureInPicture();
661 ASSERT_EQ(PiPWindowState::STATE_RESTORING, pipControl->curState_);
662 }
663
664 /**
665 * @tc.name: RestorePictureInPictureWindow
666 * @tc.desc: RestorePictureInPictureWindow
667 * @tc.type: FUNC
668 */
669 HWTEST_F(PictureInPictureControllerTest, RestorePictureInPictureWindow, Function | SmallTest | Level2)
670 {
671 auto mw = sptr<MockWindow>::MakeSptr();
672 ASSERT_NE(nullptr, mw);
673 auto option = sptr<PipOption>::MakeSptr();
674 ASSERT_NE(nullptr, option);
675 auto pipControl = sptr<PictureInPictureController>::MakeSptr(option, mw, 100, nullptr);
676
677 pipControl->curState_ = PiPWindowState::STATE_STARTED;
678 pipControl->window_ = mw;
679 pipControl->RestorePictureInPictureWindow();
680 ASSERT_EQ(PiPWindowState::STATE_STOPPING, pipControl->curState_);
681 }
682
683 /**
684 * @tc.name: UpdateWinRectByComponent
685 * @tc.desc: UpdateWinRectByComponent
686 * @tc.type: FUNC
687 */
688 HWTEST_F(PictureInPictureControllerTest, UpdateWinRectByComponent, Function | SmallTest | Level2)
689 {
690 auto mw = sptr<MockWindow>::MakeSptr();
691 ASSERT_NE(nullptr, mw);
692 auto option = sptr<PipOption>::MakeSptr();
693 ASSERT_NE(nullptr, option);
694 std::shared_ptr<MockXComponentController> xComponentController = std::make_shared<MockXComponentController>();
695 ASSERT_NE(nullptr, xComponentController);
696 auto pipControl = sptr<PictureInPictureController>::MakeSptr(option, mw, 100, nullptr);
697
698 pipControl->pipOption_->SetTypeNodeEnabled(true);
699 pipControl->UpdateWinRectByComponent();
700 ASSERT_EQ(pipControl->windowRect_.width_, 16);
701 ASSERT_EQ(pipControl->windowRect_.height_, 9);
702
703 pipControl->pipOption_->SetTypeNodeEnabled(false);
704 pipControl->mainWindowXComponentController_ = nullptr;
705 pipControl->UpdateWinRectByComponent();
706 pipControl->mainWindowXComponentController_ = xComponentController;
707
708 pipControl->windowRect_.width_ = 0;
709 pipControl->windowRect_.height_ = 10;
710 pipControl->UpdateWinRectByComponent();
711 ASSERT_EQ(pipControl->windowRect_.width_, 0);
712 ASSERT_EQ(pipControl->windowRect_.height_, 0);
713 pipControl->windowRect_.width_ = 10;
714 pipControl->windowRect_.height_ = 0;
715 ASSERT_EQ(pipControl->windowRect_.width_, 10);
716 ASSERT_EQ(pipControl->windowRect_.height_, 0);
717 pipControl->UpdateWinRectByComponent();
718 pipControl->windowRect_.width_ = 0;
719 pipControl->UpdateWinRectByComponent();
720 ASSERT_EQ(pipControl->windowRect_.width_, 0);
721 ASSERT_EQ(pipControl->windowRect_.height_, 0);
722 pipControl->windowRect_.width_ = 10;
723 pipControl->windowRect_.height_ = 10;
724 pipControl->UpdateWinRectByComponent();
725 ASSERT_EQ(pipControl->windowRect_.posX_, 0);
726 ASSERT_EQ(pipControl->windowRect_.posY_, 0);
727 }
728
729 /**
730 * @tc.name: RegisterPiPLifecycle
731 * @tc.desc: RegisterPiPLifecycle/UnregisterPiPLifecycle
732 * @tc.type: FUNC
733 */
734 HWTEST_F(PictureInPictureControllerTest, RegisterListener, Function | SmallTest | Level2)
735 {
736 auto mw = sptr<MockWindow>::MakeSptr();
737 ASSERT_NE(nullptr, mw);
738 auto option = sptr<PipOption>::MakeSptr();
739 ASSERT_NE(nullptr, option);
740 auto pipControl = sptr<PictureInPictureController>::MakeSptr(option, mw, 100, nullptr);
741
742 auto listener = sptr<IPiPLifeCycle>::MakeSptr();
743 ASSERT_NE(nullptr, listener);
744 auto listener1 = sptr<IPiPLifeCycle>::MakeSptr();
745 ASSERT_NE(nullptr, listener1);
746 pipControl->pipLifeCycleListeners_.push_back(listener);
747 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, pipControl->RegisterPiPLifecycle(nullptr));
748 ASSERT_EQ(WMError::WM_OK, pipControl->RegisterPiPLifecycle(listener));
749 ASSERT_EQ(WMError::WM_OK, pipControl->RegisterPiPLifecycle(listener1));
750 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, pipControl->UnregisterPiPLifecycle(nullptr));
751 ASSERT_EQ(WMError::WM_OK, pipControl->UnregisterPiPLifecycle(listener));
752 }
753
754 /**
755 * @tc.name: RegisterPiPActionObserver
756 * @tc.desc: RegisterPiPActionObserver/UnregisterPiPActionObserver
757 * @tc.type: FUNC
758 */
759 HWTEST_F(PictureInPictureControllerTest, RegisterPiPActionObserver, Function | SmallTest | Level2)
760 {
761 auto mw = sptr<MockWindow>::MakeSptr();
762 ASSERT_NE(nullptr, mw);
763 auto option = sptr<PipOption>::MakeSptr();
764 ASSERT_NE(nullptr, option);
765 auto pipControl = sptr<PictureInPictureController>::MakeSptr(option, mw, 100, nullptr);
766
767 auto listener = sptr<IPiPActionObserver>::MakeSptr();
768 ASSERT_NE(nullptr, listener);
769 auto listener1 = sptr<IPiPActionObserver>::MakeSptr();
770 ASSERT_NE(nullptr, listener1);
771 pipControl->pipActionObservers_.push_back(listener);
772 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, pipControl->RegisterPiPActionObserver(nullptr));
773 ASSERT_EQ(WMError::WM_OK, pipControl->RegisterPiPActionObserver(listener));
774 ASSERT_EQ(WMError::WM_OK, pipControl->RegisterPiPActionObserver(listener1));
775 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, pipControl->UnregisterPiPActionObserver(nullptr));
776 ASSERT_EQ(WMError::WM_OK, pipControl->UnregisterPiPActionObserver(listener));
777 }
778
779 /**
780 * @tc.name: RegisterPiPControlObserver
781 * @tc.desc: RegisterPiPControlObserver/UnregisterPiPControlObserver
782 * @tc.type: FUNC
783 */
784 HWTEST_F(PictureInPictureControllerTest, RegisterPiPControlObserver, Function | SmallTest | Level2)
785 {
786 auto mw = sptr<MockWindow>::MakeSptr();
787 ASSERT_NE(nullptr, mw);
788 auto option = sptr<PipOption>::MakeSptr();
789 ASSERT_NE(nullptr, option);
790 auto pipControl = sptr<PictureInPictureController>::MakeSptr(option, mw, 100, nullptr);
791
792 auto listener = sptr<IPiPControlObserver>::MakeSptr();
793 ASSERT_NE(nullptr, listener);
794 auto listener1 = sptr<IPiPControlObserver>::MakeSptr();
795 ASSERT_NE(nullptr, listener1);
796 pipControl->pipControlObservers_.push_back(listener);
797 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, pipControl->RegisterPiPControlObserver(nullptr));
798 ASSERT_EQ(WMError::WM_OK, pipControl->RegisterPiPControlObserver(listener));
799 ASSERT_EQ(WMError::WM_OK, pipControl->RegisterPiPControlObserver(listener1));
800 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, pipControl->UnregisterPiPControlObserver(nullptr));
801 ASSERT_EQ(WMError::WM_OK, pipControl->UnregisterPiPControlObserver(listener));
802 }
803
804 /**
805 * @tc.name: IsPullPiPAndHandleNavigation
806 * @tc.desc: IsPullPiPAndHandleNavigation
807 * @tc.type: FUNC
808 */
809 HWTEST_F(PictureInPictureControllerTest, IsPullPiPAndHandleNavigation, Function | SmallTest | Level2)
810 {
811 sptr<MockWindow> mw = new MockWindow();
812 sptr<PipOption> option = new PipOption();
813 sptr<PictureInPictureController> pipControl = new PictureInPictureController(option, mw, 100, nullptr);
814 pipControl->pipOption_->SetTypeNodeEnabled(true);
815 ASSERT_EQ(true, pipControl->IsPullPiPAndHandleNavigation());
816 pipControl->pipOption_->SetTypeNodeEnabled(false);
817 pipControl->pipOption_->SetNavigationId("");
818 ASSERT_EQ(true, pipControl->IsPullPiPAndHandleNavigation());
819 pipControl->pipOption_->SetNavigationId("navId");
820 pipControl->mainWindow_ = nullptr;
821 ASSERT_EQ(false, pipControl->IsPullPiPAndHandleNavigation());
822 pipControl->mainWindow_ = mw;
823 }
824
825 /**
826 * @tc.name: ResetExtController
827 * @tc.desc: ResetExtController
828 * @tc.type: FUNC
829 */
830 HWTEST_F(PictureInPictureControllerTest, ResetExtController, Function | SmallTest | Level2)
831 {
832 auto mw = sptr<MockWindow>::MakeSptr();
833 ASSERT_NE(nullptr, mw);
834 auto option = sptr<PipOption>::MakeSptr();
835 ASSERT_NE(nullptr, option);
836 std::shared_ptr<MockXComponentController> xComponentController = std::make_shared<MockXComponentController>();
837 ASSERT_NE(nullptr, xComponentController);
838 std::shared_ptr<MockXComponentController> xComponentController1 = std::make_shared<MockXComponentController>();
839 ASSERT_NE(nullptr, xComponentController1);
840 auto pipControl = sptr<PictureInPictureController>::MakeSptr(option, mw, 100, nullptr);
841
842 pipControl->pipOption_->SetTypeNodeEnabled(true);
843 pipControl->ResetExtController();
844 pipControl->pipOption_->SetTypeNodeEnabled(false);
845 pipControl->ResetExtController();
846
847 pipControl->pipXComponentController_ = nullptr;
848 pipControl->mainWindowXComponentController_ = nullptr;
849 pipControl->ResetExtController();
850 pipControl->mainWindowXComponentController_ = nullptr;
851 pipControl->pipXComponentController_ = xComponentController;
852 pipControl->ResetExtController();
853 pipControl->pipXComponentController_ = nullptr;
854 pipControl->mainWindowXComponentController_ = xComponentController1;
855 pipControl->ResetExtController();
856 pipControl->pipXComponentController_ = xComponentController;
857 EXPECT_CALL(*(xComponentController1), ResetExtController(_))
858 .Times(1)
859 .WillOnce(Return(XComponentControllerErrorCode::XCOMPONENT_CONTROLLER_TYPE_ERROR));
860 pipControl->ResetExtController();
861 EXPECT_CALL(*(xComponentController1), ResetExtController(_))
862 .Times(1)
863 .WillOnce(Return(XComponentControllerErrorCode::XCOMPONENT_CONTROLLER_NO_ERROR));
864 pipControl->ResetExtController();
865 }
866
867 /**
868 * @tc.name: OnPictureInPictureStart
869 * @tc.desc: OnPictureInPictureStart
870 * @tc.type: FUNC
871 */
872 HWTEST_F(PictureInPictureControllerTest, OnPictureInPictureStart, Function | SmallTest | Level2)
873 {
874 auto mw = sptr<MockWindow>::MakeSptr();
875 ASSERT_NE(nullptr, mw);
876 auto option = sptr<PipOption>::MakeSptr();
877 ASSERT_NE(nullptr, option);
878 auto pipControl = sptr<PictureInPictureController>::MakeSptr(option, mw, 100, nullptr);
879 pipControl->OnPictureInPictureStart();
880 }
881
882 /**
883 * @tc.name: IsTypeNodeEnabled
884 * @tc.desc: IsTypeNodeEnabled
885 * @tc.type: FUNC
886 */
887 HWTEST_F(PictureInPictureControllerTest, IsTypeNodeEnabled, Function | SmallTest | Level2)
888 {
889 auto mw = sptr<MockWindow>::MakeSptr();
890 ASSERT_NE(nullptr, mw);
891 auto option = sptr<PipOption>::MakeSptr();
892 ASSERT_NE(nullptr, option);
893 auto pipControl = sptr<PictureInPictureController>::MakeSptr(option, mw, 100, nullptr);
894 pipControl->pipOption_->SetTypeNodeEnabled(true);
895 ASSERT_TRUE(pipControl->IsTypeNodeEnabled());
896 pipControl->pipOption_->SetTypeNodeEnabled(false);
897 ASSERT_TRUE(!pipControl->IsTypeNodeEnabled());
898 pipControl->pipOption_ = nullptr;
899 ASSERT_TRUE(!pipControl->IsTypeNodeEnabled());
900 }
901
902 /**
903 * @tc.name: GetTypeNode
904 * @tc.desc: GetTypeNode
905 * @tc.type: FUNC
906 */
907 HWTEST_F(PictureInPictureControllerTest, GetTypeNode, Function | SmallTest | Level2)
908 {
909 auto mw = sptr<MockWindow>::MakeSptr();
910 ASSERT_NE(nullptr, mw);
911 auto option = sptr<PipOption>::MakeSptr();
912 ASSERT_NE(nullptr, option);
913 auto pipControl = sptr<PictureInPictureController>::MakeSptr(option, mw, 100, nullptr);
914 pipControl->pipOption_->SetTypeNodeRef(nullptr);
915 ASSERT_EQ(nullptr, pipControl->GetTypeNode());
916 pipControl->pipOption_ = nullptr;
917 ASSERT_EQ(nullptr, pipControl->GetTypeNode());
918 }
919
920 /**
921 * @tc.name: SetXComponentController
922 * @tc.desc: SetXComponentController
923 * @tc.type: FUNC
924 */
925 HWTEST_F(PictureInPictureControllerTest, SetXComponentController, Function | SmallTest | Level2)
926 {
927 sptr<IPiPLifeCycle> listener = nullptr;
928 std::shared_ptr<MockXComponentController> xComponentController = std::make_shared<MockXComponentController>();
929 ASSERT_NE(nullptr, xComponentController);
930 std::shared_ptr<MockXComponentController> xComponentController1 = std::make_shared<MockXComponentController>();
931 ASSERT_NE(nullptr, xComponentController1);
932 sptr<MockWindow> mw = new MockWindow();
933 sptr<PipOption> option = new PipOption();
934 sptr<PictureInPictureController> pipControl = new PictureInPictureController(option, mw, 100, nullptr);
935 pipControl->pipOption_->SetTypeNodeEnabled(true);
936 ASSERT_EQ(WMError::WM_OK, pipControl->SetXComponentController(xComponentController));
937 pipControl->pipOption_->SetTypeNodeEnabled(false);
938 pipControl->window_ = nullptr;
939 ASSERT_EQ(WMError::WM_ERROR_PIP_STATE_ABNORMALLY, pipControl->SetXComponentController(xComponentController));
940 pipControl->window_ = mw;
941
942 pipControl->pipXComponentController_ = nullptr;
943 pipControl->mainWindowXComponentController_ = nullptr;
944 ASSERT_EQ(WMError::WM_ERROR_PIP_STATE_ABNORMALLY, pipControl->SetXComponentController(xComponentController));
945 pipControl->mainWindowXComponentController_ = nullptr;
946 pipControl->pipXComponentController_ = xComponentController;
947 ASSERT_EQ(WMError::WM_ERROR_PIP_STATE_ABNORMALLY, pipControl->SetXComponentController(xComponentController));
948 pipControl->mainWindowXComponentController_ = xComponentController1;
949 EXPECT_CALL(*(xComponentController1), SetExtController(_))
950 .Times(1)
951 .WillOnce(Return(XComponentControllerErrorCode::XCOMPONENT_CONTROLLER_TYPE_ERROR));
952 ASSERT_EQ(WMError::WM_ERROR_PIP_INTERNAL_ERROR, pipControl->SetXComponentController(xComponentController));
953 EXPECT_CALL(*(xComponentController1), SetExtController(_))
954 .Times(1)
955 .WillOnce(Return(XComponentControllerErrorCode::XCOMPONENT_CONTROLLER_NO_ERROR));
956 ASSERT_EQ(WMError::WM_OK, pipControl->SetXComponentController(xComponentController));
957 }
958
959 /**
960 * @tc.name: RegisterPipContentListenerWithType
961 * @tc.desc: RegisterPipContentListenerWithType
962 * @tc.type: FUNC
963 */
964 HWTEST_F(PictureInPictureControllerTest, RegisterPipContentListenerWithType, Function | SmallTest | Level2)
965 {
966 sptr<MockWindow> mw = new MockWindow();
967 sptr<PipOption> option = new PipOption();
968 sptr<PictureInPictureController> pipControl = new PictureInPictureController(option, mw, 100, nullptr);
969 pipControl->pipOption_ = nullptr;
970 ASSERT_EQ(WMError::WM_ERROR_PIP_STATE_ABNORMALLY,
971 pipControl->RegisterPipContentListenerWithType("nodeUpdate", nullptr));
972 pipControl->pipOption_ = option;
973 ASSERT_EQ(WMError::WM_OK, pipControl->RegisterPipContentListenerWithType("nodeUpdate", nullptr));
974 }
975
976 /**
977 * @tc.name: UnRegisterPipContentListenerWithType
978 * @tc.desc: UnRegisterPipContentListenerWithType
979 * @tc.type: FUNC
980 */
981 HWTEST_F(PictureInPictureControllerTest, UnRegisterPipContentListenerWithType, Function | SmallTest | Level2)
982 {
983 sptr<MockWindow> mw = new MockWindow();
984 sptr<PipOption> option = new PipOption();
985 sptr<PictureInPictureController> pipControl = new PictureInPictureController(option, mw, 100, nullptr);
986 pipControl->pipOption_ = nullptr;
987 ASSERT_EQ(WMError::WM_ERROR_PIP_STATE_ABNORMALLY, pipControl->UnRegisterPipContentListenerWithType("nodeUpdate"));
988 pipControl->pipOption_ = option;
989 ASSERT_EQ(WMError::WM_OK, pipControl->UnRegisterPipContentListenerWithType("nodeUpdate"));
990 }
991
992 /**
993 * @tc.name: GetPipContentCallbackRef
994 * @tc.desc: GetPipContentCallbackRef
995 * @tc.type: FUNC
996 */
997 HWTEST_F(PictureInPictureControllerTest, GetPipContentCallbackRef, Function | SmallTest | Level2)
998 {
999 sptr<MockWindow> mw = new MockWindow();
1000 sptr<PipOption> option = new PipOption();
1001 sptr<PictureInPictureController> pipControl = new PictureInPictureController(option, mw, 100, nullptr);
1002 pipControl->pipOption_ = nullptr;
1003 pipControl->RegisterPipContentListenerWithType("nodeUpdate", nullptr);
1004 ASSERT_EQ(nullptr, pipControl->GetPipContentCallbackRef("nodeUpdate"));
1005 pipControl->pipOption_ = option;
1006 pipControl->RegisterPipContentListenerWithType("nodeUpdate", nullptr);
1007 ASSERT_EQ(nullptr, pipControl->GetPipContentCallbackRef("nodeUpdate"));
1008 }
1009
1010 /**
1011 * @tc.name: UpdateContentNodeRef
1012 * @tc.desc: UpdateContentNodeRef
1013 * @tc.type: FUNC
1014 */
1015 HWTEST_F(PictureInPictureControllerTest, UpdateContentNodeRef, Function | SmallTest | Level2)
1016 {
1017 sptr<MockWindow> mw = new MockWindow();
1018 sptr<PipOption> option = new PipOption();
1019 sptr<PictureInPictureController> pipControl = new PictureInPictureController(option, mw, 100, nullptr);
1020 pipControl->pipOption_ = nullptr;
1021 napi_ref nodeRef = nullptr;
1022 pipControl->UpdateContentNodeRef(nodeRef);
1023 pipControl->pipOption_ = option;
1024 pipControl->pipOption_->SetTypeNodeEnabled(true);
1025 pipControl->UpdateContentNodeRef(nodeRef);
1026 pipControl->pipOption_->SetTypeNodeEnabled(false);
1027 pipControl->UpdateContentNodeRef(nodeRef);
1028 pipControl->isAutoStartEnabled_ = true;
1029 pipControl->UpdateContentNodeRef(nodeRef);
1030 pipControl->isAutoStartEnabled_ = false;
1031 ASSERT_EQ(true, pipControl->IsTypeNodeEnabled());
1032 }
1033
1034 /**
1035 * @tc.name: UpdatePiPSourceRect
1036 * @tc.desc: UpdatePiPSourceRect
1037 * @tc.type: FUNC
1038 */
1039 HWTEST_F(PictureInPictureControllerTest, UpdatePiPSourceRect, Function | SmallTest | Level2)
1040 {
1041 auto mw = sptr<MockWindow>::MakeSptr();
1042 ASSERT_NE(nullptr, mw);
1043 auto option = sptr<PipOption>::MakeSptr();
1044 ASSERT_NE(nullptr, option);
1045 std::shared_ptr<MockXComponentController> xComponentController = std::make_shared<MockXComponentController>();
1046 ASSERT_NE(nullptr, xComponentController);
1047 auto pipControl = sptr<PictureInPictureController>::MakeSptr(option, mw, 100, nullptr);
1048
1049 pipControl->pipOption_->SetTypeNodeEnabled(true);
1050 pipControl->window_ = mw;
1051 pipControl->UpdatePiPSourceRect();
1052 ASSERT_EQ(0, pipControl->windowRect_.posX_);
1053 pipControl->pipOption_->SetTypeNodeEnabled(false);
1054 pipControl->UpdatePiPSourceRect();
1055
1056 pipControl->mainWindowXComponentController_ = nullptr;
1057 pipControl->window_ = mw;
1058 pipControl->UpdatePiPSourceRect();
1059 pipControl->mainWindowXComponentController_ = xComponentController;
1060 pipControl->window_ = nullptr;
1061 pipControl->UpdatePiPSourceRect();
1062 pipControl->mainWindowXComponentController_ = nullptr;
1063 pipControl->UpdatePiPSourceRect();
1064 pipControl->mainWindowXComponentController_ = xComponentController;
1065 pipControl->window_ = mw;
1066 pipControl->UpdatePiPSourceRect();
1067 ASSERT_EQ(0, pipControl->windowRect_.posX_);
1068 ASSERT_EQ(0, pipControl->windowRect_.posY_);
1069 ASSERT_EQ(0, pipControl->windowRect_.width_);
1070 ASSERT_EQ(0, pipControl->windowRect_.height_);
1071 }
1072
1073 /**
1074 * @tc.name: DestroyPictureInPictureWindow
1075 * @tc.desc: DestroyPictureInPictureWindow
1076 * @tc.type: FUNC
1077 */
1078 HWTEST_F(PictureInPictureControllerTest, DestroyPictureInPictureWindow, Function | SmallTest | Level2)
1079 {
1080 sptr<MockWindow> mw = new (std::nothrow) MockWindow();
1081 ASSERT_NE(nullptr, mw);
1082 sptr<PipOption> option = new (std::nothrow) PipOption();
1083 ASSERT_NE(nullptr, option);
1084 sptr<PictureInPictureController> pipControl = sptr<PictureInPictureController>::MakeSptr(option, mw, 100, nullptr);
1085
1086 pipControl->window_ = nullptr;
1087 ASSERT_EQ(WMError::WM_ERROR_PIP_INTERNAL_ERROR, pipControl->DestroyPictureInPictureWindow());
1088
1089 sptr<MockWindow> window = sptr<MockWindow>::MakeSptr();
1090 pipControl->window_ = window;
1091 EXPECT_CALL(*(window), Destroy()).Times(1).WillOnce(Return(WMError::WM_DO_NOTHING));
1092 ASSERT_EQ(WMError::WM_ERROR_PIP_DESTROY_FAILED, pipControl->DestroyPictureInPictureWindow());
1093
1094 EXPECT_CALL(*(window), Destroy()).Times(1).WillOnce(Return(WMError::WM_OK));
1095 pipControl->pipOption_ = nullptr;
1096 pipControl->mainWindow_ = nullptr;
1097 pipControl->window_ = window;
1098 ASSERT_EQ(WMError::WM_OK, pipControl->DestroyPictureInPictureWindow());
1099 pipControl->mainWindow_ = mw;
1100 pipControl->window_ = window;
1101 EXPECT_CALL(*(window), Destroy()).Times(1).WillOnce(Return(WMError::WM_OK));
1102 ASSERT_EQ(WMError::WM_OK, pipControl->DestroyPictureInPictureWindow());
1103 pipControl->pipOption_ = option;
1104 pipControl->pipOption_->SetNavigationId("navId");
1105 pipControl->pipOption_->SetTypeNodeEnabled(false);
1106 pipControl->mainWindow_ = nullptr;
1107 pipControl->window_ = window;
1108 EXPECT_CALL(*(window), Destroy()).Times(1).WillOnce(Return(WMError::WM_OK));
1109 ASSERT_EQ(WMError::WM_OK, pipControl->DestroyPictureInPictureWindow());
1110 pipControl->pipOption_->SetNavigationId("");
1111 pipControl->mainWindow_ = mw;
1112 pipControl->window_ = window;
1113 EXPECT_CALL(*(window), Destroy()).Times(1).WillOnce(Return(WMError::WM_OK));
1114 ASSERT_EQ(WMError::WM_OK, pipControl->DestroyPictureInPictureWindow());
1115 }
1116
1117 /**
1118 * @tc.name: PrepareSource
1119 * @tc.desc: PrepareSource
1120 * @tc.type: FUNC
1121 */
1122 HWTEST_F(PictureInPictureControllerTest, PrepareSource, Function | SmallTest | Level2)
1123 {
1124 auto mw = sptr<MockWindow>::MakeSptr();
1125 ASSERT_NE(nullptr, mw);
1126 auto option = sptr<PipOption>::MakeSptr();
1127 ASSERT_NE(nullptr, option);
1128 auto pipControl = sptr<PictureInPictureController>::MakeSptr(option, mw, 100, nullptr);
1129 ASSERT_NE(nullptr, pipControl);
1130 pipControl->pipOption_->SetTypeNodeEnabled(true);
1131 pipControl->PrepareSource();
1132 pipControl->pipOption_->SetTypeNodeEnabled(false);
1133 pipControl->mainWindow_ = nullptr;
1134 pipControl->PrepareSource();
1135 pipControl->mainWindow_ = mw;
1136 pipControl->pipOption_->SetNavigationId("");
1137 pipControl->PrepareSource();
1138 }
1139
1140 /**
1141 * @tc.name: LocateSource
1142 * @tc.desc: LocateSource
1143 * @tc.type: FUNC
1144 */
1145 HWTEST_F(PictureInPictureControllerTest, LocateSource, Function | SmallTest | Level2)
1146 {
1147 auto mw = sptr<MockWindow>::MakeSptr();
1148 ASSERT_NE(nullptr, mw);
1149 auto option = sptr<PipOption>::MakeSptr();
1150 ASSERT_NE(nullptr, option);
1151 auto pipControl = sptr<PictureInPictureController>::MakeSptr(option, mw, 100, nullptr);
1152 ASSERT_NE(nullptr, pipControl);
1153 pipControl->window_ = nullptr;
1154 pipControl->LocateSource();
1155
1156 pipControl->window_ = mw;
1157 pipControl->LocateSource();
1158 }
1159
1160 /**
1161 * @tc.name: StopPictureInPictureInner
1162 * @tc.desc: StopPictureInPictureInner
1163 * @tc.type: FUNC
1164 */
1165 HWTEST_F(PictureInPictureControllerTest, StopPictureInPictureInner, Function | SmallTest | Level2)
1166 {
1167 auto mw = sptr<MockWindow>::MakeSptr();
1168 ASSERT_NE(nullptr, mw);
1169 auto option = sptr<PipOption>::MakeSptr();
1170 ASSERT_NE(nullptr, option);
1171 auto pipControl = sptr<PictureInPictureController>::MakeSptr(option, mw, 100, nullptr);
1172
1173 pipControl->pipOption_ = nullptr;
1174 pipControl->StopPictureInPictureInner(StopPipType::NULL_STOP, true);
1175 pipControl->pipOption_ = option;
1176 pipControl->window_ = nullptr;
1177 ASSERT_EQ(WMError::WM_ERROR_PIP_INTERNAL_ERROR,
1178 pipControl->StopPictureInPictureInner(StopPipType::NULL_STOP, true));
1179 pipControl->mainWindow_ = mw;
1180 ASSERT_EQ(WMError::WM_ERROR_PIP_INTERNAL_ERROR,
1181 pipControl->StopPictureInPictureInner(StopPipType::NULL_STOP, true));
1182 auto window = sptr<MockWindow>::MakeSptr();
1183 pipControl->window_ = window;
1184 ASSERT_EQ(WMError::WM_OK, pipControl->StopPictureInPictureInner(StopPipType::NULL_STOP, true));
1185 ASSERT_EQ(WMError::WM_OK, pipControl->StopPictureInPictureInner(StopPipType::NULL_STOP, false));
1186 }
1187
1188 /**
1189 * @tc.name: GetPipPossible
1190 * @tc.desc: GetPipPossible
1191 * @tc.type: FUNC
1192 */
1193 HWTEST_F(PictureInPictureControllerTest, GetPipPossible, Function | SmallTest | Level2)
1194 {
1195 auto mw = sptr<MockWindow>::MakeSptr();
1196 ASSERT_NE(nullptr, mw);
1197 auto option = sptr<PipOption>::MakeSptr();
1198 ASSERT_NE(nullptr, option);
1199 auto pipControl = sptr<PictureInPictureController>::MakeSptr(option, mw, 100, nullptr);
1200
1201 const std::string multiWindowUIType = system::GetParameter("const.window.multiWindowUIType", "");
1202 bool isDeviceSupported = multiWindowUIType == "HandsetSmartWindow" || multiWindowUIType == "TabletSmartWindow";
1203
1204 bool pipSupported = false;
1205 pipControl->pipOption_ = option;
1206 pipControl->GetPipPossible(pipSupported);
1207 ASSERT_EQ(isDeviceSupported, pipSupported);
1208 }
1209 } // namespace
1210 } // namespace Rosen
1211 } // namespace OHOS