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