1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include <gtest/gtest.h>
16
17 #include <gmock/gmock.h>
18 #include "parameters.h"
19 #include "oh_window_pip.h"
20
21 #include "oh_window_comm.h"
22 #include "web_picture_in_picture_controller_interface.h"
23 #include "window_manager_hilog.h"
24 using namespace testing;
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace Rosen {
29 class OHWindowPipTest : public testing::Test {
30 public:
31 static void SetUpTestCase();
32 static void TearDownTestCase();
33 void SetUp() override;
34 void TearDown() override;
35 PictureInPicture_PipConfig pipConfig;
36 uint32_t mainWindowId = 100;
37 uint32_t width = 100;
38 uint32_t height = 150;
39 PictureInPicture_PipTemplateType pipTemplateType = PictureInPicture_PipTemplateType::VIDEO_PLAY;
40 PictureInPicture_PipControlType pipControlType = PictureInPicture_PipControlType::VIDEO_PLAY_PAUSE;
41 PictureInPicture_PipControlStatus pipControlStatus = PictureInPicture_PipControlStatus::PAUSE;
42 PictureInPicture_PipControlGroup controlGroup[1] = {
43 PictureInPicture_PipControlGroup::VIDEO_PLAY_VIDEO_PREVIOUS_NEXT };
44 uint8_t controlGroupLength = 1;
45 int num = 0;
46 napi_env env = reinterpret_cast<napi_env>(&num);
47 };
48
SetUpTestCase()49 void OHWindowPipTest::SetUpTestCase()
50 {
51 }
52
TearDownTestCase()53 void OHWindowPipTest::TearDownTestCase()
54 {
55 }
56
SetUp()57 void OHWindowPipTest::SetUp()
58 {
59 OH_PictureInPicture_CreatePipConfig(&pipConfig);
60 OH_PictureInPicture_SetPipMainWindowId(pipConfig, 100);
61 OH_PictureInPicture_SetPipTemplateType(pipConfig, PictureInPicture_PipTemplateType::VIDEO_PLAY);
62 OH_PictureInPicture_SetPipRect(pipConfig, 100, 150);
63 OH_PictureInPicture_SetPipControlGroup(pipConfig, controlGroup, 1);
64 OH_PictureInPicture_SetPipNapiEnv(pipConfig, env);
65 }
66
TearDown()67 void OHWindowPipTest::TearDown()
68 {
69 OH_PictureInPicture_DestroyPipConfig(&pipConfig);
70 }
71
PipStartPipCallback(uint32_t controllerId,uint8_t requestId,uint64_t surfaceId)72 void PipStartPipCallback(uint32_t controllerId, uint8_t requestId, uint64_t surfaceId)
73 {
74 }
75
PipLifeCycleCallback(uint32_t controllerId,PictureInPicture_PipState state,int32_t errorCode)76 void PipLifeCycleCallback(uint32_t controllerId, PictureInPicture_PipState state, int32_t errorCode)
77 {
78 }
79
PipControlEventCallback(uint32_t controllerId,PictureInPicture_PipControlType controlType,PictureInPicture_PipControlStatus status)80 void PipControlEventCallback(uint32_t controllerId, PictureInPicture_PipControlType controlType,
81 PictureInPicture_PipControlStatus status)
82 {
83 }
84
PipResizeCallback(uint32_t controllerId,uint32_t width,uint32_t height,double scale)85 void PipResizeCallback(uint32_t controllerId, uint32_t width, uint32_t height, double scale)
86 {
87 }
88
89 namespace {
90 /**
91 * @tc.name: OH_PictureInPicture_CreatePipConfig
92 * @tc.desc: OH_PictureInPicture_CreatePipConfig
93 * @tc.type: FUNC
94 */
95 HWTEST_F(OHWindowPipTest, OH_PictureInPicture_CreatePipConfig, TestSize.Level1)
96 {
97 PictureInPicture_PipConfig config;
98 int32_t ret = OH_PictureInPicture_CreatePipConfig(nullptr);
99 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
100 ret = OH_PictureInPicture_CreatePipConfig(&config);
101 EXPECT_EQ(ret, WindowManager_ErrorCode::OK);
102 OH_PictureInPicture_DestroyPipConfig(&config);
103 }
104
105 /**
106 * @tc.name: OH_PictureInPicture_DestroyPipConfig
107 * @tc.desc: OH_PictureInPicture_DestroyPipConfig
108 * @tc.type: FUNC
109 */
110 HWTEST_F(OHWindowPipTest, OH_PictureInPicture_DestroyPipConfig, TestSize.Level1)
111 {
112 PictureInPicture_PipConfig config;
113 int32_t ret = OH_PictureInPicture_DestroyPipConfig(nullptr);
114 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
115 ret = OH_PictureInPicture_CreatePipConfig(&config);
116 EXPECT_EQ(ret, WindowManager_ErrorCode::OK);
117 ret = OH_PictureInPicture_DestroyPipConfig(&config);
118 EXPECT_EQ(ret, WindowManager_ErrorCode::OK);
119 }
120
121 /**
122 * @tc.name: OH_PictureInPicture_SetPipMainWindowId
123 * @tc.desc: OH_PictureInPicture_SetPipMainWindowId
124 * @tc.type: FUNC
125 */
126 HWTEST_F(OHWindowPipTest, OH_PictureInPicture_SetPipMainWindowId, TestSize.Level1)
127 {
128 int32_t ret = OH_PictureInPicture_SetPipMainWindowId(pipConfig, mainWindowId);
129 EXPECT_EQ(ret, WindowManager_ErrorCode::OK);
130 ret = OH_PictureInPicture_SetPipMainWindowId(nullptr, mainWindowId);
131 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
132 }
133
134 /**
135 * @tc.name: OH_PictureInPicture_SetPipTemplateType
136 * @tc.desc: OH_PictureInPicture_SetPipTemplateType
137 * @tc.type: FUNC
138 */
139 HWTEST_F(OHWindowPipTest, OH_PictureInPicture_SetPipTemplateType, TestSize.Level1)
140 {
141 int32_t ret = OH_PictureInPicture_SetPipTemplateType(pipConfig, pipTemplateType);
142 EXPECT_EQ(ret, WindowManager_ErrorCode::OK);
143 ret = OH_PictureInPicture_SetPipTemplateType(nullptr, pipTemplateType);
144 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
145 }
146
147 /**
148 * @tc.name: OH_PictureInPicture_SetPipRect
149 * @tc.desc: OH_PictureInPicture_SetPipRect
150 * @tc.type: FUNC
151 */
152 HWTEST_F(OHWindowPipTest, OH_PictureInPicture_SetPipRect, TestSize.Level1)
153 {
154 int32_t ret = OH_PictureInPicture_SetPipRect(pipConfig, 10, 10);
155 EXPECT_EQ(ret, WindowManager_ErrorCode::OK);
156 ret = OH_PictureInPicture_SetPipRect(nullptr, 10, 10);
157 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
158 }
159
160 /**
161 * @tc.name: OH_PictureInPicture_SetPipControlGroup
162 * @tc.desc: OH_PictureInPicture_SetPipControlGroup
163 * @tc.type: FUNC
164 */
165 HWTEST_F(OHWindowPipTest, OH_PictureInPicture_SetPipControlGroup, TestSize.Level1)
166 {
167 int32_t ret = OH_PictureInPicture_SetPipControlGroup(pipConfig, controlGroup, controlGroupLength);
168 EXPECT_EQ(ret, WindowManager_ErrorCode::OK);
169 ret = OH_PictureInPicture_SetPipControlGroup(pipConfig, nullptr, 0);
170 EXPECT_EQ(ret, WindowManager_ErrorCode::OK);
171 ret = OH_PictureInPicture_SetPipControlGroup(nullptr, controlGroup, controlGroupLength);
172 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
173 }
174
175 /**
176 * @tc.name: OH_PictureInPicture_SetPipNapiEnv
177 * @tc.desc: OH_PictureInPicture_SetPipNapiEnv
178 * @tc.type: FUNC
179 */
180 HWTEST_F(OHWindowPipTest, OH_PictureInPicture_SetPipNapiEnv, TestSize.Level1)
181 {
182 int32_t ret = OH_PictureInPicture_SetPipNapiEnv(pipConfig, nullptr);
183 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
184 ret = OH_PictureInPicture_SetPipNapiEnv(nullptr, env);
185 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
186 ret = OH_PictureInPicture_SetPipNapiEnv(nullptr, nullptr);
187 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
188 ret = OH_PictureInPicture_SetPipNapiEnv(pipConfig, env);
189 EXPECT_EQ(ret, WindowManager_ErrorCode::OK);
190 }
191
192 /**
193 * @tc.name: OH_PictureInPicture_CreatePip
194 * @tc.desc: OH_PictureInPicture_CreatePip
195 * @tc.type: FUNC
196 */
197 HWTEST_F(OHWindowPipTest, OH_PictureInPicture_CreatePip, TestSize.Level1)
198 {
199 uint32_t pipControllerId_ = 0;
200 int32_t ret = OH_PictureInPicture_CreatePip(pipConfig, &pipControllerId_);
201 EXPECT_EQ(ret, WindowManager_ErrorCode::OK);
202 ret = OH_PictureInPicture_CreatePip(nullptr, &pipControllerId_);
203 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
204 ret = OH_PictureInPicture_CreatePip(nullptr, nullptr);
205 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
206 ret = OH_PictureInPicture_CreatePip(pipConfig, nullptr);
207 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
208 OH_PictureInPicture_SetPipRect(pipConfig, 0, 0);
209 ret = OH_PictureInPicture_CreatePip(pipConfig, &pipControllerId_);
210 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
211 OH_PictureInPicture_DeletePip(pipControllerId_);
212 }
213
214 /**
215 * @tc.name: OH_PictureInPicture_DeletePip
216 * @tc.desc: OH_PictureInPicture_DeletePip
217 * @tc.type: FUNC
218 */
219 HWTEST_F(OHWindowPipTest, OH_PictureInPicture_DeletePip, TestSize.Level1)
220 {
221 uint32_t pipControllerId_ = 0;
222 auto ret = OH_PictureInPicture_CreatePip(pipConfig, &pipControllerId_);
223 EXPECT_EQ(WindowManager_ErrorCode::OK, ret);
224 ret = OH_PictureInPicture_DeletePip(pipControllerId_);
225 EXPECT_EQ(WindowManager_ErrorCode::OK, ret);
226 ret = OH_PictureInPicture_DeletePip(pipControllerId_);
227 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
228 }
229
230 /**
231 * @tc.name: OH_PictureInPicture_StartPip
232 * @tc.desc: OH_PictureInPicture_StartPip
233 * @tc.type: FUNC
234 */
235 HWTEST_F(OHWindowPipTest, OH_PictureInPicture_StartPip, TestSize.Level1)
236 {
237 uint32_t pipControllerId_ = 0;
238 auto ret = OH_PictureInPicture_CreatePip(pipConfig, &pipControllerId_);
239 EXPECT_EQ(WindowManager_ErrorCode::OK, ret);
240 ret = OH_PictureInPicture_StartPip(10000);
241 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
242 ret = OH_PictureInPicture_StartPip(pipControllerId_);
243 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_PIP_CREATE_FAILED);
244 OH_PictureInPicture_DeletePip(pipControllerId_);
245 }
246
247 /**
248 * @tc.name: OH_PictureInPicture_StopPip
249 * @tc.desc: OH_PictureInPicture_StopPip
250 * @tc.type: FUNC
251 */
252 HWTEST_F(OHWindowPipTest, OH_PictureInPicture_StopPip, TestSize.Level1)
253 {
254 uint32_t pipControllerId_ = 0;
255 auto ret = OH_PictureInPicture_CreatePip(pipConfig, &pipControllerId_);
256 EXPECT_EQ(WindowManager_ErrorCode::OK, ret);
257 ret = OH_PictureInPicture_StopPip(pipControllerId_);
258 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_PIP_STATE_ABNORMAL);
259 ret = OH_PictureInPicture_StartPip(pipControllerId_);
260 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_PIP_CREATE_FAILED);
261 ret = OH_PictureInPicture_StopPip(pipControllerId_);
262 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_PIP_STATE_ABNORMAL);
263 ret = OH_PictureInPicture_StopPip(10000);
264 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
265 OH_PictureInPicture_DeletePip(pipControllerId_);
266 }
267
268 /**
269 * @tc.name: OH_PictureInPicture_UpdatePipContentSize
270 * @tc.desc: OH_PictureInPicture_UpdatePipContentSize
271 * @tc.type: FUNC
272 */
273 HWTEST_F(OHWindowPipTest, OH_PictureInPicture_UpdatePipContentSize, TestSize.Level1)
274 {
275 uint32_t pipControllerId_ = 0;
276 auto ret = OH_PictureInPicture_UpdatePipContentSize(10000, 50, 100);
277 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
278 OH_PictureInPicture_CreatePip(pipConfig, &pipControllerId_);
279 ret = OH_PictureInPicture_UpdatePipContentSize(pipControllerId_, 50, 100);
280 EXPECT_EQ(WindowManager_ErrorCode::OK, ret);
281 OH_PictureInPicture_DeletePip(pipControllerId_);
282 }
283
284 /**
285 * @tc.name: OH_PictureInPicture_UpdatePipControlStatus
286 * @tc.desc: OH_PictureInPicture_UpdatePipControlStatus
287 * @tc.type: FUNC
288 */
289 HWTEST_F(OHWindowPipTest, OH_PictureInPicture_UpdatePipControlStatus, TestSize.Level1)
290 {
291 uint32_t pipControllerId_ = 0;
292 auto ret = OH_PictureInPicture_UpdatePipControlStatus(10000, pipControlType, pipControlStatus);
293 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
294 OH_PictureInPicture_CreatePip(pipConfig, &pipControllerId_);
295 PictureInPicture_PipControlType type = static_cast<PictureInPicture_PipControlType>(10);
296 PictureInPicture_PipControlStatus status = static_cast<PictureInPicture_PipControlStatus>(2);
297 ret = OH_PictureInPicture_UpdatePipControlStatus(pipControllerId_, type, pipControlStatus);
298 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
299 ret = OH_PictureInPicture_UpdatePipControlStatus(pipControllerId_, type, status);
300 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
301 ret = OH_PictureInPicture_UpdatePipControlStatus(pipControllerId_, pipControlType, status);
302 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
303 ret = OH_PictureInPicture_UpdatePipControlStatus(pipControllerId_, pipControlType, pipControlStatus);
304 EXPECT_EQ(ret, WindowManager_ErrorCode::OK);
305 OH_PictureInPicture_DeletePip(pipControllerId_);
306 }
307
308 /**
309 * @tc.name: OH_PictureInPicture_SetPipControlEnabled
310 * @tc.desc: OH_PictureInPicture_SetPipControlEnabled
311 * @tc.type: FUNC
312 */
313 HWTEST_F(OHWindowPipTest, OH_PictureInPicture_SetPipControlEnabled, TestSize.Level1)
314 {
315 uint32_t pipControllerId_ = 0;
316 auto ret = OH_PictureInPicture_SetPipControlEnabled(10000, pipControlType, false);
317 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
318 OH_PictureInPicture_CreatePip(pipConfig, &pipControllerId_);
319 PictureInPicture_PipControlType type = static_cast<PictureInPicture_PipControlType>(10);
320 ret = OH_PictureInPicture_SetPipControlEnabled(pipControllerId_, type, false);
321 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
322 ret = OH_PictureInPicture_SetPipControlEnabled(pipControllerId_, pipControlType, false);
323 EXPECT_EQ(ret, WindowManager_ErrorCode::OK);
324 OH_PictureInPicture_DeletePip(pipControllerId_);
325 }
326
327 /**
328 * @tc.name: OH_PictureInPicture_RegisterStartPipCallback
329 * @tc.desc: OH_PictureInPicture_RegisterStartPipCallback
330 * @tc.type: FUNC
331 */
332 HWTEST_F(OHWindowPipTest, OH_PictureInPicture_RegisterStartPipCallback, TestSize.Level1)
333 {
334 auto ret = OH_PictureInPicture_RegisterStartPipCallback(10000, PipStartPipCallback);
335 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
336 uint32_t pipControllerId_ = 0;
337 ret = OH_PictureInPicture_CreatePip(pipConfig, &pipControllerId_);
338 EXPECT_EQ(WindowManager_ErrorCode::OK, ret);
339 ret = OH_PictureInPicture_RegisterStartPipCallback(pipControllerId_, PipStartPipCallback);
340 EXPECT_EQ(ret, WindowManager_ErrorCode::OK);
341 OH_PictureInPicture_DeletePip(pipControllerId_);
342 }
343
344 /**
345 * @tc.name: OH_PictureInPicture_UnregisterStartPipCallback
346 * @tc.desc: OH_PictureInPicture_UnregisterStartPipCallback
347 * @tc.type: FUNC
348 */
349 HWTEST_F(OHWindowPipTest, OH_PictureInPicture_UnregisterStartPipCallback, TestSize.Level1)
350 {
351 uint32_t pipControllerId_ = 0;
352 auto ret = OH_PictureInPicture_CreatePip(pipConfig, &pipControllerId_);
353 EXPECT_EQ(WindowManager_ErrorCode::OK, ret);
354 ret = OH_PictureInPicture_UnregisterStartPipCallback(pipControllerId_ + 1, PipStartPipCallback);
355 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
356 ret = OH_PictureInPicture_UnregisterStartPipCallback(pipControllerId_, nullptr);
357 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
358 ret = OH_PictureInPicture_UnregisterStartPipCallback(pipControllerId_, PipStartPipCallback);
359 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
360 OH_PictureInPicture_RegisterStartPipCallback(pipControllerId_, PipStartPipCallback);
361 ret = OH_PictureInPicture_UnregisterStartPipCallback(pipControllerId_, PipStartPipCallback);
362 EXPECT_EQ(ret, WindowManager_ErrorCode::OK);
363 OH_PictureInPicture_DeletePip(pipControllerId_);
364 }
365
366 /**
367 * @tc.name: OH_PictureInPicture_UnregisterAllStartPipCallbacks
368 * @tc.desc: OH_PictureInPicture_UnregisterAllStartPipCallbacks
369 * @tc.type: FUNC
370 */
371 HWTEST_F(OHWindowPipTest, OH_PictureInPicture_UnregisterAllStartPipCallbacks, TestSize.Level1)
372 {
373 uint32_t pipControllerId_ = 0;
374 auto ret = OH_PictureInPicture_CreatePip(pipConfig, &pipControllerId_);
375 EXPECT_EQ(WindowManager_ErrorCode::OK, ret);
376 ret = OH_PictureInPicture_UnregisterAllStartPipCallbacks(pipControllerId_ + 1);
377 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
378 ret = OH_PictureInPicture_UnregisterAllStartPipCallbacks(pipControllerId_);
379 EXPECT_EQ(WindowManager_ErrorCode::OK, ret);
380 OH_PictureInPicture_DeletePip(pipControllerId_);
381 }
382
383 /**
384 * @tc.name: OH_PictureInPicture_RegisterLifecycleListener
385 * @tc.desc: OH_PictureInPicture_RegisterLifecycleListener
386 * @tc.type: FUNC
387 */
388 HWTEST_F(OHWindowPipTest, OH_PictureInPicture_RegisterLifecycleListener, TestSize.Level1)
389 {
390 auto ret = OH_PictureInPicture_RegisterLifecycleListener(10000, PipLifeCycleCallback);
391 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
392 uint32_t pipControllerId_ = 0;
393 ret = OH_PictureInPicture_CreatePip(pipConfig, &pipControllerId_);
394 EXPECT_EQ(WindowManager_ErrorCode::OK, ret);
395 ret = OH_PictureInPicture_RegisterLifecycleListener(pipControllerId_, PipLifeCycleCallback);
396 EXPECT_EQ(ret, WindowManager_ErrorCode::OK);
397 OH_PictureInPicture_DeletePip(pipControllerId_);
398 }
399
400 /**
401 * @tc.name: OH_PictureInPicture_UnregisterLifecycleListener
402 * @tc.desc: OH_PictureInPicture_UnregisterLifecycleListener
403 * @tc.type: FUNC
404 */
405 HWTEST_F(OHWindowPipTest, OH_PictureInPicture_UnregisterLifecycleListener, TestSize.Level1)
406 {
407 uint32_t pipControllerId_ = 0;
408 auto ret = OH_PictureInPicture_CreatePip(pipConfig, &pipControllerId_);
409 EXPECT_EQ(WindowManager_ErrorCode::OK, ret);
410 ret = OH_PictureInPicture_UnregisterLifecycleListener(pipControllerId_ + 1, PipLifeCycleCallback);
411 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
412 ret = OH_PictureInPicture_UnregisterLifecycleListener(pipControllerId_, nullptr);
413 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
414 ret = OH_PictureInPicture_UnregisterLifecycleListener(pipControllerId_, PipLifeCycleCallback);
415 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
416 OH_PictureInPicture_RegisterLifecycleListener(pipControllerId_, PipLifeCycleCallback);
417 ret = OH_PictureInPicture_UnregisterLifecycleListener(pipControllerId_, PipLifeCycleCallback);
418 EXPECT_EQ(ret, WindowManager_ErrorCode::OK);
419 OH_PictureInPicture_DeletePip(pipControllerId_);
420 }
421
422 /**
423 * @tc.name: OH_PictureInPicture_UnregisterAllLifecycleListeners
424 * @tc.desc: OH_PictureInPicture_UnregisterAllLifecycleListeners
425 * @tc.type: FUNC
426 */
427 HWTEST_F(OHWindowPipTest, OH_PictureInPicture_UnregisterAllLifecycleListeners, TestSize.Level1)
428 {
429 uint32_t pipControllerId_ = 0;
430 auto ret = OH_PictureInPicture_CreatePip(pipConfig, &pipControllerId_);
431 EXPECT_EQ(WindowManager_ErrorCode::OK, ret);
432 ret = OH_PictureInPicture_UnregisterAllLifecycleListeners(pipControllerId_ + 1);
433 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
434 ret = OH_PictureInPicture_UnregisterAllLifecycleListeners(pipControllerId_);
435 EXPECT_EQ(WindowManager_ErrorCode::OK, ret);
436 OH_PictureInPicture_DeletePip(pipControllerId_);
437 }
438
439 /**
440 * @tc.name: OH_PictureInPicture_RegisterControlEventListener
441 * @tc.desc: OH_PictureInPicture_RegisterControlEventListener
442 * @tc.type: FUNC
443 */
444 HWTEST_F(OHWindowPipTest, OH_PictureInPicture_RegisterControlEventListener, TestSize.Level1)
445 {
446 auto ret = OH_PictureInPicture_RegisterControlEventListener(10000, PipControlEventCallback);
447 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
448 uint32_t pipControllerId_ = 0;
449 ret = OH_PictureInPicture_CreatePip(pipConfig, &pipControllerId_);
450 EXPECT_EQ(WindowManager_ErrorCode::OK, ret);
451 ret = OH_PictureInPicture_RegisterControlEventListener(pipControllerId_, PipControlEventCallback);
452 EXPECT_EQ(ret, WindowManager_ErrorCode::OK);
453 OH_PictureInPicture_DeletePip(pipControllerId_);
454 }
455
456 /**
457 * @tc.name: OH_PictureInPicture_UnregisterControlEventListener
458 * @tc.desc: OH_PictureInPicture_UnregisterControlEventListener
459 * @tc.type: FUNC
460 */
461 HWTEST_F(OHWindowPipTest, OH_PictureInPicture_UnregisterControlEventListener, TestSize.Level1)
462 {
463 uint32_t pipControllerId_ = 0;
464 auto ret = OH_PictureInPicture_CreatePip(pipConfig, &pipControllerId_);
465 EXPECT_EQ(WindowManager_ErrorCode::OK, ret);
466 ret = OH_PictureInPicture_UnregisterControlEventListener(pipControllerId_ + 1, PipControlEventCallback);
467 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
468 ret = OH_PictureInPicture_UnregisterControlEventListener(pipControllerId_, nullptr);
469 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
470 ret = OH_PictureInPicture_UnregisterControlEventListener(pipControllerId_, PipControlEventCallback);
471 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
472 OH_PictureInPicture_RegisterControlEventListener(pipControllerId_, PipControlEventCallback);
473 ret = OH_PictureInPicture_UnregisterControlEventListener(pipControllerId_, PipControlEventCallback);
474 EXPECT_EQ(ret, WindowManager_ErrorCode::OK);
475 OH_PictureInPicture_DeletePip(pipControllerId_);
476 }
477
478 /**
479 * @tc.name: OH_PictureInPicture_UnregisterAllControlEventListeners
480 * @tc.desc: OH_PictureInPicture_UnregisterAllControlEventListeners
481 * @tc.type: FUNC
482 */
483 HWTEST_F(OHWindowPipTest, OH_PictureInPicture_UnregisterAllControlEventListeners, TestSize.Level1)
484 {
485 uint32_t pipControllerId_ = 0;
486 auto ret = OH_PictureInPicture_CreatePip(pipConfig, &pipControllerId_);
487 EXPECT_EQ(WindowManager_ErrorCode::OK, ret);
488 ret = OH_PictureInPicture_UnregisterAllControlEventListeners(pipControllerId_ + 1);
489 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
490 ret = OH_PictureInPicture_UnregisterAllControlEventListeners(pipControllerId_);
491 EXPECT_EQ(WindowManager_ErrorCode::OK, ret);
492 OH_PictureInPicture_DeletePip(pipControllerId_);
493 }
494
495 /**
496 * @tc.name: OH_PictureInPicture_RegisterResizeListener
497 * @tc.desc: OH_PictureInPicture_RegisterResizeListener
498 * @tc.type: FUNC
499 */
500 HWTEST_F(OHWindowPipTest, OH_PictureInPicture_RegisterResizeListener, TestSize.Level1)
501 {
502 auto ret = OH_PictureInPicture_RegisterResizeListener(10000, PipResizeCallback);
503 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
504 uint32_t pipControllerId_ = 0;
505 ret = OH_PictureInPicture_CreatePip(pipConfig, &pipControllerId_);
506 EXPECT_EQ(WindowManager_ErrorCode::OK, ret);
507 ret = OH_PictureInPicture_RegisterResizeListener(pipControllerId_, PipResizeCallback);
508 EXPECT_EQ(ret, WindowManager_ErrorCode::OK);
509 OH_PictureInPicture_DeletePip(pipControllerId_);
510 }
511
512 /**
513 * @tc.name: OH_PictureInPicture_UnregisterResizeListener
514 * @tc.desc: OH_PictureInPicture_UnregisterResizeListener
515 * @tc.type: FUNC
516 */
517 HWTEST_F(OHWindowPipTest, OH_PictureInPicture_UnregisterResizeListener, TestSize.Level1)
518 {
519 uint32_t pipControllerId_ = 0;
520 auto ret = OH_PictureInPicture_CreatePip(pipConfig, &pipControllerId_);
521 EXPECT_EQ(WindowManager_ErrorCode::OK, ret);
522 ret = OH_PictureInPicture_UnregisterResizeListener(pipControllerId_ + 1, PipResizeCallback);
523 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
524 ret = OH_PictureInPicture_UnregisterResizeListener(pipControllerId_, nullptr);
525 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
526 ret = OH_PictureInPicture_UnregisterResizeListener(pipControllerId_, PipResizeCallback);
527 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
528 OH_PictureInPicture_RegisterResizeListener(pipControllerId_, PipResizeCallback);
529 ret = OH_PictureInPicture_UnregisterResizeListener(pipControllerId_, PipResizeCallback);
530 EXPECT_EQ(ret, WindowManager_ErrorCode::OK);
531 OH_PictureInPicture_DeletePip(pipControllerId_);
532 }
533
534 /**
535 * @tc.name: OH_PictureInPicture_UnregisterAllResizeListeners
536 * @tc.desc: OH_PictureInPicture_UnregisterAllResizeListeners
537 * @tc.type: FUNC
538 */
539 HWTEST_F(OHWindowPipTest, OH_PictureInPicture_UnregisterAllResizeListeners, TestSize.Level1)
540 {
541 uint32_t pipControllerId_ = 0;
542 auto ret = OH_PictureInPicture_CreatePip(pipConfig, &pipControllerId_);
543 EXPECT_EQ(WindowManager_ErrorCode::OK, ret);
544 ret = OH_PictureInPicture_UnregisterAllResizeListeners(pipControllerId_ + 1);
545 EXPECT_EQ(ret, WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM);
546 ret = OH_PictureInPicture_UnregisterAllResizeListeners(pipControllerId_);
547 EXPECT_EQ(WindowManager_ErrorCode::OK, ret);
548 OH_PictureInPicture_DeletePip(pipControllerId_);
549 }
550
551 /**
552 * @tc.name: OH_PictureInPicture_SetPipInitialSurfaceRect
553 * @tc.desc: OH_PictureInPicture_SetPipInitialSurfaceRect
554 * @tc.type: FUNC
555 */
556 HWTEST_F(OHWindowPipTest, OH_PictureInPicture_SetPipInitialSurfaceRect, TestSize.Level1)
557 {
558 uint32_t pipControllerId_ = 0;
559 auto ret = OH_PictureInPicture_CreatePip(pipConfig, &pipControllerId_);
560 EXPECT_EQ(WindowManager_ErrorCode::OK, ret);
561 ret = OH_PictureInPicture_SetPipInitialSurfaceRect(pipControllerId_ + 1, 10, 10, 100, 100);
562 EXPECT_EQ(WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM, ret);
563 ret = OH_PictureInPicture_SetPipInitialSurfaceRect(pipControllerId_, 10, 10, 100, 100);
564 EXPECT_EQ(WindowManager_ErrorCode::OK, ret);
565 OH_PictureInPicture_DeletePip(pipControllerId_);
566 }
567
568 /**
569 * @tc.name: OH_PictureInPicture_UnsetPipInitialSurfaceRect
570 * @tc.desc: OH_PictureInPicture_UnsetPipInitialSurfaceRect
571 * @tc.type: FUNC
572 */
573 HWTEST_F(OHWindowPipTest, OH_PictureInPicture_UnsetPipInitialSurfaceRect, TestSize.Level1)
574 {
575 uint32_t pipControllerId_ = 0;
576 auto ret = OH_PictureInPicture_CreatePip(pipConfig, &pipControllerId_);
577 EXPECT_EQ(WindowManager_ErrorCode::OK, ret);
578 ret = OH_PictureInPicture_UnsetPipInitialSurfaceRect(pipControllerId_ + 1);
579 EXPECT_EQ(WindowManager_ErrorCode::WINDOW_MANAGER_ERRORCODE_INCORRECT_PARAM, ret);
580 ret = OH_PictureInPicture_UnsetPipInitialSurfaceRect(pipControllerId_);
581 EXPECT_EQ(WindowManager_ErrorCode::OK, ret);
582 OH_PictureInPicture_DeletePip(pipControllerId_);
583 }
584 }
585 }
586 }