1 /*
2 * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include "OHAVSession.h"
18 #include "OHAVMetadataBuilder.h"
19 #include "native_avmetadata.h"
20 #include "avmeta_data.h"
21
22 using namespace testing::ext;
23
24 namespace OHOS::AVSession {
25
26 class OHAVSessionTest : public testing::Test {
27 public:
28 static void SetUpTestCase(void);
29 static void TearDownTestCase(void);
30 void SetUp();
31 void TearDown();
32 };
33
SetUpTestCase(void)34 void OHAVSessionTest::SetUpTestCase(void)
35 {
36 }
37
TearDownTestCase(void)38 void OHAVSessionTest::TearDownTestCase(void)
39 {
40 }
41
SetUp()42 void OHAVSessionTest::SetUp()
43 {
44 }
45
TearDown()46 void OHAVSessionTest::TearDown()
47 {
48 }
49
50 /**
51 * @tc.name: OH_AVSession_Create_001
52 * @tc.desc: Create from the class of ohavsession
53 * @tc.type: FUNC
54 * @tc.require: none
55 */
56 HWTEST(OHAVSessionTest, OH_AVSession_Create_001, TestSize.Level0)
57 {
58 OH_AVSession* avsession = nullptr;
59 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "OH_AVSession_Create_001",
60 "com.xxx.hmxx", "ndkxx", &avsession);
61 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
62 ret = OH_AVSession_Destroy(avsession);
63 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
64 }
65
66 /**
67 * @tc.name: OH_AVSession_Destory_001
68 * @tc.desc: Destory from the class of ohavsession
69 * @tc.type: FUNC
70 * @tc.require: none
71 */
72 HWTEST(OHAVSessionTest, OH_AVSession_Destory_001, TestSize.Level0)
73 {
74 OH_AVSession* avsession = nullptr;
75 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "OH_AVSession_Destory_001",
76 "com.xxx.hmxx", "ndkxx", &avsession);
77 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
78 ret = OH_AVSession_Destroy(avsession);
79 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
80 }
81
82 /**
83 * @tc.name: OH_AVSession_Activate_001
84 * @tc.desc: Activate from the class of ohavsession
85 * @tc.type: FUNC
86 * @tc.require: none
87 */
88 HWTEST(OHAVSessionTest, OH_AVSession_Activate_001, TestSize.Level0)
89 {
90 OH_AVSession* avsession = nullptr;
91 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "OH_AVSession_Activate_001",
92 "com.xxx.hmxx", "ndkxx", &avsession);
93 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
94 ret = OH_AVSession_Activate(avsession);
95 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
96 ret = OH_AVSession_Destroy(avsession);
97 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
98 }
99
100 /**
101 * @tc.name: OH_AVSession_Deactivate_001
102 * @tc.desc: Deactivate from the class of ohavsession
103 * @tc.type: FUNC
104 * @tc.require: none
105 */
106 HWTEST(OHAVSessionTest, OH_AVSession_Deactivate_001, TestSize.Level0)
107 {
108 OH_AVSession* avsession = nullptr;
109 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "OH_AVSession_Deactivate_001",
110 "com.xxx.hmxx", "ndkxx", &avsession);
111 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
112 ret = OH_AVSession_Deactivate(avsession);
113 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
114 ret = OH_AVSession_Destroy(avsession);
115 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
116 }
117
118 /**
119 * @tc.name: OH_AVSession_GetSessionType_001
120 * @tc.desc: GetSessionType from the class of ohavsession
121 * @tc.type: FUNC
122 * @tc.require: none
123 */
124 HWTEST(OHAVSessionTest, OH_AVSession_GetSessionType_001, TestSize.Level0)
125 {
126 OH_AVSession* avsession = nullptr;
127 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "OH_AVSession_GetSessionType_001",
128 "com.xxx.hmxx", "ndkxx", &avsession);
129 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
130 AVSession_Type sessionType;
131 ret = OH_AVSession_GetSessionType(avsession, &sessionType);
132 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
133 EXPECT_EQ(sessionType, SESSION_TYPE_AUDIO);
134 ret = OH_AVSession_Destroy(avsession);
135 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
136 }
137
138 /**
139 * @tc.name: OH_AVSession_GetSessionId_001
140 * @tc.desc: GetSessionId from the class of ohavsession
141 * @tc.type: FUNC
142 * @tc.require: none
143 */
144 HWTEST(OHAVSessionTest, OH_AVSession_GetSessionId_001, TestSize.Level0)
145 {
146 OH_AVSession* avsession = nullptr;
147 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "OH_AVSession_GetSessionId_001",
148 "com.xxx.hmxx", "ndkxx", &avsession);
149 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
150 const char* sessionId;
151 ret = OH_AVSession_GetSessionId(avsession, &sessionId);
152 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
153 ret = OH_AVSession_Destroy(avsession);
154 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
155 }
156
157 /**
158 * @tc.name: OH_AVSession_SetAVMetadata_001
159 * @tc.desc: SetAVMetadata from the class of ohavsession
160 * @tc.type: FUNC
161 * @tc.require: none
162 */
163 HWTEST(OHAVSessionTest, OH_AVSession_SetAVMetadata_001, TestSize.Level0)
164 {
165 OH_AVSession* avsession = nullptr;
166 const uint64_t DURATION = 40000;
167 const int32_t TAGS = 1;
168 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "OH_AVSession_SetAVMetadata_001",
169 "com.xxx.hmxx", "ndkxx", &avsession);
170 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
171 OH_AVMetadataBuilder *builder;
172 OH_AVMetadata *ohMetaData;
173 AVMetadata_Result res;
174 res = OH_AVMetadataBuilder_Create(&builder);
175 EXPECT_EQ(res, AVMETADATA_SUCCESS);
176 OH_AVMetadataBuilder_SetTitle(builder, "UNIT TEST");
177 OH_AVMetadataBuilder_SetArtist(builder, "Anonymous artist");
178 OH_AVMetadataBuilder_SetAuthor(builder, "Anonymous author");
179 OH_AVMetadataBuilder_SetAlbum(builder, "Anonymous album");
180 OH_AVMetadataBuilder_SetWriter(builder, "Anonymous writer");
181 OH_AVMetadataBuilder_SetComposer(builder, "Anonymous composer");
182 OH_AVMetadataBuilder_SetDuration(builder, DURATION);
183 OH_AVMetadataBuilder_SetMediaImageUri(builder, "https://xxx.xxx.xx");
184 OH_AVMetadataBuilder_SetSubtitle(builder, "fac");
185 OH_AVMetadataBuilder_SetDescription(builder, "For somebody");
186 OH_AVMetadataBuilder_SetLyric(builder, "balabala");
187 OH_AVMetadataBuilder_SetAssetId(builder, "999");
188 OH_AVMetadataBuilder_SetSkipIntervals(builder, SECONDS_30);
189 OH_AVMetadataBuilder_SetDisplayTags(builder, TAGS);
190 OH_AVMetadataBuilder_GenerateAVMetadata(builder, &ohMetaData);
191
192 ret = OH_AVSession_SetAVMetadata(avsession, ohMetaData);
193 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
194 ret = OH_AVSession_Destroy(avsession);
195 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
196 OH_AVMetadata_Destroy(ohMetaData);
197 OH_AVMetadataBuilder_Destroy(builder);
198 }
199
200 /**
201 * @tc.name: OH_AVSession_SetPlaybackState_001
202 * @tc.desc: SetPlaybackState from the class of ohavsession
203 * @tc.type: FUNC
204 * @tc.require: none
205 */
206 HWTEST(OHAVSessionTest, OH_AVSession_SetPlaybackState_001, TestSize.Level0)
207 {
208 OH_AVSession* avsession = nullptr;
209 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "OH_AVSession_SetPlaybackState_001",
210 "com.xxx.hmxx", "ndkxx", &avsession);
211 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
212 AVSession_PlaybackState state = PLAYBACK_STATE_PREPARING;
213 ret = OH_AVSession_SetPlaybackState(avsession, state);
214 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
215 ret = OH_AVSession_Destroy(avsession);
216 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
217 }
218
219 /**
220 * @tc.name: OH_AVSession_SetPlaybackState_002
221 * @tc.desc: SetPlaybackState from the class of ohavsession
222 * @tc.type: FUNC
223 * @tc.require: none
224 */
225 HWTEST(OHAVSessionTest, OH_AVSession_SetPlaybackState_002, TestSize.Level0)
226 {
227 OH_AVSession* avsession = nullptr;
228 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "OH_AVSession_SetPlaybackState_001",
229 "com.xxx.hmxx", "ndkxx", &avsession);
230 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
231 AVSession_PlaybackState state = PLAYBACK_STATE_MAX;
232 ret = OH_AVSession_SetPlaybackState(avsession, state);
233 EXPECT_EQ(ret, AV_SESSION_ERR_INVALID_PARAMETER);
234 ret = OH_AVSession_Destroy(avsession);
235 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
236 }
237
238 /**
239 * @tc.name: OH_AVSession_SetPlaybackPosition_001
240 * @tc.desc: SetPlaybackPosition from the class of ohavsession
241 * @tc.type: FUNC
242 * @tc.require: none
243 */
244 HWTEST(OHAVSessionTest, OH_AVSession_SetPlaybackPosition_001, TestSize.Level0)
245 {
246 OH_AVSession* avsession = nullptr;
247 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "OH_AVSession_SetPlaybackPosition_001",
248 "com.xxx.hmxx", "ndkxx", &avsession);
249 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
250 AVSession_PlaybackPosition* playbackPosition = new AVSession_PlaybackPosition;
251 playbackPosition->elapsedTime = 1;
252 playbackPosition->updateTime = 2;
253 ret = OH_AVSession_SetPlaybackPosition(avsession, playbackPosition);
254 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
255 ret = OH_AVSession_Destroy(avsession);
256 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
257 }
258
259 /**
260 * @tc.name: OH_AVSession_SetFavorite_001
261 * @tc.desc: SetFavorite from the class of ohavsession
262 * @tc.type: FUNC
263 * @tc.require: none
264 */
265 HWTEST(OHAVSessionTest, OH_AVSession_SetFavorite_001, TestSize.Level0)
266 {
267 OH_AVSession* avsession = nullptr;
268 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "oh_av_session_test_001",
269 "com.xxx.hmxx", "ndkxx", &avsession);
270 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
271 bool isFavorite = true;
272 ret = OH_AVSession_SetFavorite(avsession, isFavorite);
273 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
274 ret = OH_AVSession_Destroy(avsession);
275 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
276 }
277
278 /**
279 * @tc.name: OH_AVSession_SetLoopMode_001
280 * @tc.desc: SetLoopMode from the class of ohavsession
281 * @tc.type: FUNC
282 * @tc.require: none
283 */
284 HWTEST(OHAVSessionTest, OH_AVSession_SetLoopMode_001, TestSize.Level0)
285 {
286 OH_AVSession* avsession = nullptr;
287 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "oh_av_session_test_001",
288 "com.xxx.hmxx", "ndkxx", &avsession);
289 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
290 AVSession_LoopMode loopMode = LOOP_MODE_SINGLE;
291 ret = OH_AVSession_SetLoopMode(avsession, loopMode);
292 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
293 ret = OH_AVSession_Destroy(avsession);
294 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
295 }
296
297 /**
298 * @tc.name: OH_AVSession_RegisterCommandCallback_001
299 * @tc.desc: RegisterCommandCallback from the class of ohavsession
300 * @tc.type: FUNC
301 * @tc.require: none
302 */
303 HWTEST(OHAVSessionTest, OH_AVSession_RegisterCommandCallback_001, TestSize.Level0)
304 {
305 OH_AVSession* avsession = nullptr;
306 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "RegisterCommandCallback_001",
307 "com.xxx.hmxx", "ndkxx", &avsession);
308 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
309 AVSession_ControlCommand command = CONTROL_CMD_PLAY;
310 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
311 void* userData) -> AVSessionCallback_Result
__anonea2c80190102(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 312 {
313 return AVSESSION_CALLBACK_RESULT_SUCCESS;
314 };
315 int userData = 1;
316 ret = OH_AVSession_RegisterCommandCallback(avsession, command, callback, (void *)(&userData));
317 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
318 ret = OH_AVSession_Destroy(avsession);
319 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
320 }
321
322 /**
323 * @tc.name: OH_AVSession_RegisterCommandCallback_002
324 * @tc.desc: RegisterCommandCallback from the class of ohavsession
325 * @tc.type: FUNC
326 * @tc.require: none
327 */
328 HWTEST(OHAVSessionTest, OH_AVSession_RegisterCommandCallback_002, TestSize.Level0)
329 {
330 OH_AVSession* avsession = nullptr;
331 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "OH_AVSession_RegisterCommandCallback_002",
332 "com.xxx.hmxx", "ndkxx", &avsession);
333 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
334 AVSession_ControlCommand command = CONTROL_CMD_PAUSE;
335 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
336 void* userData) -> AVSessionCallback_Result
__anonea2c80190202(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 337 {
338 return AVSESSION_CALLBACK_RESULT_SUCCESS;
339 };
340 int userData = 1;
341 ret = OH_AVSession_RegisterCommandCallback(avsession, command, callback, (void *)(&userData));
342 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
343 ret = OH_AVSession_Destroy(avsession);
344 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
345 }
346
347 /**
348 * @tc.name: OH_AVSession_RegisterCommandCallback_003
349 * @tc.desc: RegisterCommandCallback from the class of ohavsession
350 * @tc.type: FUNC
351 * @tc.require: none
352 */
353 HWTEST(OHAVSessionTest, OH_AVSession_RegisterCommandCallback_003, TestSize.Level0)
354 {
355 OH_AVSession* avsession = nullptr;
356 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "OH_AVSession_RegisterCommandCallback_003",
357 "com.xxx.hmxx", "ndkxx", &avsession);
358 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
359 AVSession_ControlCommand command = CONTROL_CMD_STOP;
360 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
361 void* userData) -> AVSessionCallback_Result
__anonea2c80190302(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 362 {
363 return AVSESSION_CALLBACK_RESULT_SUCCESS;
364 };
365 int userData = 1;
366 ret = OH_AVSession_RegisterCommandCallback(avsession, command, callback, (void *)(&userData));
367 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
368 ret = OH_AVSession_Destroy(avsession);
369 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
370 }
371
372 /**
373 * @tc.name: OH_AVSession_RegisterCommandCallback_004
374 * @tc.desc: RegisterCommandCallback from the class of ohavsession
375 * @tc.type: FUNC
376 * @tc.require: none
377 */
378 HWTEST(OHAVSessionTest, OH_AVSession_RegisterCommandCallback_004, TestSize.Level0)
379 {
380 OH_AVSession* avsession = nullptr;
381 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "OH_AVSession_RegisterCommandCallback_004",
382 "com.xxx.hmxx", "ndkxx", &avsession);
383 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
384 AVSession_ControlCommand command = CONTROL_CMD_PLAY_NEXT;
385 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
386 void* userData) -> AVSessionCallback_Result
__anonea2c80190402(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 387 {
388 return AVSESSION_CALLBACK_RESULT_SUCCESS;
389 };
390 int userData = 1;
391 ret = OH_AVSession_RegisterCommandCallback(avsession, command, callback, (void *)(&userData));
392 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
393 ret = OH_AVSession_Destroy(avsession);
394 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
395 }
396
397 /**
398 * @tc.name: OH_AVSession_RegisterCommandCallback_005
399 * @tc.desc: RegisterCommandCallback from the class of ohavsession
400 * @tc.type: FUNC
401 * @tc.require: none
402 */
403 HWTEST(OHAVSessionTest, OH_AVSession_RegisterCommandCallback_005, TestSize.Level0)
404 {
405 OH_AVSession* avsession = nullptr;
406 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "OH_AVSession_RegisterCommandCallback_005",
407 "com.xxx.hmxx", "ndkxx", &avsession);
408 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
409 AVSession_ControlCommand command = CONTROL_CMD_PLAY_PREVIOUS;
410 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
411 void* userData) -> AVSessionCallback_Result
__anonea2c80190502(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 412 {
413 return AVSESSION_CALLBACK_RESULT_SUCCESS;
414 };
415 int userData = 1;
416 ret = OH_AVSession_RegisterCommandCallback(avsession, command, callback, (void *)(&userData));
417 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
418 ret = OH_AVSession_Destroy(avsession);
419 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
420 }
421
422 /**
423 * @tc.name: OH_AVSession_RegisterCommandCallback_006
424 * @tc.desc: RegisterCommandCallback from the class of ohavsession
425 * @tc.type: FUNC
426 * @tc.require: none
427 */
428 HWTEST(OHAVSessionTest, OH_AVSession_RegisterCommandCallback_006, TestSize.Level0)
429 {
430 OH_AVSession* avsession = nullptr;
431 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "OH_AVSession_RegisterCommandCallback_006",
432 "com.xxx.hmxx", "ndkxx", &avsession);
433 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
434 AVSession_ControlCommand command = CONTROL_CMD_INVALID;
435 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
436 void* userData) -> AVSessionCallback_Result
__anonea2c80190602(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 437 {
438 return AVSESSION_CALLBACK_RESULT_SUCCESS;
439 };
440 int userData = 1;
441 ret = OH_AVSession_RegisterCommandCallback(avsession, command, callback, (void *)(&userData));
442 EXPECT_EQ(ret, AV_SESSION_ERR_CODE_COMMAND_INVALID);
443 ret = OH_AVSession_Destroy(avsession);
444 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
445 }
446
447 /**
448 * @tc.name: OH_AVSession_UnregisterCommandCallback_001
449 * @tc.desc: UnregisterCommandCallback from the class of ohavsession
450 * @tc.type: FUNC
451 * @tc.require: none
452 */
453 HWTEST(OHAVSessionTest, OH_AVSession_UnregisterCommandCallback_001, TestSize.Level0)
454 {
455 OH_AVSession* avsession = nullptr;
456 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "UnregisterCommandCallback_001",
457 "com.xxx.hmxx", "ndkxx", &avsession);
458 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
459 AVSession_ControlCommand command = CONTROL_CMD_PLAY;
460 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
461 void* userData) -> AVSessionCallback_Result
__anonea2c80190702(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 462 {
463 return AVSESSION_CALLBACK_RESULT_SUCCESS;
464 };
465 ret = OH_AVSession_UnregisterCommandCallback(avsession, command, callback);
466 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
467 ret = OH_AVSession_Destroy(avsession);
468 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
469 }
470
471 /**
472 * @tc.name: OH_AVSession_UnregisterCommandCallback_002
473 * @tc.desc: UnregisterCommandCallback from the class of ohavsession
474 * @tc.type: FUNC
475 * @tc.require: none
476 */
477 HWTEST(OHAVSessionTest, OH_AVSession_UnregisterCommandCallback_002, TestSize.Level0)
478 {
479 OH_AVSession* avsession = nullptr;
480 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "OH_AVSession_UnregisterCommandCallback_002",
481 "com.xxx.hmxx", "ndkxx", &avsession);
482 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
483 AVSession_ControlCommand command = CONTROL_CMD_PAUSE;
484 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
485 void* userData) -> AVSessionCallback_Result
__anonea2c80190802(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 486 {
487 return AVSESSION_CALLBACK_RESULT_SUCCESS;
488 };
489 ret = OH_AVSession_UnregisterCommandCallback(avsession, command, callback);
490 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
491 ret = OH_AVSession_Destroy(avsession);
492 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
493 }
494
495 /**
496 * @tc.name: OH_AVSession_UnregisterCommandCallback_003
497 * @tc.desc: UnregisterCommandCallback from the class of ohavsession
498 * @tc.type: FUNC
499 * @tc.require: none
500 */
501 HWTEST(OHAVSessionTest, OH_AVSession_UnregisterCommandCallback_003, TestSize.Level0)
502 {
503 OH_AVSession* avsession = nullptr;
504 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "OH_AVSession_UnregisterCommandCallback_003",
505 "com.xxx.hmxx", "ndkxx", &avsession);
506 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
507 AVSession_ControlCommand command = CONTROL_CMD_STOP;
508 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
509 void* userData) -> AVSessionCallback_Result
__anonea2c80190902(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 510 {
511 return AVSESSION_CALLBACK_RESULT_SUCCESS;
512 };
513 ret = OH_AVSession_UnregisterCommandCallback(avsession, command, callback);
514 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
515 ret = OH_AVSession_Destroy(avsession);
516 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
517 }
518
519 /**
520 * @tc.name: OH_AVSession_UnregisterCommandCallback_004
521 * @tc.desc: UnregisterCommandCallback from the class of ohavsession
522 * @tc.type: FUNC
523 * @tc.require: none
524 */
525 HWTEST(OHAVSessionTest, OH_AVSession_UnregisterCommandCallback_004, TestSize.Level0)
526 {
527 OH_AVSession* avsession = nullptr;
528 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "OH_AVSession_UnregisterCommandCallback_004",
529 "com.xxx.hmxx", "ndkxx", &avsession);
530 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
531 AVSession_ControlCommand command = CONTROL_CMD_PLAY_NEXT;
532 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
533 void* userData) -> AVSessionCallback_Result
__anonea2c80190a02(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 534 {
535 return AVSESSION_CALLBACK_RESULT_SUCCESS;
536 };
537 ret = OH_AVSession_UnregisterCommandCallback(avsession, command, callback);
538 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
539 ret = OH_AVSession_Destroy(avsession);
540 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
541 }
542
543 /**
544 * @tc.name: OH_AVSession_UnregisterCommandCallback_005
545 * @tc.desc: UnregisterCommandCallback from the class of ohavsession
546 * @tc.type: FUNC
547 * @tc.require: none
548 */
549 HWTEST(OHAVSessionTest, OH_AVSession_UnregisterCommandCallback_005, TestSize.Level0)
550 {
551 OH_AVSession* avsession = nullptr;
552 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "OH_AVSession_UnregisterCommandCallback_005",
553 "com.xxx.hmxx", "ndkxx", &avsession);
554 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
555 AVSession_ControlCommand command = CONTROL_CMD_PLAY_PREVIOUS;
556 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
557 void* userData) -> AVSessionCallback_Result
__anonea2c80190b02(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 558 {
559 return AVSESSION_CALLBACK_RESULT_SUCCESS;
560 };
561 ret = OH_AVSession_UnregisterCommandCallback(avsession, command, callback);
562 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
563 ret = OH_AVSession_Destroy(avsession);
564 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
565 }
566
567 /**
568 * @tc.name: OH_AVSession_UnregisterCommandCallback_006
569 * @tc.desc: UnregisterCommandCallback from the class of ohavsession
570 * @tc.type: FUNC
571 * @tc.require: none
572 */
573 HWTEST(OHAVSessionTest, OH_AVSession_UnregisterCommandCallback_006, TestSize.Level0)
574 {
575 OH_AVSession* avsession = nullptr;
576 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "OH_AVSession_UnregisterCommandCallback_006",
577 "com.xxx.hmxx", "ndkxx", &avsession);
578 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
579 AVSession_ControlCommand command = CONTROL_CMD_INVALID;
580 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
581 void* userData) -> AVSessionCallback_Result
__anonea2c80190c02(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 582 {
583 return AVSESSION_CALLBACK_RESULT_SUCCESS;
584 };
585 ret = OH_AVSession_UnregisterCommandCallback(avsession, command, callback);
586 EXPECT_EQ(ret, AV_SESSION_ERR_CODE_COMMAND_INVALID);
587 ret = OH_AVSession_Destroy(avsession);
588 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
589 }
590
591 /**
592 * @tc.name: OH_AVSession_RegisterForwardCallback_001
593 * @tc.desc: RegisterForwardCallback from the class of ohavsession
594 * @tc.type: FUNC
595 * @tc.require: none
596 */
597 HWTEST(OHAVSessionTest, OH_AVSession_RegisterForwardCallback_001, TestSize.Level0)
598 {
599 OH_AVSession* avsession = nullptr;
600 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "oh_av_session_test_001",
601 "com.xxx.hmxx", "ndkxx", &avsession);
602 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
603 OH_AVSessionCallback_OnFastForward callback = [](OH_AVSession* session, uint32_t seekTime,
604 void* userData) -> AVSessionCallback_Result
__anonea2c80190d02(OH_AVSession* session, uint32_t seekTime, void* userData) 605 {
606 return AVSESSION_CALLBACK_RESULT_SUCCESS;
607 };
608 int userData = 1;
609 ret = OH_AVSession_RegisterForwardCallback(avsession, callback, (void *)(&userData));
610 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
611 ret = OH_AVSession_Destroy(avsession);
612 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
613 }
614
615 /**
616 * @tc.name: OH_AVSession_UnregisterForwardCallback_001
617 * @tc.desc: UnregisterForwardCallback from the class of ohavsession
618 * @tc.type: FUNC
619 * @tc.require: none
620 */
621 HWTEST(OHAVSessionTest, OH_AVSession_UnregisterForwardCallback_001, TestSize.Level0)
622 {
623 OH_AVSession* avsession = nullptr;
624 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "oh_av_session_test_001",
625 "com.xxx.hmxx", "ndkxx", &avsession);
626 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
627 OH_AVSessionCallback_OnFastForward callback = [](OH_AVSession* session, uint32_t seekTime,
628 void* userData) -> AVSessionCallback_Result
__anonea2c80190e02(OH_AVSession* session, uint32_t seekTime, void* userData) 629 {
630 return AVSESSION_CALLBACK_RESULT_SUCCESS;
631 };
632 int userData = 1;
633 ret = OH_AVSession_RegisterForwardCallback(avsession, callback, (void *)(&userData));
634 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
635 ret = OH_AVSession_UnregisterForwardCallback(avsession, callback);
636 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
637 ret = OH_AVSession_Destroy(avsession);
638 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
639 }
640
641 /**
642 * @tc.name: OH_AVSession_RegisterRewindCallback_001
643 * @tc.desc: RegisterRewindCallback from the class of ohavsession
644 * @tc.type: FUNC
645 * @tc.require: none
646 */
647 HWTEST(OHAVSessionTest, OH_AVSession_RegisterRewindCallback_001, TestSize.Level0)
648 {
649 OH_AVSession* avsession = nullptr;
650 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "oh_av_session_test_001",
651 "com.xxx.hmxx", "ndkxx", &avsession);
652 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
653 OH_AVSessionCallback_OnRewind callback = [](OH_AVSession* session, uint32_t seekTime,
654 void* userData) -> AVSessionCallback_Result
__anonea2c80190f02(OH_AVSession* session, uint32_t seekTime, void* userData) 655 {
656 return AVSESSION_CALLBACK_RESULT_SUCCESS;
657 };
658 int userData = 1;
659 ret = OH_AVSession_RegisterRewindCallback(avsession, callback, (void *)(&userData));
660 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
661 ret = OH_AVSession_Destroy(avsession);
662 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
663 }
664
665 /**
666 * @tc.name: OH_AVSession_UnregisterRewindCallback_001
667 * @tc.desc: UnregisterRewindCallback from the class of ohavsession
668 * @tc.type: FUNC
669 * @tc.require: none
670 */
671 HWTEST(OHAVSessionTest, OH_AVSession_UnregisterRewindCallback_001, TestSize.Level0)
672 {
673 OH_AVSession* avsession = nullptr;
674 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "oh_av_session_test_001",
675 "com.xxx.hmxx", "ndkxx", &avsession);
676 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
677 OH_AVSessionCallback_OnRewind callback = [](OH_AVSession* session, uint32_t seekTime,
678 void* userData) -> AVSessionCallback_Result
__anonea2c80191002(OH_AVSession* session, uint32_t seekTime, void* userData) 679 {
680 return AVSESSION_CALLBACK_RESULT_SUCCESS;
681 };
682 int userData = 1;
683 ret = OH_AVSession_RegisterRewindCallback(avsession, callback, (void *)(&userData));
684 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
685 ret = OH_AVSession_UnregisterRewindCallback(avsession, callback);
686 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
687 ret = OH_AVSession_Destroy(avsession);
688 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
689 }
690
691 /**
692 * @tc.name: OH_AVSession_RegisterSeekCallback_001
693 * @tc.desc: RegisterSeekCallback from the class of ohavsession
694 * @tc.type: FUNC
695 * @tc.require: none
696 */
697 HWTEST(OHAVSessionTest, OH_AVSession_RegisterSeekCallback_001, TestSize.Level0)
698 {
699 OH_AVSession* avsession = nullptr;
700 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "oh_av_session_test_001",
701 "com.xxx.hmxx", "ndkxx", &avsession);
702 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
703 OH_AVSessionCallback_OnSeek callback = [](OH_AVSession* session, uint64_t seekTime,
704 void* userData) -> AVSessionCallback_Result
__anonea2c80191102(OH_AVSession* session, uint64_t seekTime, void* userData) 705 {
706 return AVSESSION_CALLBACK_RESULT_SUCCESS;
707 };
708 int userData = 1;
709 ret = OH_AVSession_RegisterSeekCallback(avsession, callback, (void *)(&userData));
710 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
711 ret = OH_AVSession_Destroy(avsession);
712 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
713 }
714
715 /**
716 * @tc.name: OH_AVSession_UnregisterSeekCallback_001
717 * @tc.desc: UnregisterSeekCallback from the class of ohavsession
718 * @tc.type: FUNC
719 * @tc.require: none
720 */
721 HWTEST(OHAVSessionTest, OH_AVSession_UnregisterSeekCallback_001, TestSize.Level0)
722 {
723 OH_AVSession* avsession = nullptr;
724 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "oh_av_session_test_001",
725 "com.xxx.hmxx", "ndkxx", &avsession);
726 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
727 OH_AVSessionCallback_OnSeek callback = [](OH_AVSession* session, uint64_t seekTime,
728 void* userData) -> AVSessionCallback_Result
__anonea2c80191202(OH_AVSession* session, uint64_t seekTime, void* userData) 729 {
730 return AVSESSION_CALLBACK_RESULT_SUCCESS;
731 };
732 int userData = 1;
733 ret = OH_AVSession_RegisterSeekCallback(avsession, callback, (void *)(&userData));
734 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
735 ret = OH_AVSession_UnregisterSeekCallback(avsession, callback);
736 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
737 ret = OH_AVSession_Destroy(avsession);
738 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
739 }
740
741 /**
742 * @tc.name: OH_AVSession_RegisterSetLoopModeCallback_001
743 * @tc.desc: RegisterSetLoopModeCallback from the class of ohavsession
744 * @tc.type: FUNC
745 * @tc.require: none
746 */
747 HWTEST(OHAVSessionTest, OH_AVSession_RegisterSetLoopModeCallback_001, TestSize.Level0)
748 {
749 OH_AVSession* avsession = nullptr;
750 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "oh_av_session_test_001",
751 "com.xxx.hmxx", "ndkxx", &avsession);
752 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
753 OH_AVSessionCallback_OnSetLoopMode callback = [](OH_AVSession* session, AVSession_LoopMode curLoopMode,
754 void* userData) -> AVSessionCallback_Result
__anonea2c80191302(OH_AVSession* session, AVSession_LoopMode curLoopMode, void* userData) 755 {
756 return AVSESSION_CALLBACK_RESULT_SUCCESS;
757 };
758 int userData = 1;
759 ret = OH_AVSession_RegisterSetLoopModeCallback(avsession, callback, (void *)(&userData));
760 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
761 ret = OH_AVSession_Destroy(avsession);
762 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
763 }
764
765 /**
766 * @tc.name: OH_AVSession_UnregisterSetLoopModeCallback_001
767 * @tc.desc: UnregisterSetLoopModeCallback from the class of ohavsession
768 * @tc.type: FUNC
769 * @tc.require: none
770 */
771 HWTEST(OHAVSessionTest, OH_AVSession_UnregisterSetLoopModeCallback_001, TestSize.Level0)
772 {
773 OH_AVSession* avsession = nullptr;
774 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "oh_av_session_test_001",
775 "com.xxx.hmxx", "ndkxx", &avsession);
776 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
777 OH_AVSessionCallback_OnSetLoopMode callback = [](OH_AVSession* session, AVSession_LoopMode curLoopMode,
778 void* userData) -> AVSessionCallback_Result
__anonea2c80191402(OH_AVSession* session, AVSession_LoopMode curLoopMode, void* userData) 779 {
780 return AVSESSION_CALLBACK_RESULT_SUCCESS;
781 };
782 int userData = 1;
783 ret = OH_AVSession_RegisterSetLoopModeCallback(avsession, callback, (void *)(&userData));
784 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
785 ret = OH_AVSession_UnregisterSetLoopModeCallback(avsession, callback);
786 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
787 ret = OH_AVSession_Destroy(avsession);
788 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
789 }
790
791 /**
792 * @tc.name: OH_AVSession_RegisterToggleFavoriteCallback_001
793 * @tc.desc: RegisterToggleFavoriteCallback from the class of ohavsession
794 * @tc.type: FUNC
795 * @tc.require: none
796 */
797 HWTEST(OHAVSessionTest, OH_AVSession_RegisterToggleFavoriteCallback_001, TestSize.Level0)
798 {
799 OH_AVSession* avsession = nullptr;
800 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "oh_av_session_test_001",
801 "com.xxx.hmxx", "ndkxx", &avsession);
802 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
803 OH_AVSessionCallback_OnToggleFavorite callback = [](OH_AVSession* session, const char* assetId,
804 void* userData) -> AVSessionCallback_Result
__anonea2c80191502(OH_AVSession* session, const char* assetId, void* userData) 805 {
806 return AVSESSION_CALLBACK_RESULT_SUCCESS;
807 };
808 int userData = 1;
809 ret = OH_AVSession_RegisterToggleFavoriteCallback(avsession, callback, (void *)(&userData));
810 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
811 ret = OH_AVSession_Destroy(avsession);
812 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
813 }
814
815 /**
816 * @tc.name: OH_AVSession_UnregisterToggleFavoriteCallback_001
817 * @tc.desc: Unregister Toggle Favorite Callback from the class of ohavsession
818 * @tc.type: FUNC
819 * @tc.require: none
820 */
821 HWTEST(OHAVSessionTest, OH_AVSession_UnregisterToggleFavoriteCallback_001, TestSize.Level0)
822 {
823 OH_AVSession* avsession = nullptr;
824 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "oh_av_session_test_001",
825 "com.xxx.hmxx", "ndkxx", &avsession);
826 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
827 OH_AVSessionCallback_OnToggleFavorite callback = [](OH_AVSession* session, const char* assetId,
828 void* userData) -> AVSessionCallback_Result
__anonea2c80191602(OH_AVSession* session, const char* assetId, void* userData) 829 {
830 return AVSESSION_CALLBACK_RESULT_SUCCESS;
831 };
832 int userData = 1;
833 ret = OH_AVSession_RegisterToggleFavoriteCallback(avsession, callback, (void *)(&userData));
834 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
835 ret = OH_AVSession_UnregisterToggleFavoriteCallback(avsession, callback);
836 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
837 ret = OH_AVSession_Destroy(avsession);
838 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
839 }
840
841 /**
842 * @tc.name: GetEncodeErrcode001
843 * @tc.desc: Test GetEncodeErrcode with an error code that is not in the errcodes map.
844 * @tc.type: FUNC
845 * @tc.require: none
846 */
847 HWTEST(OHAVSessionTest, GetEncodeErrcode_001, TestSize.Level0)
848 {
849 auto oHAVSession = std::make_shared<OHAVSession>();
850 int32_t invalidErrorCode = 9999999;
851 AVSession_ErrCode result = oHAVSession->GetEncodeErrcode(invalidErrorCode);
852 EXPECT_EQ(result, AV_SESSION_ERR_SERVICE_EXCEPTION);
853 }
854
855 /**
856 * @tc.name: OHAVSession_GetSessionId_001
857 * @tc.desc: Test GetSessionId without entering the if branch by setting sessionId_ to a non-empty value.
858 * @tc.type: FUNC
859 * @tc.require: none
860 */
861 HWTEST(OHAVSessionTest, OHAVSession_GetSessionId_001, TestSize.Level0)
862 {
863 AVSession_Type sessionType = SESSION_TYPE_VIDEO;
864 const char* sessionTag = "1";
865 const char* bundleName = "2";
866 const char* abilityName = "3";
867 auto oHAVSession = std::make_shared<OHAVSession>(sessionType, sessionTag, bundleName, abilityName);
868
869 const std::string preSetSessionId = "predefined_session_id";
870 oHAVSession->sessionId_ = preSetSessionId;
871
872 const std::string& sessionId = oHAVSession->GetSessionId();
873 EXPECT_EQ(sessionId, preSetSessionId);
874 }
875
876 /**
877 * @tc.name: RegisterCommandCallback001
878 * @tc.desc: Test RegisterCommandCallback.
879 * @tc.type: FUNC
880 * @tc.require: none
881 */
882 HWTEST(OHAVSessionTest, RegisterCommandCallback_001, TestSize.Level0)
883 {
884 AVSession_Type sessionType = SESSION_TYPE_VIDEO;
885 const char* sessionTag = "1";
886 const char* bundleName = "2";
887 const char* abilityName = "3";
888 auto oHAVSession = std::make_shared<OHAVSession>(sessionType, sessionTag, bundleName, abilityName);
889 AVSession_ControlCommand command = CONTROL_CMD_INVALID;
890 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
891 void* userData) -> AVSessionCallback_Result
__anonea2c80191702(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 892 {
893 return AVSESSION_CALLBACK_RESULT_SUCCESS;
894 };
895 int userData = 1;
896 AVSession_ErrCode result = oHAVSession->RegisterCommandCallback(command, callback, (void *)(&userData));
897 EXPECT_EQ(result, AV_SESSION_ERR_SERVICE_EXCEPTION);
898 }
899
900 /**
901 * @tc.name: RegisterCommandCallback002
902 * @tc.desc: Test RegisterCommandCallback.
903 * @tc.type: FUNC
904 * @tc.require: none
905 */
906 HWTEST(OHAVSessionTest, RegisterCommandCallback_002, TestSize.Level0)
907 {
908 AVSession_Type sessionType = SESSION_TYPE_VIDEO;
909 const char* sessionTag = "1";
910 const char* bundleName = "2";
911 const char* abilityName = "3";
912 auto oHAVSession = std::make_shared<OHAVSession>(sessionType, sessionTag, bundleName, abilityName);
913 AVSession_ControlCommand command = CONTROL_CMD_PLAY;
914 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
915 void* userData) -> AVSessionCallback_Result
__anonea2c80191802(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 916 {
917 return AVSESSION_CALLBACK_RESULT_SUCCESS;
918 };
919 int userData = 1;
920 oHAVSession->ohAVSessionCallbackImpl_ = std::make_shared<OHAVSessionCallbackImpl>();
921 AVSession_ErrCode result = oHAVSession->RegisterCommandCallback(command, callback, (void *)(&userData));
922 EXPECT_EQ(result, AV_SESSION_ERR_SUCCESS);
923 }
924
925 /**
926 * @tc.name: UnregisterCommandCallback001
927 * @tc.desc: Test UnregisterCommandCallback.
928 * @tc.type: FUNC
929 * @tc.require: none
930 */
931 HWTEST(OHAVSessionTest, UnregisterCommandCallback_001, TestSize.Level0)
932 {
933 AVSession_Type sessionType = SESSION_TYPE_VIDEO;
934 const char* sessionTag = "1";
935 const char* bundleName = "2";
936 const char* abilityName = "3";
937 auto oHAVSession = std::make_shared<OHAVSession>(sessionType, sessionTag, bundleName, abilityName);
938 AVSession_ControlCommand command = CONTROL_CMD_PLAY;
939 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
940 void* userData) -> AVSessionCallback_Result
__anonea2c80191902(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 941 {
942 return AVSESSION_CALLBACK_RESULT_SUCCESS;
943 };
944 int32_t code = 1;
945 AVSession_ErrCode ret = oHAVSession->GetEncodeErrcode(code);
946 EXPECT_EQ(ret, AV_SESSION_ERR_SERVICE_EXCEPTION);
947 oHAVSession->ohAVSessionCallbackImpl_ = std::make_shared<OHAVSessionCallbackImpl>();
948 AVSession_ErrCode result = oHAVSession->UnregisterCommandCallback(command, callback);
949 EXPECT_EQ(result, AV_SESSION_ERR_SUCCESS);
950 }
951
952 /**
953 * @tc.name: UnregisterCommandCallback002
954 * @tc.desc: Test UnregisterCommandCallback.
955 * @tc.type: FUNC
956 * @tc.require: none
957 */
958 HWTEST(OHAVSessionTest, UnregisterCommandCallback_002, TestSize.Level0)
959 {
960 AVSession_Type sessionType = SESSION_TYPE_VIDEO;
961 const char* sessionTag = "1";
962 const char* bundleName = "2";
963 const char* abilityName = "3";
964 auto oHAVSession = std::make_shared<OHAVSession>(sessionType, sessionTag, bundleName, abilityName);
965 AVSession_ControlCommand command = CONTROL_CMD_PAUSE;
966 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
967 void* userData) -> AVSessionCallback_Result
__anonea2c80191a02(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 968 {
969 return AVSESSION_CALLBACK_RESULT_SUCCESS;
970 };
971 oHAVSession->ohAVSessionCallbackImpl_ = std::make_shared<OHAVSessionCallbackImpl>();
972 AVSession_ErrCode result = oHAVSession->UnregisterCommandCallback(command, callback);
973 EXPECT_EQ(result, AV_SESSION_ERR_SUCCESS);
974 }
975
976 /**
977 * @tc.name: UnregisterCommandCallback003
978 * @tc.desc: Test UnregisterCommandCallback.
979 * @tc.type: FUNC
980 * @tc.require: none
981 */
982 HWTEST(OHAVSessionTest, UnregisterCommandCallback_003, TestSize.Level0)
983 {
984 AVSession_Type sessionType = SESSION_TYPE_VIDEO;
985 const char* sessionTag = "1";
986 const char* bundleName = "2";
987 const char* abilityName = "3";
988 auto oHAVSession = std::make_shared<OHAVSession>(sessionType, sessionTag, bundleName, abilityName);
989 AVSession_ControlCommand command = CONTROL_CMD_STOP;
990 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
991 void* userData) -> AVSessionCallback_Result
__anonea2c80191b02(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 992 {
993 return AVSESSION_CALLBACK_RESULT_SUCCESS;
994 };
995 oHAVSession->ohAVSessionCallbackImpl_ = std::make_shared<OHAVSessionCallbackImpl>();
996 AVSession_ErrCode result = oHAVSession->UnregisterCommandCallback(command, callback);
997 EXPECT_EQ(result, AV_SESSION_ERR_SUCCESS);
998 }
999
1000 /**
1001 * @tc.name: UnregisterCommandCallback004
1002 * @tc.desc: Test UnregisterCommandCallback.
1003 * @tc.type: FUNC
1004 * @tc.require: none
1005 */
1006 HWTEST(OHAVSessionTest, UnregisterCommandCallback_004, TestSize.Level0)
1007 {
1008 AVSession_Type sessionType = SESSION_TYPE_VIDEO;
1009 const char* sessionTag = "1";
1010 const char* bundleName = "2";
1011 const char* abilityName = "3";
1012 auto oHAVSession = std::make_shared<OHAVSession>(sessionType, sessionTag, bundleName, abilityName);
1013 AVSession_ControlCommand command = CONTROL_CMD_PLAY_NEXT;
1014 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
1015 void* userData) -> AVSessionCallback_Result
__anonea2c80191c02(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 1016 {
1017 return AVSESSION_CALLBACK_RESULT_SUCCESS;
1018 };
1019 oHAVSession->ohAVSessionCallbackImpl_ = std::make_shared<OHAVSessionCallbackImpl>();
1020 AVSession_ErrCode result = oHAVSession->UnregisterCommandCallback(command, callback);
1021 EXPECT_EQ(result, AV_SESSION_ERR_SUCCESS);
1022 }
1023
1024 /**
1025 * @tc.name: UnregisterCommandCallback005
1026 * @tc.desc: Test UnregisterCommandCallback.
1027 * @tc.type: FUNC
1028 * @tc.require: none
1029 */
1030 HWTEST(OHAVSessionTest, UnregisterCommandCallback_005, TestSize.Level0)
1031 {
1032 AVSession_Type sessionType = SESSION_TYPE_VIDEO;
1033 const char* sessionTag = "1";
1034 const char* bundleName = "2";
1035 const char* abilityName = "3";
1036 auto oHAVSession = std::make_shared<OHAVSession>(sessionType, sessionTag, bundleName, abilityName);
1037 AVSession_ControlCommand command = CONTROL_CMD_PLAY_PREVIOUS;
1038 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
1039 void* userData) -> AVSessionCallback_Result
__anonea2c80191d02(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 1040 {
1041 return AVSESSION_CALLBACK_RESULT_SUCCESS;
1042 };
1043 oHAVSession->ohAVSessionCallbackImpl_ = std::make_shared<OHAVSessionCallbackImpl>();
1044 AVSession_ErrCode result = oHAVSession->UnregisterCommandCallback(command, callback);
1045 EXPECT_EQ(result, AV_SESSION_ERR_SUCCESS);
1046 }
1047
1048 /**
1049 * @tc.name: UnregisterCommandCallback006
1050 * @tc.desc: Test UnregisterCommandCallback.
1051 * @tc.type: FUNC
1052 * @tc.require: none
1053 */
1054 HWTEST(OHAVSessionTest, UnregisterCommandCallback_006, TestSize.Level0)
1055 {
1056 AVSession_Type sessionType = SESSION_TYPE_VIDEO;
1057 const char* sessionTag = "1";
1058 const char* bundleName = "2";
1059 const char* abilityName = "3";
1060 auto oHAVSession = std::make_shared<OHAVSession>(sessionType, sessionTag, bundleName, abilityName);
1061 AVSession_ControlCommand command = CONTROL_CMD_INVALID;
1062 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
1063 void* userData) -> AVSessionCallback_Result
__anonea2c80191e02(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 1064 {
1065 return AVSESSION_CALLBACK_RESULT_SUCCESS;
1066 };
1067 oHAVSession->ohAVSessionCallbackImpl_ = std::make_shared<OHAVSessionCallbackImpl>();
1068 AVSession_ErrCode result = oHAVSession->UnregisterCommandCallback(command, callback);
1069 EXPECT_EQ(result, AV_SESSION_ERR_SERVICE_EXCEPTION);
1070 }
1071
1072 /**
1073 * @tc.name: UnregisterForwardCallback001
1074 * @tc.desc: Test UnregisterForwardCallback.
1075 * @tc.type: FUNC
1076 * @tc.require: none
1077 */
1078 HWTEST(OHAVSessionTest, UnregisterForwardCallback_001, TestSize.Level0)
1079 {
1080 AVSession_Type sessionType = SESSION_TYPE_VIDEO;
1081 const char* sessionTag = "1";
1082 const char* bundleName = "2";
1083 const char* abilityName = "3";
1084 auto oHAVSession = std::make_shared<OHAVSession>(sessionType, sessionTag, bundleName, abilityName);
1085 OH_AVSessionCallback_OnFastForward callback = [](OH_AVSession* session, uint32_t seekTime,
1086 void* userData) -> AVSessionCallback_Result
__anonea2c80191f02(OH_AVSession* session, uint32_t seekTime, void* userData) 1087 {
1088 return AVSESSION_CALLBACK_RESULT_SUCCESS;
1089 };
1090 oHAVSession->ohAVSessionCallbackImpl_ = nullptr;
1091 AVSession_ErrCode result = oHAVSession->UnregisterForwardCallback(callback);
1092 EXPECT_EQ(result, AV_SESSION_ERR_SUCCESS);
1093 }
1094
1095 /**
1096 * @tc.name: UnregisterRewindCallback001
1097 * @tc.desc: Test UnregisterRewindCallback.
1098 * @tc.type: FUNC
1099 * @tc.require: none
1100 */
1101 HWTEST(OHAVSessionTest, UnregisterRewindCallback_001, TestSize.Level0)
1102 {
1103 AVSession_Type sessionType = SESSION_TYPE_VIDEO;
1104 const char* sessionTag = "1";
1105 const char* bundleName = "2";
1106 const char* abilityName = "3";
1107 auto oHAVSession = std::make_shared<OHAVSession>(sessionType, sessionTag, bundleName, abilityName);
1108 OH_AVSessionCallback_OnRewind callback = [](OH_AVSession* session, uint32_t seekTime,
1109 void* userData) -> AVSessionCallback_Result
__anonea2c80192002(OH_AVSession* session, uint32_t seekTime, void* userData) 1110 {
1111 return AVSESSION_CALLBACK_RESULT_SUCCESS;
1112 };
1113 oHAVSession->ohAVSessionCallbackImpl_ = nullptr;
1114 AVSession_ErrCode result = oHAVSession->UnregisterRewindCallback(callback);
1115 EXPECT_EQ(result, AV_SESSION_ERR_SUCCESS);
1116 }
1117
1118 /**
1119 * @tc.name: UnregisterSeekCallback001
1120 * @tc.desc: Test UnregisterSeekCallback.
1121 * @tc.type: FUNC
1122 * @tc.require: none
1123 */
1124 HWTEST(OHAVSessionTest, UnregisterSeekCallback_001, TestSize.Level0)
1125 {
1126 AVSession_Type sessionType = SESSION_TYPE_VIDEO;
1127 const char* sessionTag = "1";
1128 const char* bundleName = "2";
1129 const char* abilityName = "3";
1130 auto oHAVSession = std::make_shared<OHAVSession>(sessionType, sessionTag, bundleName, abilityName);
1131 OH_AVSessionCallback_OnSeek callback = [](OH_AVSession* session, uint64_t seekTime,
1132 void* userData) -> AVSessionCallback_Result
__anonea2c80192102(OH_AVSession* session, uint64_t seekTime, void* userData) 1133 {
1134 return AVSESSION_CALLBACK_RESULT_SUCCESS;
1135 };
1136 oHAVSession->ohAVSessionCallbackImpl_ = nullptr;
1137 AVSession_ErrCode result = oHAVSession->UnregisterSeekCallback(callback);
1138 EXPECT_EQ(result, AV_SESSION_ERR_SUCCESS);
1139 }
1140
1141 /**
1142 * @tc.name: UnregisterSetLoopModeCallback
1143 * @tc.desc: Test UnregisterSetLoopModeCallback.
1144 * @tc.type: FUNC
1145 * @tc.require: none
1146 */
1147 HWTEST(OHAVSessionTest, UnregisterSetLoopModeCallback_001, TestSize.Level0)
1148 {
1149 AVSession_Type sessionType = SESSION_TYPE_VIDEO;
1150 const char* sessionTag = "1";
1151 const char* bundleName = "2";
1152 const char* abilityName = "3";
1153 auto oHAVSession = std::make_shared<OHAVSession>(sessionType, sessionTag, bundleName, abilityName);
1154 OH_AVSessionCallback_OnSetLoopMode callback = [](OH_AVSession* session, AVSession_LoopMode curLoopMode,
1155 void* userData) -> AVSessionCallback_Result
__anonea2c80192202(OH_AVSession* session, AVSession_LoopMode curLoopMode, void* userData) 1156 {
1157 return AVSESSION_CALLBACK_RESULT_SUCCESS;
1158 };
1159 oHAVSession->ohAVSessionCallbackImpl_ = nullptr;
1160 AVSession_ErrCode result = oHAVSession->UnregisterSetLoopModeCallback(callback);
1161 EXPECT_EQ(result, AV_SESSION_ERR_SUCCESS);
1162 }
1163
1164 /**
1165 * @tc.name: UnregisterToggleFavoriteCallback
1166 * @tc.desc: Test UnregisterToggleFavoriteCallback.
1167 * @tc.type: FUNC
1168 * @tc.require: none
1169 */
1170 HWTEST(OHAVSessionTest, UnregisterToggleFavoriteCallback_001, TestSize.Level0)
1171 {
1172 AVSession_Type sessionType = SESSION_TYPE_VIDEO;
1173 const char* sessionTag = "1";
1174 const char* bundleName = "2";
1175 const char* abilityName = "3";
1176 auto oHAVSession = std::make_shared<OHAVSession>(sessionType, sessionTag, bundleName, abilityName);
1177 OH_AVSessionCallback_OnToggleFavorite callback = [](OH_AVSession* session, const char* assetId,
1178 void* userData) -> AVSessionCallback_Result
__anonea2c80192302(OH_AVSession* session, const char* assetId, void* userData) 1179 {
1180 return AVSESSION_CALLBACK_RESULT_SUCCESS;
1181 };
1182 oHAVSession->ohAVSessionCallbackImpl_ = nullptr;
1183 AVSession_ErrCode result = oHAVSession->UnregisterToggleFavoriteCallback(callback);
1184 EXPECT_EQ(result, AV_SESSION_ERR_SUCCESS);
1185 }
1186
1187 /**
1188 * @tc.name: OHAVSession_GetSessionId_002
1189 * @tc.desc: Test GetSessionId when sessionId_ is empty
1190 * @tc.type: FUNC
1191 * @tc.require: none
1192 */
1193 HWTEST(OHAVSessionTest, OHAVSession_GetSessionId_002, TestSize.Level0)
1194 {
1195 AVSession_Type sessionType = SESSION_TYPE_VIDEO;
1196 const char* sessionTag = "1";
1197 const char* bundleName = "2";
1198 const char* abilityName = "3";
1199 auto oHAVSession = std::make_shared<OHAVSession>(sessionType, sessionTag, bundleName, abilityName);
1200
1201 oHAVSession->sessionId_ = "";
1202
1203 const std::string& sessionId = oHAVSession->GetSessionId();
1204 EXPECT_TRUE(sessionId != "");
1205 }
1206
1207 /**
1208 * @tc.name: RegisterCommandCallback_003
1209 * @tc.desc: send invalid command
1210 * @tc.type: FUNC
1211 * @tc.require: none
1212 */
1213 HWTEST(OHAVSessionTest, RegisterCommandCallback_003, TestSize.Level0)
1214 {
1215 AVSession_Type sessionType = SESSION_TYPE_VIDEO;
1216 const char* sessionTag = "1";
1217 const char* bundleName = "2";
1218 const char* abilityName = "3";
1219 auto oHAVSession = std::make_shared<OHAVSession>(sessionType, sessionTag, bundleName, abilityName);
1220 AVSession_ControlCommand command = static_cast<AVSession_ControlCommand>(100);
1221 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
1222 void* userData) -> AVSessionCallback_Result
__anonea2c80192402(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 1223 {
1224 return AVSESSION_CALLBACK_RESULT_SUCCESS;
1225 };
1226 int userData = 1;
1227 oHAVSession->ohAVSessionCallbackImpl_ = std::make_shared<OHAVSessionCallbackImpl>();
1228 AVSession_ErrCode result = oHAVSession->RegisterCommandCallback(command, callback, (void *)(&userData));
1229 EXPECT_EQ(result, AV_SESSION_ERR_SERVICE_EXCEPTION);
1230 }
1231
1232 /**
1233 * @tc.name: RegisterCommandCallback_004
1234 * @tc.desc: send invalid command
1235 * @tc.type: FUNC
1236 * @tc.require: none
1237 */
1238 HWTEST(OHAVSessionTest, RegisterCommandCallback_004, TestSize.Level0)
1239 {
1240 AVSession_Type sessionType = SESSION_TYPE_VIDEO;
1241 const char* sessionTag = "1";
1242 const char* bundleName = "2";
1243 const char* abilityName = "3";
1244 auto oHAVSession = std::make_shared<OHAVSession>(sessionType, sessionTag, bundleName, abilityName);
1245 AVSession_ControlCommand command = CONTROL_CMD_INVALID;
1246 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
1247 void* userData) -> AVSessionCallback_Result
__anonea2c80192502(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 1248 {
1249 return AVSESSION_CALLBACK_RESULT_SUCCESS;
1250 };
1251 int userData = 1;
1252 oHAVSession->ohAVSessionCallbackImpl_ = std::make_shared<OHAVSessionCallbackImpl>();
1253 AVSession_ErrCode result = oHAVSession->RegisterCommandCallback(command, callback, (void *)(&userData));
1254 EXPECT_EQ(result, AV_SESSION_ERR_SERVICE_EXCEPTION);
1255 }
1256
1257 /**
1258 * @tc.name: CheckAndRegister_001
1259 * @tc.desc: have not registered callback
1260 * @tc.type: FUNC
1261 * @tc.require: none
1262 */
1263 HWTEST(OHAVSessionTest, CheckAndRegister_001, TestSize.Level0)
1264 {
1265 AVSession_Type sessionType = SESSION_TYPE_VIDEO;
1266 const char* sessionTag = "1";
1267 const char* bundleName = "2";
1268 const char* abilityName = "3";
1269 auto oHAVSession = std::make_shared<OHAVSession>(sessionType, sessionTag, bundleName, abilityName);
1270 oHAVSession->ohAVSessionCallbackImpl_ = nullptr;
1271 AVSession_ErrCode result = oHAVSession->CheckAndRegister();
1272 EXPECT_EQ(result, AV_SESSION_ERR_SUCCESS);
1273 }
1274
1275 /**
1276 * @tc.name: CheckAndRegister_002
1277 * @tc.desc: have registered callback
1278 * @tc.type: FUNC
1279 * @tc.require: none
1280 */
1281 HWTEST(OHAVSessionTest, CheckAndRegister_002, TestSize.Level0)
1282 {
1283 AVSession_Type sessionType = SESSION_TYPE_VIDEO;
1284 const char* sessionTag = "1";
1285 const char* bundleName = "2";
1286 const char* abilityName = "3";
1287 auto oHAVSession = std::make_shared<OHAVSession>(sessionType, sessionTag, bundleName, abilityName);
1288 oHAVSession->ohAVSessionCallbackImpl_ = std::make_shared<OHAVSessionCallbackImpl>();
1289 AVSession_ErrCode result = oHAVSession->CheckAndRegister();
1290 EXPECT_EQ(result, AV_SESSION_ERR_SUCCESS);
1291 }
1292
1293 }