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