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
16 #include "audio_haptic_sound_normal_impl_unit_test.h"
17
18 namespace OHOS {
19 namespace Media {
20 using namespace testing::ext;
21 static float g_nuM1 = -1.0f;
22 static float g_nuM2 = 2.0f;
23 static float g_nuM3 = 0.5f;
24 static int32_t g_nuM4 = -1;
25
SetUpTestCase(void)26 void AudioHapticSoundNormalImplUnitTest::SetUpTestCase(void) {}
27
TearDownTestCase(void)28 void AudioHapticSoundNormalImplUnitTest::TearDownTestCase(void) {}
29
SetUp(void)30 void AudioHapticSoundNormalImplUnitTest::SetUp(void) {}
31
TearDown(void)32 void AudioHapticSoundNormalImplUnitTest::TearDown(void) {}
33
34 /**
35 * @tc.name : Test AudioHapticSoundNormalImpl API
36 * @tc.number: AudioHapticSoundNormalImpl_001
37 * @tc.desc : Test AudioHapticSoundNormalImpl::~AudioHapticSoundNormalImpl()
38 */
39 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AudioHapticSoundNormalImpl_001, TestSize.Level1)
40 {
41 std::string audioUri = "123";
42 bool muteAudio = true;
43 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
44 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
45
46 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
47
48 audioHapticSoundNormalImpl->avPlayer_ = PlayerFactory::CreatePlayer();
49 EXPECT_NE(audioHapticSoundNormalImpl->avPlayer_, nullptr);
50 }
51
52 /**
53 * @tc.name : Test AudioHapticSoundNormalImpl API
54 * @tc.number: AudioHapticSoundNormalImpl_002
55 * @tc.desc : Test AudioHapticSoundNormalImpl::~AudioHapticSoundNormalImpl()
56 */
57 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AudioHapticSoundNormalImpl_002, TestSize.Level1)
58 {
59 std::string audioUri = "123";
60 bool muteAudio = true;
61 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
62 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
63
64 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
65
66 audioHapticSoundNormalImpl->avPlayer_ = nullptr;
67 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
68 }
69
70 /**
71 * @tc.name : Test AudioHapticSoundNormalImpl API
72 * @tc.number: AudioHapticSoundNormalImpl_003
73 * @tc.desc : Test AudioHapticSoundNormalImpl::PrepareSound()
74 */
75 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AudioHapticSoundNormalImpl_003, TestSize.Level1)
76 {
77 std::string audioUri = "123";
78 bool muteAudio = true;
79 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
80 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
81
82 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
83
84 audioHapticSoundNormalImpl->avPlayer_ = PlayerFactory::CreatePlayer();
85 EXPECT_NE(audioHapticSoundNormalImpl->avPlayer_, nullptr);
86
87 audioHapticSoundNormalImpl->audioUri_ = "abc";
88 audioHapticSoundNormalImpl->configuredAudioUri_ = "abc";
89 auto ret = audioHapticSoundNormalImpl->PrepareSound();
90
91 EXPECT_NE(ret, MSERR_OK);
92 }
93
94 /**
95 * @tc.name : Test AudioHapticSoundNormalImpl API
96 * @tc.number: AudioHapticSoundNormalImpl_004
97 * @tc.desc : Test AudioHapticSoundNormalImpl::StartSound()
98 */
99 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AudioHapticSoundNormalImpl_004, TestSize.Level1)
100 {
101 std::string audioUri = "123";
102 bool muteAudio = true;
103 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
104 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
105
106 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
107
108 audioHapticSoundNormalImpl->avPlayer_ = PlayerFactory::CreatePlayer();
109 EXPECT_NE(audioHapticSoundNormalImpl->avPlayer_, nullptr);
110
111 audioHapticSoundNormalImpl->playerState_ = AudioHapticPlayerState::STATE_RUNNING;
112 audioHapticSoundNormalImpl->audioUri_ = "abc";
113 auto ret = audioHapticSoundNormalImpl->StartSound();
114
115 EXPECT_EQ(ret, MSERR_START_FAILED);
116 }
117
118 /**
119 * @tc.name : Test AudioHapticSoundNormalImpl API
120 * @tc.number: AudioHapticSoundNormalImpl_005
121 * @tc.desc : Test AudioHapticSoundNormalImpl::StartSound()
122 */
123 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AudioHapticSoundNormalImpl_005, TestSize.Level1)
124 {
125 std::string audioUri = "123";
126 bool muteAudio = true;
127 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
128 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
129
130 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
131
132 audioHapticSoundNormalImpl->avPlayer_ = PlayerFactory::CreatePlayer();
133 EXPECT_NE(audioHapticSoundNormalImpl->avPlayer_, nullptr);
134
135 audioHapticSoundNormalImpl->playerState_ = AudioHapticPlayerState::STATE_STOPPED;
136 audioHapticSoundNormalImpl->audioUri_ = "abc";
137 auto ret = audioHapticSoundNormalImpl->StartSound();
138
139 EXPECT_EQ(ret, MSERR_START_FAILED);
140 }
141
142 /**
143 * @tc.name : Test AudioHapticSoundNormalImpl API
144 * @tc.number: AudioHapticSoundNormalImpl_006
145 * @tc.desc : Test AudioHapticSoundNormalImpl::StartSound()
146 */
147 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AudioHapticSoundNormalImpl_006, TestSize.Level1)
148 {
149 std::string audioUri = "123";
150 bool muteAudio = true;
151 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
152 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
153
154 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
155
156 audioHapticSoundNormalImpl->avPlayer_ = PlayerFactory::CreatePlayer();
157 EXPECT_NE(audioHapticSoundNormalImpl->avPlayer_, nullptr);
158
159 audioHapticSoundNormalImpl->playerState_ = AudioHapticPlayerState::STATE_NEW;
160 audioHapticSoundNormalImpl->audioUri_ = "abc";
161 audioHapticSoundNormalImpl->configuredAudioUri_ = "abcd";
162 auto ret = audioHapticSoundNormalImpl->StartSound();
163
164 EXPECT_EQ(ret, MSERR_START_FAILED);
165 }
166
167 /**
168 * @tc.name : Test AudioHapticSoundNormalImpl API
169 * @tc.number: AudioHapticSoundNormalImpl_007
170 * @tc.desc : Test AudioHapticSoundNormalImpl::StartSound()
171 */
172 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AudioHapticSoundNormalImpl_007, TestSize.Level1)
173 {
174 std::string audioUri = "123";
175 bool muteAudio = true;
176 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
177 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
178
179 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
180
181 audioHapticSoundNormalImpl->avPlayer_ = PlayerFactory::CreatePlayer();
182 EXPECT_NE(audioHapticSoundNormalImpl->avPlayer_, nullptr);
183
184 audioHapticSoundNormalImpl->playerState_ = AudioHapticPlayerState::STATE_NEW;
185 audioHapticSoundNormalImpl->audioUri_ = "abc";
186 audioHapticSoundNormalImpl->configuredAudioUri_ = "abc";
187 auto ret = audioHapticSoundNormalImpl->StartSound();
188
189 EXPECT_EQ(ret, MSERR_START_FAILED);
190 }
191
192 /**
193 * @tc.name : Test AudioHapticSoundNormalImpl API
194 * @tc.number: AudioHapticSoundNormalImpl_008
195 * @tc.desc : Test AudioHapticSoundNormalImpl::StopSound()
196 */
197 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AudioHapticSoundNormalImpl_008, TestSize.Level1)
198 {
199 std::string audioUri = "123";
200 bool muteAudio = true;
201 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
202 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
203
204 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
205
206 audioHapticSoundNormalImpl->avPlayer_ = PlayerFactory::CreatePlayer();
207 EXPECT_NE(audioHapticSoundNormalImpl->avPlayer_, nullptr);
208
209 audioHapticSoundNormalImpl->playerState_ = AudioHapticPlayerState::STATE_NEW;
210 auto ret = audioHapticSoundNormalImpl->StopSound();
211
212 EXPECT_EQ(ret, MSERR_OK);
213 }
214
215 /**
216 * @tc.name : Test AudioHapticSoundNormalImpl API
217 * @tc.number: AudioHapticSoundNormalImpl_009
218 * @tc.desc : Test AudioHapticSoundNormalImpl::StopSound()
219 */
220 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AudioHapticSoundNormalImpl_009, TestSize.Level1)
221 {
222 std::string audioUri = "123";
223 bool muteAudio = true;
224 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
225 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
226
227 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
228
229 audioHapticSoundNormalImpl->avPlayer_ = PlayerFactory::CreatePlayer();
230 EXPECT_NE(audioHapticSoundNormalImpl->avPlayer_, nullptr);
231
232 audioHapticSoundNormalImpl->playerState_ = AudioHapticPlayerState::STATE_STOPPED;
233 auto ret = audioHapticSoundNormalImpl->StopSound();
234
235 EXPECT_EQ(ret, MSERR_OK);
236 }
237
238 /**
239 * @tc.name : Test AudioHapticSoundNormalImpl API
240 * @tc.number: AudioHapticSoundNormalImpl_010
241 * @tc.desc : Test AudioHapticSoundNormalImpl::ReleaseAVPlayer()
242 */
243 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AudioHapticSoundNormalImpl_010, TestSize.Level1)
244 {
245 std::string audioUri = "123";
246 bool muteAudio = true;
247 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
248 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
249
250 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
251
252 audioHapticSoundNormalImpl->avPlayer_ = PlayerFactory::CreatePlayer();
253 EXPECT_NE(audioHapticSoundNormalImpl->avPlayer_, nullptr);
254 audioHapticSoundNormalImpl->fileDes_ = 0;
255
256 audioHapticSoundNormalImpl->ReleaseAVPlayer();
257 }
258
259 /**
260 * @tc.name : Test AudioHapticSoundNormalImpl API
261 * @tc.number: AudioHapticSoundNormalImpl_011
262 * @tc.desc : Test AudioHapticSoundNormalImpl::ReleaseAVPlayer()
263 */
264 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AudioHapticSoundNormalImpl_011, TestSize.Level1)
265 {
266 std::string audioUri = "123";
267 bool muteAudio = true;
268 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
269 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
270
271 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
272
273 audioHapticSoundNormalImpl->avPlayer_ = nullptr;
274 audioHapticSoundNormalImpl->fileDes_ = -1;
275
276 audioHapticSoundNormalImpl->ReleaseAVPlayer();
277 }
278
279 /**
280 * @tc.name : Test AudioHapticSoundNormalImpl API
281 * @tc.number: AudioHapticSoundNormalImpl_012
282 * @tc.desc : Test AudioHapticSoundNormalImpl::SetVolume()
283 */
284 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AudioHapticSoundNormalImpl_012, TestSize.Level1)
285 {
286 std::string audioUri = "123";
287 bool muteAudio = true;
288 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
289 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
290
291 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
292
293 float volume = g_nuM1;
294
295 auto ret = audioHapticSoundNormalImpl->SetVolume(volume);
296 EXPECT_EQ(ret, MSERR_INVALID_VAL);
297 }
298
299 /**
300 * @tc.name : Test AudioHapticSoundNormalImpl API
301 * @tc.number: AudioHapticSoundNormalImpl_013
302 * @tc.desc : Test AudioHapticSoundNormalImpl::SetVolume()
303 */
304 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AudioHapticSoundNormalImpl_013, TestSize.Level1)
305 {
306 std::string audioUri = "123";
307 bool muteAudio = true;
308 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
309 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
310
311 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
312
313 float volume = g_nuM2;
314
315 auto ret = audioHapticSoundNormalImpl->SetVolume(volume);
316 EXPECT_EQ(ret, MSERR_INVALID_VAL);
317 }
318
319 /**
320 * @tc.name : Test AudioHapticSoundNormalImpl API
321 * @tc.number: AudioHapticSoundNormalImpl_014
322 * @tc.desc : Test AudioHapticSoundNormalImpl::SetVolume()
323 */
324 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AudioHapticSoundNormalImpl_014, TestSize.Level1)
325 {
326 std::string audioUri = "123";
327 bool muteAudio = true;
328 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
329 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
330
331 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
332
333 float volume = g_nuM3;
334 audioHapticSoundNormalImpl->playerState_ = AudioHapticPlayerState::STATE_NEW;
335 audioHapticSoundNormalImpl->avPlayer_ = PlayerFactory::CreatePlayer();
336 EXPECT_NE(audioHapticSoundNormalImpl->avPlayer_, nullptr);
337
338 auto ret = audioHapticSoundNormalImpl->SetVolume(volume);
339 EXPECT_EQ(ret, MSERR_OK);
340 }
341
342 /**
343 * @tc.name : Test AudioHapticSoundNormalImpl API
344 * @tc.number: AudioHapticSoundNormalImpl_015
345 * @tc.desc : Test AudioHapticSoundNormalImpl::SetVolume()
346 */
347 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AudioHapticSoundNormalImpl_015, TestSize.Level1)
348 {
349 std::string audioUri = "123";
350 bool muteAudio = true;
351 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
352 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
353
354 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
355
356 float volume = g_nuM3;
357 audioHapticSoundNormalImpl->playerState_ = AudioHapticPlayerState::STATE_RUNNING;
358 audioHapticSoundNormalImpl->avPlayer_ = PlayerFactory::CreatePlayer();
359 EXPECT_NE(audioHapticSoundNormalImpl->avPlayer_, nullptr);
360
361 auto ret = audioHapticSoundNormalImpl->SetVolume(volume);
362 EXPECT_EQ(ret, MSERR_OK);
363 }
364
365 /**
366 * @tc.name : Test AudioHapticSoundNormalImpl API
367 * @tc.number: AudioHapticSoundNormalImpl_016
368 * @tc.desc : Test AudioHapticSoundNormalImpl::SetVolume()
369 */
370 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AudioHapticSoundNormalImpl_016, TestSize.Level1)
371 {
372 std::string audioUri = "123";
373 bool muteAudio = true;
374 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
375 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
376
377 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
378
379 float volume = g_nuM3;
380 audioHapticSoundNormalImpl->playerState_ = AudioHapticPlayerState::STATE_PREPARED;
381 audioHapticSoundNormalImpl->avPlayer_ = PlayerFactory::CreatePlayer();
382 EXPECT_NE(audioHapticSoundNormalImpl->avPlayer_, nullptr);
383
384 auto ret = audioHapticSoundNormalImpl->SetVolume(volume);
385 EXPECT_EQ(ret, MSERR_OK);
386 }
387
388 /**
389 * @tc.name : Test AudioHapticSoundNormalImpl API
390 * @tc.number: AudioHapticSoundNormalImpl_017
391 * @tc.desc : Test AudioHapticSoundNormalImpl::SetLoop()
392 */
393 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AudioHapticSoundNormalImpl_017, TestSize.Level1)
394 {
395 std::string audioUri = "123";
396 bool muteAudio = true;
397 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
398 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
399
400 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
401
402 bool loop = true;
403 audioHapticSoundNormalImpl->playerState_ = AudioHapticPlayerState::STATE_NEW;
404 audioHapticSoundNormalImpl->avPlayer_ = PlayerFactory::CreatePlayer();
405 EXPECT_NE(audioHapticSoundNormalImpl->avPlayer_, nullptr);
406
407 auto ret = audioHapticSoundNormalImpl->SetLoop(loop);
408 EXPECT_EQ(ret, MSERR_OK);
409 }
410
411 /**
412 * @tc.name : Test AudioHapticSoundNormalImpl API
413 * @tc.number: AudioHapticSoundNormalImpl_018
414 * @tc.desc : Test AudioHapticSoundNormalImpl::SetLoop()
415 */
416 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AudioHapticSoundNormalImpl_018, TestSize.Level1)
417 {
418 std::string audioUri = "123";
419 bool muteAudio = true;
420 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
421 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
422
423 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
424
425 bool loop = true;
426 audioHapticSoundNormalImpl->playerState_ = AudioHapticPlayerState::STATE_RUNNING;
427 audioHapticSoundNormalImpl->avPlayer_ = PlayerFactory::CreatePlayer();
428 EXPECT_NE(audioHapticSoundNormalImpl->avPlayer_, nullptr);
429
430 auto ret = audioHapticSoundNormalImpl->SetLoop(loop);
431 EXPECT_EQ(ret, MSERR_OK);
432 }
433
434 /**
435 * @tc.name : Test AudioHapticSoundNormalImpl API
436 * @tc.number: AudioHapticSoundNormalImpl_019
437 * @tc.desc : Test AudioHapticSoundNormalImpl::SetLoop()
438 */
439 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AudioHapticSoundNormalImpl_019, TestSize.Level1)
440 {
441 std::string audioUri = "123";
442 bool muteAudio = true;
443 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
444 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
445
446 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
447
448 bool loop = true;
449 audioHapticSoundNormalImpl->playerState_ = AudioHapticPlayerState::STATE_PREPARED;
450 audioHapticSoundNormalImpl->avPlayer_ = PlayerFactory::CreatePlayer();
451 EXPECT_NE(audioHapticSoundNormalImpl->avPlayer_, nullptr);
452
453 auto ret = audioHapticSoundNormalImpl->SetLoop(loop);
454 EXPECT_EQ(ret, MSERR_OK);
455 }
456
457 /**
458 * @tc.name : Test AudioHapticSoundNormalImpl API
459 * @tc.number: AudioHapticSoundNormalImpl_020
460 * @tc.desc : Test AudioHapticSoundNormalImpl::GetAudioCurrentTime()
461 */
462 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AudioHapticSoundNormalImpl_020, TestSize.Level1)
463 {
464 std::string audioUri = "123";
465 bool muteAudio = true;
466 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
467 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
468
469 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
470
471 audioHapticSoundNormalImpl->avPlayer_ = PlayerFactory::CreatePlayer();
472 EXPECT_NE(audioHapticSoundNormalImpl->avPlayer_, nullptr);
473
474 auto ret = audioHapticSoundNormalImpl->GetAudioCurrentTime();
475 EXPECT_EQ(ret, g_nuM4);
476 }
477
478 /**
479 * @tc.name : Test AudioHapticSoundNormalImpl API
480 * @tc.number: AudioHapticSoundNormalImpl_021
481 * @tc.desc : Test AudioHapticSoundNormalImpl::GetAudioCurrentTime()
482 */
483 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AudioHapticSoundNormalImpl_021, TestSize.Level1)
484 {
485 std::string audioUri = "123";
486 bool muteAudio = true;
487 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
488 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
489
490 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
491
492 audioHapticSoundNormalImpl->avPlayer_ = nullptr;
493 auto ret = audioHapticSoundNormalImpl->GetAudioCurrentTime();
494 EXPECT_EQ(ret, g_nuM4);
495 }
496
497 /**
498 * @tc.name : Test AudioHapticSoundNormalImpl API
499 * @tc.number: AudioHapticSoundNormalImpl_022
500 * @tc.desc : Test AudioHapticSoundNormalImpl::SetAudioHapticSoundCallback()
501 */
502 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AudioHapticSoundNormalImpl_022, TestSize.Level1)
503 {
504 std::string audioUri = "123";
505 bool muteAudio = true;
506 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
507 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
508
509 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
510
511 auto callback = std::make_shared<AudioHapticSoundCallbackImpl>(std::make_shared<AudioHapticPlayerImpl>());
512 EXPECT_NE(callback, nullptr);
513
514 auto ret = audioHapticSoundNormalImpl->SetAudioHapticSoundCallback(callback);
515 EXPECT_EQ(ret, MSERR_OK);
516 }
517
518 /**
519 * @tc.name : Test AudioHapticSoundNormalImpl API
520 * @tc.number: AudioHapticSoundNormalImpl_023
521 * @tc.desc : Test AudioHapticSoundNormalImpl::SetAudioHapticSoundCallback()
522 */
523 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AudioHapticSoundNormalImpl_023, TestSize.Level1)
524 {
525 std::string audioUri = "123";
526 bool muteAudio = true;
527 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
528 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
529
530 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
531
532 std::shared_ptr<AudioHapticSoundCallback> callback = nullptr;
533 auto ret = audioHapticSoundNormalImpl->SetAudioHapticSoundCallback(callback);
534 EXPECT_EQ(ret, MSERR_INVALID_VAL);
535 }
536
537 /**
538 * @tc.name : Test AudioHapticSoundNormalImpl API
539 * @tc.number: AudioHapticSoundNormalImpl_024
540 * @tc.desc : Test AudioHapticSoundNormalImpl::NotifyErrorEvent()
541 */
542 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AudioHapticSoundNormalImpl_024, TestSize.Level1)
543 {
544 std::string audioUri = "123";
545 bool muteAudio = true;
546 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
547 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
548
549 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
550
551 int32_t errorCode = MediaServiceErrCode::MSERR_UNSUPPORT_FILE;
552 audioHapticSoundNormalImpl->audioHapticPlayerCallback_.reset();
553 audioHapticSoundNormalImpl->NotifyErrorEvent(errorCode);
554 }
555
556 /**
557 * @tc.name : Test AudioHapticSoundNormalImpl API
558 * @tc.number: AudioHapticSoundNormalImpl_025
559 * @tc.desc : Test AudioHapticSoundNormalImpl::NotifyErrorEvent()
560 */
561 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AudioHapticSoundNormalImpl_025, TestSize.Level1)
562 {
563 std::string audioUri = "123";
564 bool muteAudio = true;
565 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
566 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
567
568 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
569
570 int32_t errorCode = MediaServiceErrCode::MSERR_OK;
571
572 std::shared_ptr<AudioHapticSoundCallback> sharedcb =
573 std::make_shared<AudioHapticSoundCallbackImpl>(std::make_shared<AudioHapticPlayerImpl>());
574 audioHapticSoundNormalImpl->audioHapticPlayerCallback_ = sharedcb;
575 EXPECT_NE(audioHapticSoundNormalImpl->audioHapticPlayerCallback_.lock(), nullptr);
576
577 audioHapticSoundNormalImpl->NotifyErrorEvent(errorCode);
578 }
579
580 /**
581 * @tc.name : Test AudioHapticSoundNormalImpl API
582 * @tc.number: AudioHapticSoundNormalImpl_026
583 * @tc.desc : Test AudioHapticSoundNormalImpl::NotifyFirstFrameEvent()
584 */
585 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AudioHapticSoundNormalImpl_026, TestSize.Level1)
586 {
587 std::string audioUri = "123";
588 bool muteAudio = true;
589 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
590 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
591
592 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
593
594 uint64_t latency = 0;
595
596 std::shared_ptr<AudioHapticSoundCallback> sharedcb =
597 std::make_shared<AudioHapticSoundCallbackImpl>(std::make_shared<AudioHapticPlayerImpl>());
598 audioHapticSoundNormalImpl->audioHapticPlayerCallback_ = sharedcb;
599 EXPECT_NE(audioHapticSoundNormalImpl->audioHapticPlayerCallback_.lock(), nullptr);
600
601 audioHapticSoundNormalImpl->NotifyFirstFrameEvent(latency);
602 }
603
604 /**
605 * @tc.name : Test AudioHapticSoundNormalImpl API
606 * @tc.number: AudioHapticSoundNormalImpl_027
607 * @tc.desc : Test AudioHapticSoundNormalImpl::NotifyFirstFrameEvent()
608 */
609 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AudioHapticSoundNormalImpl_027, TestSize.Level1)
610 {
611 std::string audioUri = "123";
612 bool muteAudio = true;
613 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
614 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
615
616 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
617
618 uint64_t latency = 0;
619
620 audioHapticSoundNormalImpl->audioHapticPlayerCallback_.reset();
621 audioHapticSoundNormalImpl->NotifyFirstFrameEvent(latency);
622 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
623 }
624
625 /**
626 * @tc.name : Test AudioHapticSoundNormalImpl API
627 * @tc.number: AudioHapticSoundNormalImpl_028
628 * @tc.desc : Test AudioHapticSoundNormalImpl::NotifyInterruptEvent()
629 */
630 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AudioHapticSoundNormalImpl_028, TestSize.Level1)
631 {
632 std::string audioUri = "123";
633 bool muteAudio = true;
634 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
635 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
636
637 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
638
639 AudioStandard::InterruptEvent interruptEvent;
640
641 std::shared_ptr<AudioHapticSoundCallback> sharedcb =
642 std::make_shared<AudioHapticSoundCallbackImpl>(std::make_shared<AudioHapticPlayerImpl>());
643 audioHapticSoundNormalImpl->audioHapticPlayerCallback_ = sharedcb;
644 EXPECT_NE(audioHapticSoundNormalImpl->audioHapticPlayerCallback_.lock(), nullptr);
645
646 audioHapticSoundNormalImpl->NotifyInterruptEvent(interruptEvent);
647 }
648
649 /**
650 * @tc.name : Test AudioHapticSoundNormalImpl API
651 * @tc.number: AudioHapticSoundNormalImpl_029
652 * @tc.desc : Test AudioHapticSoundNormalImpl::NotifyInterruptEvent()
653 */
654 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AudioHapticSoundNormalImpl_029, TestSize.Level1)
655 {
656 std::string audioUri = "123";
657 bool muteAudio = true;
658 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
659 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
660
661 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
662
663 AudioStandard::InterruptEvent interruptEvent;
664
665 audioHapticSoundNormalImpl->audioHapticPlayerCallback_.reset();
666 audioHapticSoundNormalImpl->NotifyInterruptEvent(interruptEvent);
667 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
668 }
669
670 /**
671 * @tc.name : Test AudioHapticSoundNormalImpl API
672 * @tc.number: AudioHapticSoundNormalImpl_030
673 * @tc.desc : Test AudioHapticSoundNormalImpl::NotifyEndOfStreamEvent()
674 */
675 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AudioHapticSoundNormalImpl_030, TestSize.Level1)
676 {
677 std::string audioUri = "123";
678 bool muteAudio = true;
679 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
680 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
681
682 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
683
684 std::shared_ptr<AudioHapticSoundCallback> sharedcb =
685 std::make_shared<AudioHapticSoundCallbackImpl>(std::make_shared<AudioHapticPlayerImpl>());
686 audioHapticSoundNormalImpl->audioHapticPlayerCallback_ = sharedcb;
687 EXPECT_NE(audioHapticSoundNormalImpl->audioHapticPlayerCallback_.lock(), nullptr);
688
689 audioHapticSoundNormalImpl->NotifyEndOfStreamEvent();
690 }
691
692 /**
693 * @tc.name : Test AudioHapticSoundNormalImpl API
694 * @tc.number: AudioHapticSoundNormalImpl_031
695 * @tc.desc : Test AudioHapticSoundNormalImpl::NotifyEndOfStreamEvent()
696 */
697 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AudioHapticSoundNormalImpl_031, TestSize.Level1)
698 {
699 std::string audioUri = "123";
700 bool muteAudio = true;
701 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
702 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
703
704 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
705
706 audioHapticSoundNormalImpl->audioHapticPlayerCallback_.reset();
707 audioHapticSoundNormalImpl->NotifyEndOfStreamEvent();
708 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
709 }
710
711 /**
712 * @tc.name : Test AudioHapticSoundNormalImpl API
713 * @tc.number: AHSoundNormalCallback_032
714 * @tc.desc : Test AHSoundNormalCallback::OnError()
715 */
716 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AHSoundNormalCallback_032, TestSize.Level1)
717 {
718 std::string audioUri = "123";
719 bool muteAudio = true;
720 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
721 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
722
723 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
724
725 auto aHSoundNormalCallback = std::make_shared<AHSoundNormalCallback>(audioHapticSoundNormalImpl);
726 EXPECT_NE(aHSoundNormalCallback, nullptr);
727
728 std::shared_ptr<AudioHapticSoundNormalImpl> sharedcb =
729 std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
730 aHSoundNormalCallback->soundNormalImpl_ = sharedcb;
731 EXPECT_NE(aHSoundNormalCallback->soundNormalImpl_.lock(), nullptr);
732
733 int32_t errorCode = 0;
734 std::string errorMsg = "abc";
735 aHSoundNormalCallback->OnError(errorCode, errorMsg);
736 EXPECT_NE(aHSoundNormalCallback, nullptr);
737 }
738
739 /**
740 * @tc.name : Test AudioHapticSoundNormalImpl API
741 * @tc.number: AHSoundNormalCallback_033
742 * @tc.desc : Test AHSoundNormalCallback::OnError()
743 */
744 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AHSoundNormalCallback_033, TestSize.Level1)
745 {
746 std::string audioUri = "123";
747 bool muteAudio = true;
748 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
749 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
750
751 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
752
753 auto aHSoundNormalCallback = std::make_shared<AHSoundNormalCallback>(audioHapticSoundNormalImpl);
754 EXPECT_NE(aHSoundNormalCallback, nullptr);
755
756 aHSoundNormalCallback->soundNormalImpl_.reset();
757
758 int32_t errorCode = 0;
759 std::string errorMsg = "abc";
760 aHSoundNormalCallback->OnError(errorCode, errorMsg);
761 EXPECT_NE(aHSoundNormalCallback, nullptr);
762 }
763
764 /**
765 * @tc.name : Test AudioHapticSoundNormalImpl API
766 * @tc.number: AHSoundNormalCallback_034
767 * @tc.desc : Test AHSoundNormalCallback::OnInfo()
768 */
769 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AHSoundNormalCallback_034, TestSize.Level1)
770 {
771 std::string audioUri = "123";
772 bool muteAudio = true;
773 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
774 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
775
776 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
777
778 auto aHSoundNormalCallback = std::make_shared<AHSoundNormalCallback>(audioHapticSoundNormalImpl);
779 EXPECT_NE(aHSoundNormalCallback, nullptr);
780
781 aHSoundNormalCallback->soundNormalImpl_.reset();
782
783 Media::PlayerOnInfoType type = PlayerOnInfoType::INFO_TYPE_STATE_CHANGE;
784 int32_t extra = 0;
785 Media::Format infoBody;
786 aHSoundNormalCallback->OnInfo(type, extra, infoBody);
787 EXPECT_NE(aHSoundNormalCallback, nullptr);
788 }
789
790 /**
791 * @tc.name : Test AudioHapticSoundNormalImpl API
792 * @tc.number: AHSoundNormalCallback_035
793 * @tc.desc : Test AHSoundNormalCallback::OnInfo()
794 */
795 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AHSoundNormalCallback_035, TestSize.Level1)
796 {
797 std::string audioUri = "123";
798 bool muteAudio = true;
799 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
800 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
801
802 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
803
804 auto aHSoundNormalCallback = std::make_shared<AHSoundNormalCallback>(audioHapticSoundNormalImpl);
805 EXPECT_NE(aHSoundNormalCallback, nullptr);
806
807 aHSoundNormalCallback->soundNormalImpl_.reset();
808
809 Media::PlayerOnInfoType type = PlayerOnInfoType::INFO_TYPE_INTERRUPT_EVENT;
810 int32_t extra = 0;
811 Media::Format infoBody;
812 aHSoundNormalCallback->OnInfo(type, extra, infoBody);
813 EXPECT_NE(aHSoundNormalCallback, nullptr);
814 }
815
816 /**
817 * @tc.name : Test AudioHapticSoundNormalImpl API
818 * @tc.number: AHSoundNormalCallback_036
819 * @tc.desc : Test AHSoundNormalCallback::OnInfo()
820 */
821 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AHSoundNormalCallback_036, TestSize.Level1)
822 {
823 std::string audioUri = "123";
824 bool muteAudio = true;
825 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
826 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
827
828 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
829
830 auto aHSoundNormalCallback = std::make_shared<AHSoundNormalCallback>(audioHapticSoundNormalImpl);
831 EXPECT_NE(aHSoundNormalCallback, nullptr);
832
833 aHSoundNormalCallback->soundNormalImpl_.reset();
834
835 Media::PlayerOnInfoType type = PlayerOnInfoType::INFO_TYPE_AUDIO_FIRST_FRAME;
836 int32_t extra = 0;
837 Media::Format infoBody;
838 aHSoundNormalCallback->OnInfo(type, extra, infoBody);
839 EXPECT_NE(aHSoundNormalCallback, nullptr);
840 }
841
842 /**
843 * @tc.name : Test AudioHapticSoundNormalImpl API
844 * @tc.number: AHSoundNormalCallback_037
845 * @tc.desc : Test AHSoundNormalCallback::OnInfo()
846 */
847 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AHSoundNormalCallback_037, TestSize.Level1)
848 {
849 std::string audioUri = "123";
850 bool muteAudio = true;
851 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
852 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
853
854 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
855
856 auto aHSoundNormalCallback = std::make_shared<AHSoundNormalCallback>(audioHapticSoundNormalImpl);
857 EXPECT_NE(aHSoundNormalCallback, nullptr);
858
859 aHSoundNormalCallback->soundNormalImpl_.reset();
860
861 Media::PlayerOnInfoType type = PlayerOnInfoType::INFO_TYPE_AUDIO_DEVICE_CHANGE;
862 int32_t extra = 0;
863 Media::Format infoBody;
864 aHSoundNormalCallback->OnInfo(type, extra, infoBody);
865 EXPECT_NE(aHSoundNormalCallback, nullptr);
866 }
867
868 /**
869 * @tc.name : Test AudioHapticSoundNormalImpl API
870 * @tc.number: AHSoundNormalCallback_038
871 * @tc.desc : Test AHSoundNormalCallback::HandleStateChangeEvent()
872 */
873 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AHSoundNormalCallback_038, TestSize.Level1)
874 {
875 std::string audioUri = "123";
876 bool muteAudio = true;
877 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
878 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
879
880 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
881
882 auto aHSoundNormalCallback = std::make_shared<AHSoundNormalCallback>(audioHapticSoundNormalImpl);
883 EXPECT_NE(aHSoundNormalCallback, nullptr);
884
885 aHSoundNormalCallback->soundNormalImpl_.reset();
886
887 int32_t extra = PlayerStates::PLAYER_STATE_ERROR;
888 Format infoBody;
889 aHSoundNormalCallback->HandleStateChangeEvent(extra, infoBody);
890 EXPECT_EQ(aHSoundNormalCallback->playerState_, AudioHapticPlayerState::STATE_INVALID);
891 }
892
893 /**
894 * @tc.name : Test AudioHapticSoundNormalImpl API
895 * @tc.number: AHSoundNormalCallback_039
896 * @tc.desc : Test AHSoundNormalCallback::HandleStateChangeEvent()
897 */
898 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AHSoundNormalCallback_039, TestSize.Level1)
899 {
900 std::string audioUri = "123";
901 bool muteAudio = true;
902 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
903 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
904
905 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
906
907 auto aHSoundNormalCallback = std::make_shared<AHSoundNormalCallback>(audioHapticSoundNormalImpl);
908 EXPECT_NE(aHSoundNormalCallback, nullptr);
909
910 aHSoundNormalCallback->soundNormalImpl_.reset();
911
912 int32_t extra = PlayerStates::PLAYER_IDLE;
913 Format infoBody;
914 aHSoundNormalCallback->HandleStateChangeEvent(extra, infoBody);
915 EXPECT_EQ(aHSoundNormalCallback->playerState_, AudioHapticPlayerState::STATE_NEW);
916 }
917
918 /**
919 * @tc.name : Test AudioHapticSoundNormalImpl API
920 * @tc.number: AHSoundNormalCallback_040
921 * @tc.desc : Test AHSoundNormalCallback::HandleStateChangeEvent()
922 */
923 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AHSoundNormalCallback_040, TestSize.Level1)
924 {
925 std::string audioUri = "123";
926 bool muteAudio = true;
927 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
928 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
929
930 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
931
932 auto aHSoundNormalCallback = std::make_shared<AHSoundNormalCallback>(audioHapticSoundNormalImpl);
933 EXPECT_NE(aHSoundNormalCallback, nullptr);
934
935 std::shared_ptr<AudioHapticSoundNormalImpl> sharedcb =
936 std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
937 aHSoundNormalCallback->soundNormalImpl_ = sharedcb;
938 EXPECT_NE(aHSoundNormalCallback->soundNormalImpl_.lock(), nullptr);
939
940
941 int32_t extra = PlayerStates::PLAYER_PREPARED;
942 Format infoBody;
943 aHSoundNormalCallback->HandleStateChangeEvent(extra, infoBody);
944 EXPECT_EQ(aHSoundNormalCallback->playerState_, AudioHapticPlayerState::STATE_PREPARED);
945 }
946
947 /**
948 * @tc.name : Test AudioHapticSoundNormalImpl API
949 * @tc.number: AHSoundNormalCallback_041
950 * @tc.desc : Test AHSoundNormalCallback::HandleStateChangeEvent()
951 */
952 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AHSoundNormalCallback_041, TestSize.Level1)
953 {
954 std::string audioUri = "123";
955 bool muteAudio = true;
956 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
957 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
958
959 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
960
961 auto aHSoundNormalCallback = std::make_shared<AHSoundNormalCallback>(audioHapticSoundNormalImpl);
962 EXPECT_NE(aHSoundNormalCallback, nullptr);
963
964 aHSoundNormalCallback->soundNormalImpl_.reset();
965
966 int32_t extra = PlayerStates::PLAYER_STARTED;
967 Format infoBody;
968 aHSoundNormalCallback->HandleStateChangeEvent(extra, infoBody);
969 EXPECT_EQ(aHSoundNormalCallback->playerState_, AudioHapticPlayerState::STATE_RUNNING);
970 }
971
972 /**
973 * @tc.name : Test AudioHapticSoundNormalImpl API
974 * @tc.number: AHSoundNormalCallback_042
975 * @tc.desc : Test AHSoundNormalCallback::HandleStateChangeEvent()
976 */
977 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AHSoundNormalCallback_042, TestSize.Level1)
978 {
979 std::string audioUri = "123";
980 bool muteAudio = true;
981 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
982 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
983
984 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
985
986 auto aHSoundNormalCallback = std::make_shared<AHSoundNormalCallback>(audioHapticSoundNormalImpl);
987 EXPECT_NE(aHSoundNormalCallback, nullptr);
988
989 aHSoundNormalCallback->soundNormalImpl_.reset();
990
991 int32_t extra = PlayerStates::PLAYER_PAUSED;
992 Format infoBody;
993 aHSoundNormalCallback->HandleStateChangeEvent(extra, infoBody);
994 EXPECT_EQ(aHSoundNormalCallback->playerState_, AudioHapticPlayerState::STATE_PAUSED);
995 }
996
997 /**
998 * @tc.name : Test AudioHapticSoundNormalImpl API
999 * @tc.number: AHSoundNormalCallback_043
1000 * @tc.desc : Test AHSoundNormalCallback::HandleStateChangeEvent()
1001 */
1002 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AHSoundNormalCallback_043, TestSize.Level1)
1003 {
1004 std::string audioUri = "123";
1005 bool muteAudio = true;
1006 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
1007 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
1008
1009 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
1010
1011 auto aHSoundNormalCallback = std::make_shared<AHSoundNormalCallback>(audioHapticSoundNormalImpl);
1012 EXPECT_NE(aHSoundNormalCallback, nullptr);
1013
1014 std::shared_ptr<AudioHapticSoundNormalImpl> sharedcb =
1015 std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
1016 aHSoundNormalCallback->soundNormalImpl_ = sharedcb;
1017 EXPECT_NE(aHSoundNormalCallback->soundNormalImpl_.lock(), nullptr);
1018
1019
1020 int32_t extra = PlayerStates::PLAYER_PLAYBACK_COMPLETE;
1021 Format infoBody;
1022 aHSoundNormalCallback->HandleStateChangeEvent(extra, infoBody);
1023 EXPECT_EQ(aHSoundNormalCallback->playerState_, AudioHapticPlayerState::STATE_STOPPED);
1024 }
1025
1026 /**
1027 * @tc.name : Test AudioHapticSoundNormalImpl API
1028 * @tc.number: AHSoundNormalCallback_044
1029 * @tc.desc : Test AHSoundNormalCallback::HandleStateChangeEvent()
1030 */
1031 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AHSoundNormalCallback_044, TestSize.Level1)
1032 {
1033 std::string audioUri = "123";
1034 bool muteAudio = true;
1035 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
1036 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
1037
1038 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
1039
1040 auto aHSoundNormalCallback = std::make_shared<AHSoundNormalCallback>(audioHapticSoundNormalImpl);
1041 EXPECT_NE(aHSoundNormalCallback, nullptr);
1042
1043 aHSoundNormalCallback->soundNormalImpl_.reset();
1044
1045 int32_t extra = PlayerStates::PLAYER_RELEASED;
1046 Format infoBody;
1047 aHSoundNormalCallback->HandleStateChangeEvent(extra, infoBody);
1048 EXPECT_EQ(aHSoundNormalCallback->playerState_, AudioHapticPlayerState::STATE_NEW);
1049 }
1050
1051 /**
1052 * @tc.name : Test AudioHapticSoundNormalImpl API
1053 * @tc.number: AHSoundNormalCallback_045
1054 * @tc.desc : Test AHSoundNormalCallback::HandleAudioInterruptEvent()
1055 */
1056 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AHSoundNormalCallback_045, TestSize.Level1)
1057 {
1058 std::string audioUri = "123";
1059 bool muteAudio = true;
1060 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
1061 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
1062
1063 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
1064
1065 auto aHSoundNormalCallback = std::make_shared<AHSoundNormalCallback>(audioHapticSoundNormalImpl);
1066 EXPECT_NE(aHSoundNormalCallback, nullptr);
1067
1068 aHSoundNormalCallback->soundNormalImpl_.reset();
1069
1070 int32_t extra = PlayerStates::PLAYER_INITIALIZED;
1071 Format infoBody;
1072 aHSoundNormalCallback->HandleAudioInterruptEvent(extra, infoBody);
1073 }
1074
1075 /**
1076 * @tc.name : Test AudioHapticSoundNormalImpl API
1077 * @tc.number: AHSoundNormalCallback_046
1078 * @tc.desc : Test AHSoundNormalCallback::HandleAudioInterruptEvent()
1079 */
1080 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AHSoundNormalCallback_046, TestSize.Level1)
1081 {
1082 std::string audioUri = "123";
1083 bool muteAudio = true;
1084 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
1085 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
1086
1087 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
1088
1089 auto aHSoundNormalCallback = std::make_shared<AHSoundNormalCallback>(audioHapticSoundNormalImpl);
1090 EXPECT_NE(aHSoundNormalCallback, nullptr);
1091
1092 std::shared_ptr<AudioHapticSoundNormalImpl> sharedcb =
1093 std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
1094 aHSoundNormalCallback->soundNormalImpl_ = sharedcb;
1095 EXPECT_NE(aHSoundNormalCallback->soundNormalImpl_.lock(), nullptr);
1096
1097 int32_t extra = PlayerStates::PLAYER_INITIALIZED;
1098 Format infoBody;
1099 aHSoundNormalCallback->HandleAudioInterruptEvent(extra, infoBody);
1100 }
1101
1102 /**
1103 * @tc.name : Test AudioHapticSoundNormalImpl API
1104 * @tc.number: AHSoundNormalCallback_047
1105 * @tc.desc : Test AHSoundNormalCallback::HandleAudioFirstFrameEvent()
1106 */
1107 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AHSoundNormalCallback_047, TestSize.Level1)
1108 {
1109 std::string audioUri = "123";
1110 bool muteAudio = true;
1111 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
1112 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
1113
1114 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
1115
1116 auto aHSoundNormalCallback = std::make_shared<AHSoundNormalCallback>(audioHapticSoundNormalImpl);
1117 EXPECT_NE(aHSoundNormalCallback, nullptr);
1118
1119 std::shared_ptr<AudioHapticSoundNormalImpl> sharedcb =
1120 std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
1121 aHSoundNormalCallback->soundNormalImpl_ = sharedcb;
1122 EXPECT_NE(aHSoundNormalCallback->soundNormalImpl_.lock(), nullptr);
1123
1124 int32_t extra = PlayerStates::PLAYER_INITIALIZED;
1125 Format infoBody;
1126 aHSoundNormalCallback->HandleAudioFirstFrameEvent(extra, infoBody);
1127 }
1128
1129 /**
1130 * @tc.name : Test AudioHapticSoundNormalImpl API
1131 * @tc.number: AHSoundNormalCallback_048
1132 * @tc.desc : Test AHSoundNormalCallback::HandleAudioInterruptEvent()
1133 */
1134 HWTEST_F(AudioHapticSoundNormalImplUnitTest, AHSoundNormalCallback_048, TestSize.Level1)
1135 {
1136 std::string audioUri = "123";
1137 bool muteAudio = true;
1138 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
1139 auto audioHapticSoundNormalImpl = std::make_shared<AudioHapticSoundNormalImpl>(audioUri, muteAudio, streamUsage);
1140
1141 EXPECT_NE(audioHapticSoundNormalImpl, nullptr);
1142
1143 auto aHSoundNormalCallback = std::make_shared<AHSoundNormalCallback>(audioHapticSoundNormalImpl);
1144 EXPECT_NE(aHSoundNormalCallback, nullptr);
1145
1146 aHSoundNormalCallback->soundNormalImpl_.reset();
1147
1148 int32_t extra = PlayerStates::PLAYER_INITIALIZED;
1149 Format infoBody;
1150 aHSoundNormalCallback->HandleAudioInterruptEvent(extra, infoBody);
1151 }
1152 } // namespace Media
1153 } // namespace OHOS