1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include "native_avsession.h"
18 #include "OHAVSession.h"
19 #include "OHAVSessionCallbackImpl.h"
20 #include "avsession_log.h"
21 #include "avsession_manager.h"
22
23 using namespace testing::ext;
24
25 namespace OHOS::AVSession {
26 static OHAVSessionCallbackImpl g_ohAVSessionCallbackImpl;
27
28 class OHAVSessionCallbackImplTest : public testing::Test {
29 public:
30 static void SetUpTestCase(void);
31 static void TearDownTestCase(void);
32 void SetUp();
33 void TearDown();
34 };
35
SetUpTestCase(void)36 void OHAVSessionCallbackImplTest::SetUpTestCase(void)
37 {
38 }
39
TearDownTestCase(void)40 void OHAVSessionCallbackImplTest::TearDownTestCase(void)
41 {
42 }
43
SetUp()44 void OHAVSessionCallbackImplTest::SetUp()
45 {
46 }
47
TearDown()48 void OHAVSessionCallbackImplTest::TearDown()
49 {
50 }
51
52 /**
53 * @tc.name: UnSetPlayCallback001
54 * @tc.desc: test UnSetPlayCallback
55 * @tc.type: FUNC
56 * @tc.require: AR000H31JO
57 */
58 HWTEST_F(OHAVSessionCallbackImplTest, UnSetPlayCallback001, TestSize.Level1)
59 {
60 SLOGI("UnSetPlayCallback001 Begin");
61 OH_AVSession* avsession = nullptr;
62 OH_AVSession_Create(SESSION_TYPE_AUDIO, "UnSetPlayCallback001", "com.xxx.hmxx", "ndkxx", &avsession);
63 AVSession_ControlCommand command = CONTROL_CMD_PLAY;
64 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
__anon0ce928b50102(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 65 void* userData) -> AVSessionCallback_Result {
66 return AVSESSION_CALLBACK_RESULT_SUCCESS;
67 };
68 int userData = 1;
69 g_ohAVSessionCallbackImpl.SetPlayCallback(avsession, command, callback, (void *)(&userData));
70 AVSession_ErrCode ret = g_ohAVSessionCallbackImpl.UnSetPlayCallback(
71 avsession, command, callback);
72 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
73 SLOGI("UnSetPlayCallback001 End");
74 }
75
76 /**
77 * @tc.name: SetPauseCallback001
78 * @tc.desc: test SetPauseCallback
79 * @tc.type: FUNC
80 * @tc.require: AR000H31JO
81 */
82 HWTEST_F(OHAVSessionCallbackImplTest, SetPauseCallback001, TestSize.Level1)
83 {
84 SLOGI("SetPauseCallback001 Begin");
85 OH_AVSession* avsession = nullptr;
86 OH_AVSession_Create(SESSION_TYPE_AUDIO, "SetPauseCallback001", "com.xxx.hmxx", "ndkxx", &avsession);
87 AVSession_ControlCommand command = CONTROL_CMD_PLAY;
88 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
__anon0ce928b50202(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 89 void* userData) -> AVSessionCallback_Result {
90 return AVSESSION_CALLBACK_RESULT_SUCCESS;
91 };
92 int userData = 1;
93 AVSession_ErrCode ret = g_ohAVSessionCallbackImpl.SetPauseCallback(
94 avsession, command, callback, (void *)(&userData));
95 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
96 SLOGI("SetPauseCallback001 End");
97 }
98
99 /**
100 * @tc.name: SetPauseCallback002
101 * @tc.desc: test SetPauseCallback
102 * @tc.type: FUNC
103 * @tc.require: AR000H31JO
104 */
105 HWTEST_F(OHAVSessionCallbackImplTest, SetPauseCallback002, TestSize.Level1)
106 {
107 SLOGI("SetPauseCallback002 Begin");
108 OH_AVSession* avsession = nullptr;
109 OH_AVSession_Create(SESSION_TYPE_AUDIO, "SetPauseCallback002", "com.xxx.hmxx", "ndkxx", &avsession);
110 AVSession_ControlCommand command = CONTROL_CMD_PLAY;
111 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
__anon0ce928b50302(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 112 void* userData) -> AVSessionCallback_Result {
113 return AVSESSION_CALLBACK_RESULT_SUCCESS;
114 };
115 int userData = 1;
116 AVSession_ErrCode ret = g_ohAVSessionCallbackImpl.SetPauseCallback(
117 avsession, command, callback, (void *)(&userData));
118 g_ohAVSessionCallbackImpl.SetPauseCallback(avsession, command, callback, (void *)(&userData));
119 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
120 SLOGI("SetPauseCallback002 End");
121 }
122
123 /**
124 * @tc.name: UnSetPauseCallback001
125 * @tc.desc: test UnSetPauseCallback
126 * @tc.type: FUNC
127 * @tc.require: AR000H31JO
128 */
129 HWTEST_F(OHAVSessionCallbackImplTest, UnSetPauseCallback001, TestSize.Level1)
130 {
131 SLOGI("UnSetPauseCallback001 Begin");
132 OH_AVSession* avsession = nullptr;
133 OH_AVSession_Create(SESSION_TYPE_AUDIO, "UnSetPauseCallback001", "com.xxx.hmxx", "ndkxx", &avsession);
134 AVSession_ControlCommand command = CONTROL_CMD_PLAY;
135 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
__anon0ce928b50402(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 136 void* userData) -> AVSessionCallback_Result {
137 return AVSESSION_CALLBACK_RESULT_SUCCESS;
138 };
139 int userData = 1;
140 g_ohAVSessionCallbackImpl.SetPauseCallback(avsession, command, callback, (void *)(&userData));
141 AVSession_ErrCode ret = g_ohAVSessionCallbackImpl.UnSetPauseCallback(
142 avsession, command, callback);
143 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
144 SLOGI("UnSetPauseCallback001 End");
145 }
146
147 /**
148 * @tc.name: SetStopCallback001
149 * @tc.desc: test SetStopCallback
150 * @tc.type: FUNC
151 * @tc.require: AR000H31JO
152 */
153 HWTEST_F(OHAVSessionCallbackImplTest, SetStopCallback001, TestSize.Level1)
154 {
155 SLOGI("SetStopCallback001 Begin");
156 OH_AVSession* avsession = nullptr;
157 OH_AVSession_Create(SESSION_TYPE_AUDIO, "SetStopCallback001", "com.xxx.hmxx", "ndkxx", &avsession);
158 AVSession_ControlCommand command = CONTROL_CMD_PLAY;
159 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
__anon0ce928b50502(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 160 void* userData) -> AVSessionCallback_Result {
161 return AVSESSION_CALLBACK_RESULT_SUCCESS;
162 };
163 int userData = 1;
164 AVSession_ErrCode ret = g_ohAVSessionCallbackImpl.SetStopCallback(
165 avsession, command, callback, (void *)(&userData));
166 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
167 SLOGI("SetStopCallback001 End");
168 }
169
170 /**
171 * @tc.name: SetStopCallback002
172 * @tc.desc: test SetStopCallback
173 * @tc.type: FUNC
174 * @tc.require: AR000H31JO
175 */
176 HWTEST_F(OHAVSessionCallbackImplTest, SetStopCallback002, TestSize.Level1)
177 {
178 SLOGI("SetStopCallback002 Begin");
179 OH_AVSession* avsession = nullptr;
180 OH_AVSession_Create(SESSION_TYPE_AUDIO, "SetStopCallback002", "com.xxx.hmxx", "ndkxx", &avsession);
181 AVSession_ControlCommand command = CONTROL_CMD_PLAY;
182 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
__anon0ce928b50602(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 183 void* userData) -> AVSessionCallback_Result {
184 return AVSESSION_CALLBACK_RESULT_SUCCESS;
185 };
186 int userData = 1;
187 AVSession_ErrCode ret = g_ohAVSessionCallbackImpl.SetStopCallback(
188 avsession, command, callback, (void *)(&userData));
189 g_ohAVSessionCallbackImpl.SetStopCallback(avsession, command, callback, (void *)(&userData));
190 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
191 SLOGI("SetStopCallback002 End");
192 }
193
194 /**
195 * @tc.name: SetPlayNextCallback001
196 * @tc.desc: test SetPlayNextCallback
197 * @tc.type: FUNC
198 * @tc.require: AR000H31JO
199 */
200 HWTEST_F(OHAVSessionCallbackImplTest, SetPlayNextCallback001, TestSize.Level1)
201 {
202 SLOGI("SetPlayNextCallback001 Begin");
203 OH_AVSession* avsession = nullptr;
204 OH_AVSession_Create(SESSION_TYPE_AUDIO, "SetPlayNextCallback001", "com.xxx.hmxx", "ndkxx", &avsession);
205 AVSession_ControlCommand command = CONTROL_CMD_PLAY;
206 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
__anon0ce928b50702(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 207 void* userData) -> AVSessionCallback_Result {
208 return AVSESSION_CALLBACK_RESULT_SUCCESS;
209 };
210 int userData = 1;
211 AVSession_ErrCode ret = g_ohAVSessionCallbackImpl.SetPlayNextCallback(
212 avsession, command, callback, (void *)(&userData));
213 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
214 SLOGI("SetPlayNextCallback001 End");
215 }
216
217 /**
218 * @tc.name: SetPlayNextCallback002
219 * @tc.desc: test SetPlayNextCallback
220 * @tc.type: FUNC
221 * @tc.require: AR000H31JO
222 */
223 HWTEST_F(OHAVSessionCallbackImplTest, SetPlayNextCallback002, TestSize.Level1)
224 {
225 SLOGI("SetPlayNextCallback002 Begin");
226 OH_AVSession* avsession = nullptr;
227 OH_AVSession_Create(SESSION_TYPE_AUDIO, "SetPlayNextCallback002", "com.xxx.hmxx", "ndkxx", &avsession);
228 AVSession_ControlCommand command = CONTROL_CMD_PLAY;
229 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
__anon0ce928b50802(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 230 void* userData) -> AVSessionCallback_Result {
231 return AVSESSION_CALLBACK_RESULT_SUCCESS;
232 };
233 int userData = 1;
234 AVSession_ErrCode ret = g_ohAVSessionCallbackImpl.SetPlayNextCallback(
235 avsession, command, callback, (void *)(&userData));
236 g_ohAVSessionCallbackImpl.SetPlayNextCallback(avsession, command, callback, (void *)(&userData));
237 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
238 SLOGI("SetPlayNextCallback002 End");
239 }
240
241 /**
242 * @tc.name: SetPlayPreviousCallback001
243 * @tc.desc: test SetPlayPreviousCallback
244 * @tc.type: FUNC
245 * @tc.require: AR000H31JO
246 */
247 HWTEST_F(OHAVSessionCallbackImplTest, SetPlayPreviousCallback001, TestSize.Level1)
248 {
249 SLOGI("SetPlayPreviousCallback001 Begin");
250 OH_AVSession* avsession = nullptr;
251 OH_AVSession_Create(SESSION_TYPE_AUDIO, "SetPlayPreviousCallback001", "com.xxx.hmxx", "ndkxx", &avsession);
252 AVSession_ControlCommand command = CONTROL_CMD_PLAY;
253 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
__anon0ce928b50902(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 254 void* userData) -> AVSessionCallback_Result {
255 return AVSESSION_CALLBACK_RESULT_SUCCESS;
256 };
257 int userData = 1;
258 AVSession_ErrCode ret = g_ohAVSessionCallbackImpl.SetPlayPreviousCallback(
259 avsession, command, callback, (void *)(&userData));
260 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
261 SLOGI("SetPlayPreviousCallback001 End");
262 }
263
264 /**
265 * @tc.name: SetPlayPreviousCallback002
266 * @tc.desc: test SetPlayPreviousCallback
267 * @tc.type: FUNC
268 * @tc.require: AR000H31JO
269 */
270 HWTEST_F(OHAVSessionCallbackImplTest, SetPlayPreviousCallback002, TestSize.Level1)
271 {
272 SLOGI("SetPlayPreviousCallback002 Begin");
273 OH_AVSession* avsession = nullptr;
274 OH_AVSession_Create(SESSION_TYPE_AUDIO, "SetPlayPreviousCallback002", "com.xxx.hmxx", "ndkxx", &avsession);
275 AVSession_ControlCommand command = CONTROL_CMD_PLAY;
276 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
__anon0ce928b50a02(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 277 void* userData) -> AVSessionCallback_Result {
278 return AVSESSION_CALLBACK_RESULT_SUCCESS;
279 };
280 int userData = 1;
281 AVSession_ErrCode ret = g_ohAVSessionCallbackImpl.SetPlayPreviousCallback(
282 avsession, command, callback, (void *)(&userData));
283 g_ohAVSessionCallbackImpl.SetPlayPreviousCallback(avsession, command, callback, (void *)(&userData));
284 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
285 SLOGI("SetPlayPreviousCallback002 End");
286 }
287
288 /**
289 * @tc.name: SetPlayCallback001
290 * @tc.desc: test SetPlayCallback
291 * @tc.type: FUNC
292 * @tc.require: AR000H31JO
293 */
294 HWTEST_F(OHAVSessionCallbackImplTest, SetPlayCallback001, TestSize.Level1)
295 {
296 SLOGI("SetPlayCallback001 Begin");
297 OH_AVSession* avsession = nullptr;
298 OH_AVSession_Create(SESSION_TYPE_AUDIO, "SetPlayCallback001", "com.xxx.hmxx", "ndkxx", &avsession);
299 AVSession_ControlCommand command = CONTROL_CMD_PLAY;
300 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
__anon0ce928b50b02(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 301 void* userData) -> AVSessionCallback_Result {
302 return AVSESSION_CALLBACK_RESULT_SUCCESS;
303 };
304 int userData = 1;
305 g_ohAVSessionCallbackImpl.avsession_ = avsession;
306 g_ohAVSessionCallbackImpl.SetPlayCallback(avsession, command, callback, (void *)(&userData));
307 AVSession_ErrCode ret = g_ohAVSessionCallbackImpl.UnSetPlayCallback(
308 avsession, command, callback);
309 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
310 SLOGI("SetPlayCallback001 End");
311 }
312
313 /**
314 * @tc.name: RegisterForwardCallback001
315 * @tc.desc: test RegisterForwardCallback
316 * @tc.type: FUNC
317 * @tc.require: AR000H31JO
318 */
319 HWTEST_F(OHAVSessionCallbackImplTest, RegisterForwardCallback001, TestSize.Level1)
320 {
321 SLOGI("RegisterForwardCallback001 Begin");
322 OH_AVSession* avsession = nullptr;
323 OH_AVSession_Create(SESSION_TYPE_AUDIO, "RegisterForwardCallback001", "com.xxx.hmxx", "ndkxx", &avsession);
324 OH_AVSessionCallback_OnFastForward callback = [](OH_AVSession* session, uint32_t seekTime,
__anon0ce928b50c02(OH_AVSession* session, uint32_t seekTime, void* userData) 325 void* userData) -> AVSessionCallback_Result {
326 return AVSESSION_CALLBACK_RESULT_SUCCESS;
327 };
328 int userData = 1;
329 g_ohAVSessionCallbackImpl.avsession_ = avsession;
330 auto ret = g_ohAVSessionCallbackImpl.RegisterForwardCallback(avsession, callback, (void *)(&userData));
331 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
332 SLOGI("RegisterForwardCallback001 End");
333 }
334
335 /**
336 * @tc.name: RegisterSeekCallback001
337 * @tc.desc: test RegisterSeekCallback
338 * @tc.type: FUNC
339 * @tc.require: AR000H31JO
340 */
341 HWTEST_F(OHAVSessionCallbackImplTest, RegisterSeekCallback001, TestSize.Level1)
342 {
343 SLOGI("RegisterSeekCallback001 Begin");
344 OH_AVSession* avsession = nullptr;
345 OH_AVSession_Create(SESSION_TYPE_AUDIO, "RegisterSeekCallback001", "com.xxx.hmxx", "ndkxx", &avsession);
346 OH_AVSessionCallback_OnSeek callback = [](OH_AVSession* session, uint64_t seekTime,
__anon0ce928b50d02(OH_AVSession* session, uint64_t seekTime, void* userData) 347 void* userData) -> AVSessionCallback_Result {
348 return AVSESSION_CALLBACK_RESULT_SUCCESS;
349 };
350 int userData = 1;
351 g_ohAVSessionCallbackImpl.avsession_ = avsession;
352 auto ret = g_ohAVSessionCallbackImpl.RegisterSeekCallback(avsession, callback, (void *)(&userData));
353 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
354 SLOGI("RegisterSeekCallback001 End");
355 }
356
357 /**
358 * @tc.name: RegisterSetLoopModeCallback001
359 * @tc.desc: test RegisterSetLoopModeCallback
360 * @tc.type: FUNC
361 * @tc.require: AR000H31JO
362 */
363 HWTEST_F(OHAVSessionCallbackImplTest, RegisterSetLoopModeCallback001, TestSize.Level1)
364 {
365 SLOGI("RegisterSetLoopModeCallback001 Begin");
366 OH_AVSession* avsession = nullptr;
367 OH_AVSession_Create(SESSION_TYPE_AUDIO, "RegisterSetLoopModeCallback", "com.xxx.hmxx", "ndkxx", &avsession);
368 OH_AVSessionCallback_OnSetLoopMode callback = [](OH_AVSession* session, AVSession_LoopMode curLoopMode,
__anon0ce928b50e02(OH_AVSession* session, AVSession_LoopMode curLoopMode, void* userData) 369 void* userData) -> AVSessionCallback_Result {
370 return AVSESSION_CALLBACK_RESULT_SUCCESS;
371 };
372 int userData = 1;
373 g_ohAVSessionCallbackImpl.avsession_ = avsession;
374 auto ret = g_ohAVSessionCallbackImpl.RegisterSetLoopModeCallback(avsession, callback, (void *)(&userData));
375 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
376 SLOGI("RegisterSetLoopModeCallback001 End");
377 }
378
379 /**
380 * @tc.name: RegisterToggleFavoriteCallback001
381 * @tc.desc: test RegisterToggleFavoriteCallback
382 * @tc.type: FUNC
383 * @tc.require: AR000H31JO
384 */
385 HWTEST_F(OHAVSessionCallbackImplTest, RegisterToggleFavoriteCallback001, TestSize.Level1)
386 {
387 SLOGI("RegisterToggleFavoriteCallback001 Begin");
388 OH_AVSession* avsession = nullptr;
389 OH_AVSession_Create(SESSION_TYPE_AUDIO, "RegisterToggleFavoriteCallback001", "com.xxx.hmxx", "ndkxx", &avsession);
390 OH_AVSessionCallback_OnToggleFavorite callback = [](OH_AVSession* session, const char* assetId,
__anon0ce928b50f02(OH_AVSession* session, const char* assetId, void* userData) 391 void* userData) -> AVSessionCallback_Result {
392 return AVSESSION_CALLBACK_RESULT_SUCCESS;
393 };
394 int userData = 1;
395 g_ohAVSessionCallbackImpl.avsession_ = avsession;
396 auto ret = g_ohAVSessionCallbackImpl.RegisterToggleFavoriteCallback(avsession, callback, (void *)(&userData));
397 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
398 SLOGI("RegisterToggleFavoriteCallback001 End");
399 }
400
401 /**
402 * @tc.name: RegisterForwardCallback002
403 * @tc.desc: have registered RegisterForwardCallback
404 * @tc.type: FUNC
405 * @tc.require: AR000H31JO
406 */
407 HWTEST_F(OHAVSessionCallbackImplTest, RegisterForwardCallback002, TestSize.Level1)
408 {
409 SLOGI("RegisterForwardCallback002 Begin");
410 auto avsession = std::make_shared<OHAVSession>();
411 OH_AVSession* oh_avsession = reinterpret_cast<OH_AVSession*>(avsession.get());
412 EXPECT_TRUE(oh_avsession != nullptr);
413
414 OH_AVSessionCallback_OnFastForward callback = [](OH_AVSession* oh_avsession, uint32_t seekTime,
__anon0ce928b51002(OH_AVSession* oh_avsession, uint32_t seekTime, void* userData) 415 void* userData) -> AVSessionCallback_Result {
416 return AVSESSION_CALLBACK_RESULT_SUCCESS;
417 };
418 int userData = 1;
419 g_ohAVSessionCallbackImpl.avsession_ = oh_avsession;
420 auto ret = g_ohAVSessionCallbackImpl.RegisterForwardCallback(oh_avsession, callback, (void *)(&userData));
421 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
422
423 auto it = std::find_if (g_ohAVSessionCallbackImpl.forwardCallbacks_.begin(),
424 g_ohAVSessionCallbackImpl.forwardCallbacks_.end(),
__anon0ce928b51102(const std::pair<OH_AVSessionCallback_OnFastForward, void*> &element) 425 [callback](const std::pair<OH_AVSessionCallback_OnFastForward, void*> &element) {
426 return element.first == callback; });
427 EXPECT_TRUE (it != g_ohAVSessionCallbackImpl.forwardCallbacks_.end());
428 SLOGI("RegisterForwardCallback002 End");
429 }
430
431 /**
432 * @tc.name: RegisterRewindCallback002
433 * @tc.desc: have registered RegisterRewindCallback
434 * @tc.type: FUNC
435 * @tc.require: AR000H31JO
436 */
437 HWTEST_F(OHAVSessionCallbackImplTest, RegisterRewindCallback002, TestSize.Level1)
438 {
439 SLOGI("RegisterRewindCallback002 Begin");
440 auto avsession = std::make_shared<OHAVSession>();
441 OH_AVSession* oh_avsession = reinterpret_cast<OH_AVSession*>(avsession.get());
442 EXPECT_TRUE(oh_avsession != nullptr);
443
444 OH_AVSessionCallback_OnRewind callback = [](OH_AVSession* oh_avsession, uint32_t seekTime,
__anon0ce928b51202(OH_AVSession* oh_avsession, uint32_t seekTime, void* userData) 445 void* userData) -> AVSessionCallback_Result {
446 return AVSESSION_CALLBACK_RESULT_SUCCESS;
447 };
448 int userData = 1;
449 g_ohAVSessionCallbackImpl.avsession_ = oh_avsession;
450 auto ret = g_ohAVSessionCallbackImpl.RegisterRewindCallback(oh_avsession, callback, (void *)(&userData));
451 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
452
453 auto it = std::find_if (g_ohAVSessionCallbackImpl.rewindCallbacks_.begin(),
454 g_ohAVSessionCallbackImpl.rewindCallbacks_.end(),
__anon0ce928b51302(const std::pair<OH_AVSessionCallback_OnRewind, void*> &element) 455 [callback](const std::pair<OH_AVSessionCallback_OnRewind, void*> &element) {
456 return element.first == callback; });
457 EXPECT_TRUE (it != g_ohAVSessionCallbackImpl.rewindCallbacks_.end());
458 SLOGI("RegisterRewindCallback002 End");
459 }
460
461 /**
462 * @tc.name: RegisterSeekCallback002
463 * @tc.desc: have registered RegisterSeekCallback
464 * @tc.type: FUNC
465 * @tc.require: AR000H31JO
466 */
467 HWTEST_F(OHAVSessionCallbackImplTest, RegisterSeekCallback002, TestSize.Level1)
468 {
469 SLOGI("RegisterSeekCallback002 Begin");
470 auto avsession = std::make_shared<OHAVSession>();
471 OH_AVSession* oh_avsession = reinterpret_cast<OH_AVSession*>(avsession.get());
472 EXPECT_TRUE(oh_avsession != nullptr);
473
474 OH_AVSessionCallback_OnSeek callback = [](OH_AVSession* oh_avsession, uint64_t seekTime,
__anon0ce928b51402(OH_AVSession* oh_avsession, uint64_t seekTime, void* userData) 475 void* userData) -> AVSessionCallback_Result {
476 return AVSESSION_CALLBACK_RESULT_SUCCESS;
477 };
478 int userData = 1;
479 g_ohAVSessionCallbackImpl.avsession_ = oh_avsession;
480 auto ret = g_ohAVSessionCallbackImpl.RegisterSeekCallback(oh_avsession, callback, (void *)(&userData));
481 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
482
483 auto it = std::find_if (g_ohAVSessionCallbackImpl.seekCallbacks_.begin(),
484 g_ohAVSessionCallbackImpl.seekCallbacks_.end(),
__anon0ce928b51502(const std::pair<OH_AVSessionCallback_OnSeek, void*> &element) 485 [callback](const std::pair<OH_AVSessionCallback_OnSeek, void*> &element) {
486 return element.first == callback; });
487 EXPECT_TRUE (it != g_ohAVSessionCallbackImpl.seekCallbacks_.end());
488 SLOGI("RegisterSeekCallback002 End");
489 }
490
491 /**
492 * @tc.name: RegisterSetLoopModeCallback002
493 * @tc.desc: have registered RegisterSetLoopModeCallback
494 * @tc.type: FUNC
495 * @tc.require: AR000H31JO
496 */
497 HWTEST_F(OHAVSessionCallbackImplTest, RegisterSetLoopModeCallback002, TestSize.Level1)
498 {
499 SLOGI("RegisterSetLoopModeCallback002 Begin");
500 auto avsession = std::make_shared<OHAVSession>();
501 OH_AVSession* oh_avsession = reinterpret_cast<OH_AVSession*>(avsession.get());
502 EXPECT_TRUE(oh_avsession != nullptr);
503
504 OH_AVSessionCallback_OnSetLoopMode callback = [](OH_AVSession* session,
__anon0ce928b51602(OH_AVSession* session, AVSession_LoopMode curLoopMode, void* userData) 505 AVSession_LoopMode curLoopMode, void* userData) -> AVSessionCallback_Result {
506 return AVSESSION_CALLBACK_RESULT_SUCCESS;
507 };
508 int userData = 1;
509 g_ohAVSessionCallbackImpl.avsession_ = oh_avsession;
510 auto ret = g_ohAVSessionCallbackImpl.RegisterSetLoopModeCallback(oh_avsession, callback, (void *)(&userData));
511 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
512
513 auto it = std::find_if (g_ohAVSessionCallbackImpl.setLoopModeCallbacks_.begin(),
514 g_ohAVSessionCallbackImpl.setLoopModeCallbacks_.end(),
__anon0ce928b51702(const std::pair<OH_AVSessionCallback_OnSetLoopMode, void*> &element) 515 [callback](const std::pair<OH_AVSessionCallback_OnSetLoopMode, void*> &element) {
516 return element.first == callback; });
517 EXPECT_TRUE (it != g_ohAVSessionCallbackImpl.setLoopModeCallbacks_.end());
518 SLOGI("RegisterSetLoopModeCallback002 End");
519 }
520
521 /**
522 * @tc.name: RegisterToggleFavoriteCallback002
523 * @tc.desc: have registered RegisterToggleFavoriteCallback
524 * @tc.type: FUNC
525 * @tc.require: AR000H31JO
526 */
527 HWTEST_F(OHAVSessionCallbackImplTest, RegisterToggleFavoriteCallback002, TestSize.Level1)
528 {
529 SLOGI("RegisterToggleFavoriteCallback002 Begin");
530 auto avsession = std::make_shared<OHAVSession>();
531 OH_AVSession* oh_avsession = reinterpret_cast<OH_AVSession*>(avsession.get());
532 EXPECT_TRUE(oh_avsession != nullptr);
533
534 OH_AVSessionCallback_OnToggleFavorite callback = [](OH_AVSession* session,
__anon0ce928b51802(OH_AVSession* session, const char* assetId, void* userData) 535 const char* assetId, void* userData) -> AVSessionCallback_Result {
536 return AVSESSION_CALLBACK_RESULT_SUCCESS;
537 };
538 int userData = 1;
539 g_ohAVSessionCallbackImpl.avsession_ = oh_avsession;
540 auto ret = g_ohAVSessionCallbackImpl.RegisterToggleFavoriteCallback(oh_avsession, callback, (void *)(&userData));
541 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
542
543 auto it = std::find_if (g_ohAVSessionCallbackImpl.toggleFavoriteCallbacks_.begin(),
544 g_ohAVSessionCallbackImpl.toggleFavoriteCallbacks_.end(),
__anon0ce928b51902(const std::pair<OH_AVSessionCallback_OnToggleFavorite, void*> &element) 545 [callback](const std::pair<OH_AVSessionCallback_OnToggleFavorite, void*> &element) {
546 return element.first == callback; });
547 EXPECT_TRUE (it != g_ohAVSessionCallbackImpl.toggleFavoriteCallbacks_.end());
548 SLOGI("RegisterToggleFavoriteCallback002 End");
549 }
550
551 } //OHOS::AVSession