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_low_latency_impl_unit_test.h"
17
18 namespace OHOS {
19 namespace Media {
20
21 using namespace testing::ext;
22
23 const int32_t MAX_SOUND_POOL_STREAMS = 1;
24 const float NUM1 = -1.0f;
25 const float NUM2 = 2.0f;
26 const float NUM3 = 0.5f;
27
SetUpTestCase(void)28 void AudioHapticSoundLowLatencyImplUnitTest::SetUpTestCase(void) {}
29
TearDownTestCase(void)30 void AudioHapticSoundLowLatencyImplUnitTest::TearDownTestCase(void) {}
31
SetUp(void)32 void AudioHapticSoundLowLatencyImplUnitTest::SetUp(void) {}
33
TearDown(void)34 void AudioHapticSoundLowLatencyImplUnitTest::TearDown(void) {}
35
36 /**
37 * @tc.name : Test AudioHapticSoundLowLatencyImpl API
38 * @tc.number: AudioHapticSoundLowLatencyImpl_001
39 * @tc.desc : Test AudioHapticSoundLowLatencyImpl::~AudioHapticSoundLowLatencyImpl()
40 */
41 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_001, TestSize.Level1)
42 {
43 std::string audioUri = "123";
44 bool muteAudio = true;
45 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
46 bool parallelPlayFlag = true;
47 auto audioHapticSoundLowLatencyImpl =
48 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
49
50 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
51
52 AudioStandard::AudioRendererInfo audioRendererInfo;
53 audioRendererInfo.contentType = AudioStandard::ContentType::CONTENT_TYPE_UNKNOWN;
54 audioRendererInfo.streamUsage = AudioStandard::STREAM_USAGE_UNKNOWN;
55 audioRendererInfo.rendererFlags = 1;
56
57 audioHapticSoundLowLatencyImpl->soundPoolPlayer_ =
58 SoundPoolFactory::CreateSoundPool(MAX_SOUND_POOL_STREAMS, audioRendererInfo);
59
60 EXPECT_NE(audioHapticSoundLowLatencyImpl->soundPoolPlayer_, nullptr);
61 }
62
63 /**
64 * @tc.name : Test AudioHapticSoundLowLatencyImpl API
65 * @tc.number: AudioHapticSoundLowLatencyImpl_002
66 * @tc.desc : Test AudioHapticSoundLowLatencyImpl::~AudioHapticSoundLowLatencyImpl()
67 */
68 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_002, TestSize.Level1)
69 {
70 std::string audioUri = "123";
71 bool muteAudio = true;
72 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
73 bool parallelPlayFlag = true;
74 auto audioHapticSoundLowLatencyImpl =
75 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
76
77 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
78
79 audioHapticSoundLowLatencyImpl->soundPoolPlayer_ = nullptr;
80
81 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
82 }
83
84 /**
85 * @tc.name : Test AudioHapticSoundLowLatencyImpl API
86 * @tc.number: AudioHapticSoundLowLatencyImpl_003
87 * @tc.desc : Test AudioHapticSoundLowLatencyImpl::OpenAudioUri()
88 */
89 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_003, TestSize.Level1)
90 {
91 std::string audioUri = "123";
92 bool muteAudio = true;
93 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
94 bool parallelPlayFlag = true;
95 auto audioHapticSoundLowLatencyImpl =
96 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
97
98 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
99
100 audioHapticSoundLowLatencyImpl->fileDes_ = 0;
101 audioHapticSoundLowLatencyImpl->audioUri_ = "123";
102
103 auto ret = audioHapticSoundLowLatencyImpl->OpenAudioUri(audioUri);
104 EXPECT_NE(ret, MSERR_OK);
105 }
106
107 /**
108 * @tc.name : Test AudioHapticSoundLowLatencyImpl API
109 * @tc.number: AudioHapticSoundLowLatencyImpl_004
110 * @tc.desc : Test AudioHapticSoundLowLatencyImpl::OpenAudioUri()
111 */
112 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_004, TestSize.Level1)
113 {
114 std::string audioUri = "123";
115 bool muteAudio = true;
116 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
117 bool parallelPlayFlag = true;
118 auto audioHapticSoundLowLatencyImpl =
119 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
120
121 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
122
123 audioHapticSoundLowLatencyImpl->fileDes_ = -1;
124 audioHapticSoundLowLatencyImpl->audioUri_ = "123";
125
126 auto ret = audioHapticSoundLowLatencyImpl->OpenAudioUri(audioUri);
127 EXPECT_NE(ret, MSERR_OK);
128 }
129
130 /**
131 * @tc.name : Test AudioHapticSoundLowLatencyImpl API
132 * @tc.number: AudioHapticSoundLowLatencyImpl_005
133 * @tc.desc : Test AudioHapticSoundLowLatencyImpl::StartSound()
134 */
135 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_005, TestSize.Level1)
136 {
137 std::string audioUri = "123";
138 bool muteAudio = true;
139 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
140 bool parallelPlayFlag = true;
141 auto audioHapticSoundLowLatencyImpl =
142 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
143
144 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
145
146 audioHapticSoundLowLatencyImpl->playerState_ = AudioHapticPlayerState::STATE_NEW;
147
148 auto ret = audioHapticSoundLowLatencyImpl->StartSound();
149 EXPECT_EQ(ret, MSERR_START_FAILED);
150 }
151
152 /**
153 * @tc.name : Test AudioHapticSoundLowLatencyImpl API
154 * @tc.number: AudioHapticSoundLowLatencyImpl_006
155 * @tc.desc : Test AudioHapticSoundLowLatencyImpl::StartSound()
156 */
157 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_006, TestSize.Level1)
158 {
159 std::string audioUri = "123";
160 bool muteAudio = true;
161 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
162 bool parallelPlayFlag = true;
163 auto audioHapticSoundLowLatencyImpl =
164 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
165
166 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
167
168 AudioStandard::AudioRendererInfo audioRendererInfo;
169 audioRendererInfo.contentType = AudioStandard::ContentType::CONTENT_TYPE_UNKNOWN;
170 audioRendererInfo.streamUsage = AudioStandard::STREAM_USAGE_UNKNOWN;
171 audioRendererInfo.rendererFlags = 1;
172
173 audioHapticSoundLowLatencyImpl->soundPoolPlayer_ =
174 SoundPoolFactory::CreateSoundPool(MAX_SOUND_POOL_STREAMS, audioRendererInfo);
175 EXPECT_NE(audioHapticSoundLowLatencyImpl->soundPoolPlayer_, nullptr);
176
177 audioHapticSoundLowLatencyImpl->playerState_ = AudioHapticPlayerState::STATE_STOPPED;
178
179 auto ret = audioHapticSoundLowLatencyImpl->StartSound();
180 EXPECT_EQ(ret, MSERR_OK);
181 }
182
183 /**
184 * @tc.name : Test AudioHapticSoundLowLatencyImpl API
185 * @tc.number: AudioHapticSoundLowLatencyImpl_007
186 * @tc.desc : Test AudioHapticSoundLowLatencyImpl::StartSound()
187 */
188 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_007, TestSize.Level1)
189 {
190 std::string audioUri = "123";
191 bool muteAudio = true;
192 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
193 bool parallelPlayFlag = true;
194 auto audioHapticSoundLowLatencyImpl =
195 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
196
197 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
198
199 AudioStandard::AudioRendererInfo audioRendererInfo;
200 audioRendererInfo.contentType = AudioStandard::ContentType::CONTENT_TYPE_UNKNOWN;
201 audioRendererInfo.streamUsage = AudioStandard::STREAM_USAGE_UNKNOWN;
202 audioRendererInfo.rendererFlags = 1;
203
204 audioHapticSoundLowLatencyImpl->soundPoolPlayer_ =
205 SoundPoolFactory::CreateSoundPool(MAX_SOUND_POOL_STREAMS, audioRendererInfo);
206
207 audioHapticSoundLowLatencyImpl->playerState_ = AudioHapticPlayerState::STATE_RUNNING;
208 EXPECT_NE(audioHapticSoundLowLatencyImpl->soundPoolPlayer_, nullptr);
209
210 auto ret = audioHapticSoundLowLatencyImpl->StartSound();
211 EXPECT_EQ(ret, MSERR_OK);
212 }
213
214 /**
215 * @tc.name : Test AudioHapticSoundLowLatencyImpl API
216 * @tc.number: AudioHapticSoundLowLatencyImpl_008
217 * @tc.desc : Test AudioHapticSoundLowLatencyImpl::StartSound()
218 */
219 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_008, TestSize.Level1)
220 {
221 std::string audioUri = "123";
222 bool muteAudio = true;
223 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
224 bool parallelPlayFlag = true;
225 auto audioHapticSoundLowLatencyImpl =
226 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
227
228 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
229
230 AudioStandard::AudioRendererInfo audioRendererInfo;
231 audioRendererInfo.contentType = AudioStandard::ContentType::CONTENT_TYPE_UNKNOWN;
232 audioRendererInfo.streamUsage = AudioStandard::STREAM_USAGE_UNKNOWN;
233 audioRendererInfo.rendererFlags = 1;
234
235 audioHapticSoundLowLatencyImpl->soundPoolPlayer_ =
236 SoundPoolFactory::CreateSoundPool(MAX_SOUND_POOL_STREAMS, audioRendererInfo);
237
238 audioHapticSoundLowLatencyImpl->playerState_ = AudioHapticPlayerState::STATE_PREPARED;
239 EXPECT_NE(audioHapticSoundLowLatencyImpl->soundPoolPlayer_, nullptr);
240
241 auto ret = audioHapticSoundLowLatencyImpl->StartSound();
242 EXPECT_EQ(ret, MSERR_OK);
243 }
244
245 /**
246 * @tc.name : Test AudioHapticSoundLowLatencyImpl API
247 * @tc.number: AudioHapticSoundLowLatencyImpl_009
248 * @tc.desc : Test AudioHapticSoundLowLatencyImpl::ReleaseSoundPoolPlayer()
249 */
250 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_009, TestSize.Level1)
251 {
252 std::string audioUri = "123";
253 bool muteAudio = true;
254 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
255 bool parallelPlayFlag = true;
256 auto audioHapticSoundLowLatencyImpl =
257 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
258
259 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
260
261 AudioStandard::AudioRendererInfo audioRendererInfo;
262 audioRendererInfo.contentType = AudioStandard::ContentType::CONTENT_TYPE_UNKNOWN;
263 audioRendererInfo.streamUsage = AudioStandard::STREAM_USAGE_UNKNOWN;
264 audioRendererInfo.rendererFlags = 1;
265
266 audioHapticSoundLowLatencyImpl->soundPoolPlayer_ =
267 SoundPoolFactory::CreateSoundPool(MAX_SOUND_POOL_STREAMS, audioRendererInfo);
268
269 EXPECT_NE(audioHapticSoundLowLatencyImpl->soundPoolPlayer_, nullptr);
270
271 audioHapticSoundLowLatencyImpl->fileDes_ = 0;
272
273 audioHapticSoundLowLatencyImpl->ReleaseSoundPoolPlayer();
274 }
275
276 /**
277 * @tc.name : Test AudioHapticSoundLowLatencyImpl API
278 * @tc.number: AudioHapticSoundLowLatencyImpl_010
279 * @tc.desc : Test AudioHapticSoundLowLatencyImpl::ReleaseSoundPoolPlayer()
280 */
281 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_010, TestSize.Level1)
282 {
283 std::string audioUri = "123";
284 bool muteAudio = true;
285 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
286 bool parallelPlayFlag = true;
287 auto audioHapticSoundLowLatencyImpl =
288 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
289
290 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
291
292 audioHapticSoundLowLatencyImpl->soundPoolPlayer_ = nullptr;
293 audioHapticSoundLowLatencyImpl->fileDes_ = -1;
294
295 audioHapticSoundLowLatencyImpl->ReleaseSoundPoolPlayer();
296 }
297
298 /**
299 * @tc.name : Test AudioHapticSoundLowLatencyImpl API
300 * @tc.number: AudioHapticSoundLowLatencyImpl_011
301 * @tc.desc : Test AudioHapticSoundLowLatencyImpl::SetVolume()
302 */
303 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_011, TestSize.Level1)
304 {
305 std::string audioUri = "123";
306 bool muteAudio = true;
307 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
308 bool parallelPlayFlag = true;
309 auto audioHapticSoundLowLatencyImpl =
310 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
311
312 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
313
314 float volume = NUM1;
315
316 auto ret = audioHapticSoundLowLatencyImpl->SetVolume(volume);
317 EXPECT_EQ(ret, MSERR_INVALID_VAL);
318 }
319
320 /**
321 * @tc.name : Test AudioHapticSoundLowLatencyImpl API
322 * @tc.number: AudioHapticSoundLowLatencyImpl_012
323 * @tc.desc : Test AudioHapticSoundLowLatencyImpl::SetVolume()
324 */
325 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_012, TestSize.Level1)
326 {
327 std::string audioUri = "123";
328 bool muteAudio = true;
329 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
330 bool parallelPlayFlag = true;
331 auto audioHapticSoundLowLatencyImpl =
332 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
333
334 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
335
336 float volume = NUM2;
337
338 auto ret = audioHapticSoundLowLatencyImpl->SetVolume(volume);
339 EXPECT_EQ(ret, MSERR_INVALID_VAL);
340 }
341
342 /**
343 * @tc.name : Test AudioHapticSoundLowLatencyImpl API
344 * @tc.number: AudioHapticSoundLowLatencyImpl_013
345 * @tc.desc : Test AudioHapticSoundLowLatencyImpl::SetVolume()
346 */
347 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_013, TestSize.Level1)
348 {
349 std::string audioUri = "123";
350 bool muteAudio = true;
351 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
352 bool parallelPlayFlag = true;
353 auto audioHapticSoundLowLatencyImpl =
354 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
355
356 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
357
358 float volume = NUM3;
359 audioHapticSoundLowLatencyImpl->playerState_ = AudioHapticPlayerState::STATE_NEW;
360
361 auto ret = audioHapticSoundLowLatencyImpl->SetVolume(volume);
362 EXPECT_EQ(ret, MSERR_OK);
363 }
364
365 /**
366 * @tc.name : Test AudioHapticSoundLowLatencyImpl API
367 * @tc.number: AudioHapticSoundLowLatencyImpl_014
368 * @tc.desc : Test AudioHapticSoundLowLatencyImpl::SetVolume()
369 */
370 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_014, TestSize.Level1)
371 {
372 std::string audioUri = "123";
373 bool muteAudio = true;
374 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
375 bool parallelPlayFlag = true;
376 auto audioHapticSoundLowLatencyImpl =
377 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
378
379 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
380
381 float volume = NUM3;
382 audioHapticSoundLowLatencyImpl->playerState_ = AudioHapticPlayerState::STATE_RUNNING;
383
384 AudioStandard::AudioRendererInfo audioRendererInfo;
385 audioRendererInfo.contentType = AudioStandard::ContentType::CONTENT_TYPE_UNKNOWN;
386 audioRendererInfo.streamUsage = AudioStandard::STREAM_USAGE_UNKNOWN;
387 audioRendererInfo.rendererFlags = 1;
388
389 audioHapticSoundLowLatencyImpl->soundPoolPlayer_ =
390 SoundPoolFactory::CreateSoundPool(MAX_SOUND_POOL_STREAMS, audioRendererInfo);
391
392 audioHapticSoundLowLatencyImpl->streamID_ = 0;
393 EXPECT_NE(audioHapticSoundLowLatencyImpl->soundPoolPlayer_, nullptr);
394
395 auto ret = audioHapticSoundLowLatencyImpl->SetVolume(volume);
396 EXPECT_NE(ret, MSERR_OK);
397 }
398
399 /**
400 * @tc.name : Test AudioHapticSoundLowLatencyImpl API
401 * @tc.number: AudioHapticSoundLowLatencyImpl_015
402 * @tc.desc : Test AudioHapticSoundLowLatencyImpl::SetVolume()
403 */
404 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_015, TestSize.Level1)
405 {
406 std::string audioUri = "123";
407 bool muteAudio = true;
408 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
409 bool parallelPlayFlag = true;
410 auto audioHapticSoundLowLatencyImpl =
411 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
412
413 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
414
415 float volume = NUM3;
416 audioHapticSoundLowLatencyImpl->playerState_ = AudioHapticPlayerState::STATE_PREPARED;
417 audioHapticSoundLowLatencyImpl->streamID_ = -1;
418
419 auto ret = audioHapticSoundLowLatencyImpl->SetVolume(volume);
420 EXPECT_EQ(ret, MSERR_OK);
421 }
422
423 /**
424 * @tc.name : Test AudioHapticSoundLowLatencyImpl API
425 * @tc.number: AudioHapticSoundLowLatencyImpl_016
426 * @tc.desc : Test AudioHapticSoundLowLatencyImpl::SetLoop()
427 */
428 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_016, TestSize.Level1)
429 {
430 std::string audioUri = "123";
431 bool muteAudio = true;
432 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
433 bool parallelPlayFlag = true;
434 auto audioHapticSoundLowLatencyImpl =
435 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
436
437 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
438
439 bool loop = true;
440 audioHapticSoundLowLatencyImpl->playerState_ = AudioHapticPlayerState::STATE_NEW;
441
442 auto ret = audioHapticSoundLowLatencyImpl->SetLoop(loop);
443 EXPECT_EQ(ret, MSERR_OK);
444 }
445
446 /**
447 * @tc.name : Test AudioHapticSoundLowLatencyImpl API
448 * @tc.number: AudioHapticSoundLowLatencyImpl_017
449 * @tc.desc : Test AudioHapticSoundLowLatencyImpl::SetLoop()
450 */
451 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_017, TestSize.Level1)
452 {
453 std::string audioUri = "123";
454 bool muteAudio = true;
455 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
456 bool parallelPlayFlag = true;
457 auto audioHapticSoundLowLatencyImpl =
458 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
459
460 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
461
462 bool loop = true;
463 audioHapticSoundLowLatencyImpl->playerState_ = AudioHapticPlayerState::STATE_RUNNING;
464 audioHapticSoundLowLatencyImpl->streamID_ = 0;
465
466 AudioStandard::AudioRendererInfo audioRendererInfo;
467 audioRendererInfo.contentType = AudioStandard::ContentType::CONTENT_TYPE_UNKNOWN;
468 audioRendererInfo.streamUsage = AudioStandard::STREAM_USAGE_UNKNOWN;
469 audioRendererInfo.rendererFlags = 1;
470
471 audioHapticSoundLowLatencyImpl->soundPoolPlayer_ =
472 SoundPoolFactory::CreateSoundPool(MAX_SOUND_POOL_STREAMS, audioRendererInfo);
473 EXPECT_NE(audioHapticSoundLowLatencyImpl->soundPoolPlayer_, nullptr);
474
475
476 auto ret = audioHapticSoundLowLatencyImpl->SetLoop(loop);
477 EXPECT_NE(ret, MSERR_OK);
478 }
479
480 /**
481 * @tc.name : Test AudioHapticSoundLowLatencyImpl API
482 * @tc.number: AudioHapticSoundLowLatencyImpl_018
483 * @tc.desc : Test AudioHapticSoundLowLatencyImpl::SetLoop()
484 */
485 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_018, TestSize.Level1)
486 {
487 std::string audioUri = "123";
488 bool muteAudio = true;
489 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
490 bool parallelPlayFlag = true;
491 auto audioHapticSoundLowLatencyImpl =
492 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
493
494 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
495
496 bool loop = true;
497 audioHapticSoundLowLatencyImpl->playerState_ = AudioHapticPlayerState::STATE_PREPARED;
498 audioHapticSoundLowLatencyImpl->streamID_ = -1;
499
500 auto ret = audioHapticSoundLowLatencyImpl->SetLoop(loop);
501 EXPECT_EQ(ret, MSERR_OK);
502 }
503
504 /**
505 * @tc.name : Test AudioHapticSoundLowLatencyImpl API
506 * @tc.number: AudioHapticSoundLowLatencyImpl_019
507 * @tc.desc : Test AudioHapticSoundLowLatencyImpl::SetAudioHapticSoundCallback()
508 */
509 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_019, TestSize.Level1)
510 {
511 std::string audioUri = "123";
512 bool muteAudio = true;
513 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
514 bool parallelPlayFlag = true;
515 auto audioHapticSoundLowLatencyImpl =
516 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
517
518 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
519
520 auto callback = std::make_shared<AudioHapticSoundCallbackImpl>(std::make_shared<AudioHapticPlayerImpl>());
521 EXPECT_NE(callback, nullptr);
522
523 auto ret = audioHapticSoundLowLatencyImpl->SetAudioHapticSoundCallback(callback);
524 EXPECT_EQ(ret, MSERR_OK);
525 }
526
527 /**
528 * @tc.name : Test AudioHapticSoundLowLatencyImpl API
529 * @tc.number: AudioHapticSoundLowLatencyImpl_020
530 * @tc.desc : Test AudioHapticSoundLowLatencyImpl::SetAudioHapticSoundCallback()
531 */
532 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_020, TestSize.Level1)
533 {
534 std::string audioUri = "123";
535 bool muteAudio = true;
536 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
537 bool parallelPlayFlag = true;
538 auto audioHapticSoundLowLatencyImpl =
539 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
540
541 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
542
543 std::shared_ptr<AudioHapticSoundCallback> callback = nullptr;
544
545 auto ret = audioHapticSoundLowLatencyImpl->SetAudioHapticSoundCallback(callback);
546 EXPECT_EQ(ret, MSERR_INVALID_VAL);
547 }
548
549 /**
550 * @tc.name : Test AudioHapticSoundLowLatencyImpl API
551 * @tc.number: AudioHapticSoundLowLatencyImpl_021
552 * @tc.desc : Test AudioHapticSoundLowLatencyImpl::NotifyErrorEvent()
553 */
554 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_021, TestSize.Level1)
555 {
556 std::string audioUri = "123";
557 bool muteAudio = true;
558 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
559 bool parallelPlayFlag = true;
560 auto audioHapticSoundLowLatencyImpl =
561 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
562
563 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
564
565 int32_t errorCode = MediaServiceErrCode::MSERR_UNSUPPORT_FILE;
566 audioHapticSoundLowLatencyImpl->audioHapticPlayerCallback_.reset();
567 audioHapticSoundLowLatencyImpl->NotifyErrorEvent(errorCode);
568 }
569
570 /**
571 * @tc.name : Test AudioHapticSoundLowLatencyImpl API
572 * @tc.number: AudioHapticSoundLowLatencyImpl_022
573 * @tc.desc : Test AudioHapticSoundLowLatencyImpl::NotifyErrorEvent()
574 */
575 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_022, TestSize.Level1)
576 {
577 std::string audioUri = "123";
578 bool muteAudio = true;
579 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
580 bool parallelPlayFlag = true;
581 auto audioHapticSoundLowLatencyImpl =
582 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
583
584 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
585
586 int32_t errorCode = MediaServiceErrCode::MSERR_OK;
587
588 std::shared_ptr<AudioHapticSoundCallback> sharedcb =
589 std::make_shared<AudioHapticSoundCallbackImpl>(std::make_shared<AudioHapticPlayerImpl>());
590 audioHapticSoundLowLatencyImpl->audioHapticPlayerCallback_ = sharedcb;
591
592 EXPECT_NE(audioHapticSoundLowLatencyImpl->audioHapticPlayerCallback_.lock(), nullptr);
593
594 audioHapticSoundLowLatencyImpl->NotifyErrorEvent(errorCode);
595 }
596
597 /**
598 * @tc.name : Test AudioHapticSoundLowLatencyImpl API
599 * @tc.number: AudioHapticSoundLowLatencyImpl_023
600 * @tc.desc : Test AudioHapticSoundLowLatencyImpl::NotifyFirstFrameEvent()
601 */
602 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_023, TestSize.Level1)
603 {
604 std::string audioUri = "123";
605 bool muteAudio = true;
606 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
607 bool parallelPlayFlag = true;
608 auto audioHapticSoundLowLatencyImpl =
609 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
610
611 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
612
613 uint64_t latency = 0;
614
615 audioHapticSoundLowLatencyImpl->audioHapticPlayerCallback_.reset();
616 audioHapticSoundLowLatencyImpl->NotifyFirstFrameEvent(latency);
617 }
618
619 /**
620 * @tc.name : Test AudioHapticSoundLowLatencyImpl API
621 * @tc.number: AudioHapticSoundLowLatencyImpl_024
622 * @tc.desc : Test AudioHapticSoundLowLatencyImpl::NotifyFirstFrameEvent()
623 */
624 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_024, TestSize.Level1)
625 {
626 std::string audioUri = "123";
627 bool muteAudio = true;
628 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
629 bool parallelPlayFlag = true;
630 auto audioHapticSoundLowLatencyImpl =
631 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
632
633 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
634
635 uint64_t latency = 0;
636
637 std::shared_ptr<AudioHapticSoundCallback> sharedcb =
638 std::make_shared<AudioHapticSoundCallbackImpl>(std::make_shared<AudioHapticPlayerImpl>());
639 audioHapticSoundLowLatencyImpl->audioHapticPlayerCallback_ = sharedcb;
640
641 EXPECT_NE(audioHapticSoundLowLatencyImpl->audioHapticPlayerCallback_.lock(), nullptr);
642
643 audioHapticSoundLowLatencyImpl->NotifyFirstFrameEvent(latency);
644 }
645
646 /**
647 * @tc.name : Test AudioHapticSoundLowLatencyImpl API
648 * @tc.number: AudioHapticSoundLowLatencyImpl_025
649 * @tc.desc : Test AudioHapticSoundLowLatencyImpl::NotifyEndOfStreamEvent()
650 */
651 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_025, TestSize.Level1)
652 {
653 std::string audioUri = "123";
654 bool muteAudio = true;
655 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
656 bool parallelPlayFlag = true;
657 auto audioHapticSoundLowLatencyImpl =
658 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
659
660 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
661
662 audioHapticSoundLowLatencyImpl->audioHapticPlayerCallback_.reset();
663 audioHapticSoundLowLatencyImpl->NotifyEndOfStreamEvent();
664 }
665
666 /**
667 * @tc.name : Test AudioHapticSoundLowLatencyImpl API
668 * @tc.number: AudioHapticSoundLowLatencyImpl_026
669 * @tc.desc : Test AudioHapticSoundLowLatencyImpl::NotifyEndOfStreamEvent()
670 */
671 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_026, TestSize.Level1)
672 {
673 std::string audioUri = "123";
674 bool muteAudio = true;
675 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
676 bool parallelPlayFlag = true;
677 auto audioHapticSoundLowLatencyImpl =
678 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
679
680 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
681
682 std::shared_ptr<AudioHapticSoundCallback> sharedcb =
683 std::make_shared<AudioHapticSoundCallbackImpl>(std::make_shared<AudioHapticPlayerImpl>());
684 audioHapticSoundLowLatencyImpl->audioHapticPlayerCallback_ = sharedcb;
685
686 EXPECT_NE(audioHapticSoundLowLatencyImpl->audioHapticPlayerCallback_.lock(), nullptr);
687
688 audioHapticSoundLowLatencyImpl->NotifyEndOfStreamEvent();
689 }
690
691 /**
692 * @tc.name : Test AHSoundLowLatencyCallback API
693 * @tc.number: AudioHapticSoundLowLatencyImpl_027
694 * @tc.desc : Test AHSoundLowLatencyCallback::OnLoadCompleted()
695 */
696 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_027, TestSize.Level1)
697 {
698 std::string audioUri = "123";
699 bool muteAudio = true;
700 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
701 bool parallelPlayFlag = true;
702 auto audioHapticSoundLowLatencyImpl =
703 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
704
705 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
706
707 auto aHSoundLowLatencyCallback = std::make_shared<AHSoundLowLatencyCallback>(audioHapticSoundLowLatencyImpl);
708 EXPECT_NE(aHSoundLowLatencyCallback, nullptr);
709
710 int32_t soundId = 0;
711 aHSoundLowLatencyCallback->soundLowLatencyImpl_.reset();
712
713 aHSoundLowLatencyCallback->OnLoadCompleted(soundId);
714 }
715
716 /**
717 * @tc.name : Test AHSoundLowLatencyCallback API
718 * @tc.number: AudioHapticSoundLowLatencyImpl_028
719 * @tc.desc : Test AHSoundLowLatencyCallback::OnLoadCompleted()
720 */
721 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_028, TestSize.Level1)
722 {
723 std::string audioUri = "123";
724 bool muteAudio = true;
725 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
726 bool parallelPlayFlag = true;
727 auto audioHapticSoundLowLatencyImpl =
728 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
729
730 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
731
732 auto aHSoundLowLatencyCallback = std::make_shared<AHSoundLowLatencyCallback>(audioHapticSoundLowLatencyImpl);
733 EXPECT_NE(aHSoundLowLatencyCallback, nullptr);
734
735 int32_t soundId = 0;
736
737 std::shared_ptr<AudioHapticSoundLowLatencyImpl> sharedcb =
738 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
739 aHSoundLowLatencyCallback->soundLowLatencyImpl_ = sharedcb;
740
741 EXPECT_NE(aHSoundLowLatencyCallback->soundLowLatencyImpl_.lock(), nullptr);
742
743
744 aHSoundLowLatencyCallback->OnLoadCompleted(soundId);
745 }
746
747 /**
748 * @tc.name : Test AHSoundLowLatencyCallback API
749 * @tc.number: AudioHapticSoundLowLatencyImpl_029
750 * @tc.desc : Test AHSoundLowLatencyCallback::OnPlayFinished()
751 */
752 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_029, TestSize.Level1)
753 {
754 std::string audioUri = "123";
755 bool muteAudio = true;
756 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
757 bool parallelPlayFlag = true;
758 auto audioHapticSoundLowLatencyImpl =
759 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
760
761 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
762
763 auto aHSoundLowLatencyCallback = std::make_shared<AHSoundLowLatencyCallback>(audioHapticSoundLowLatencyImpl);
764 EXPECT_NE(aHSoundLowLatencyCallback, nullptr);
765
766 int32_t streamID = 0;
767 aHSoundLowLatencyCallback->soundLowLatencyImpl_.reset();
768
769 aHSoundLowLatencyCallback->OnPlayFinished(streamID);
770 }
771
772 /**
773 * @tc.name : Test AHSoundLowLatencyCallback API
774 * @tc.number: AudioHapticSoundLowLatencyImpl_030
775 * @tc.desc : Test AHSoundLowLatencyCallback::OnPlayFinished()
776 */
777 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_030, TestSize.Level1)
778 {
779 std::string audioUri = "123";
780 bool muteAudio = true;
781 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
782 bool parallelPlayFlag = true;
783 auto audioHapticSoundLowLatencyImpl =
784 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
785
786 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
787
788 auto aHSoundLowLatencyCallback = std::make_shared<AHSoundLowLatencyCallback>(audioHapticSoundLowLatencyImpl);
789 EXPECT_NE(aHSoundLowLatencyCallback, nullptr);
790
791 int32_t streamID = 0;
792 std::shared_ptr<AudioHapticSoundLowLatencyImpl> sharedcb =
793 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
794 aHSoundLowLatencyCallback->soundLowLatencyImpl_ = sharedcb;
795
796 EXPECT_NE(aHSoundLowLatencyCallback->soundLowLatencyImpl_.lock(), nullptr);
797
798 aHSoundLowLatencyCallback->OnPlayFinished(streamID);
799 }
800
801 /**
802 * @tc.name : Test AHSoundLowLatencyCallback API
803 * @tc.number: AudioHapticSoundLowLatencyImpl_031
804 * @tc.desc : Test AHSoundLowLatencyCallback::OnError()
805 */
806 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_031, TestSize.Level1)
807 {
808 std::string audioUri = "123";
809 bool muteAudio = true;
810 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
811 bool parallelPlayFlag = true;
812 auto audioHapticSoundLowLatencyImpl =
813 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
814
815 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
816
817 auto aHSoundLowLatencyCallback = std::make_shared<AHSoundLowLatencyCallback>(audioHapticSoundLowLatencyImpl);
818 EXPECT_NE(aHSoundLowLatencyCallback, nullptr);
819
820 int32_t errorCode = 0;
821 aHSoundLowLatencyCallback->soundLowLatencyImpl_.reset();
822
823 aHSoundLowLatencyCallback->OnError(errorCode);
824 }
825
826 /**
827 * @tc.name : Test AHSoundLowLatencyCallback API
828 * @tc.number: AudioHapticSoundLowLatencyImpl_032
829 * @tc.desc : Test AHSoundLowLatencyCallback::OnError()
830 */
831 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_032, TestSize.Level1)
832 {
833 std::string audioUri = "123";
834 bool muteAudio = true;
835 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
836 bool parallelPlayFlag = true;
837 auto audioHapticSoundLowLatencyImpl =
838 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
839
840 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
841
842 auto aHSoundLowLatencyCallback = std::make_shared<AHSoundLowLatencyCallback>(audioHapticSoundLowLatencyImpl);
843 EXPECT_NE(aHSoundLowLatencyCallback, nullptr);
844
845 int32_t errorCode = 0;
846 std::shared_ptr<AudioHapticSoundLowLatencyImpl> sharedcb =
847 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
848 aHSoundLowLatencyCallback->soundLowLatencyImpl_ = sharedcb;
849
850 EXPECT_NE(aHSoundLowLatencyCallback->soundLowLatencyImpl_.lock(), nullptr);
851
852 aHSoundLowLatencyCallback->OnError(errorCode);
853 }
854
855 /**
856 * @tc.name : Test AHSoundFirstFrameCallback API
857 * @tc.number: AudioHapticSoundLowLatencyImpl_033
858 * @tc.desc : Test AHSoundFirstFrameCallback::OnFirstAudioFrameWritingCallback()
859 */
860 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_033, TestSize.Level1)
861 {
862 std::string audioUri = "123";
863 bool muteAudio = true;
864 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
865 bool parallelPlayFlag = true;
866 auto audioHapticSoundLowLatencyImpl =
867 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
868
869 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
870
871 auto aHSoundFirstFrameCallback = std::make_shared<AHSoundFirstFrameCallback>(audioHapticSoundLowLatencyImpl);
872 EXPECT_NE(aHSoundFirstFrameCallback, nullptr);
873
874 uint64_t latency = 0;
875 aHSoundFirstFrameCallback->soundLowLatencyImpl_.reset();
876
877 aHSoundFirstFrameCallback->OnFirstAudioFrameWritingCallback(latency);
878 }
879
880 /**
881 * @tc.name : Test AHSoundFirstFrameCallback API
882 * @tc.number: AudioHapticSoundLowLatencyImpl_034
883 * @tc.desc : Test AHSoundFirstFrameCallback::OnFirstAudioFrameWritingCallback()
884 */
885 HWTEST_F(AudioHapticSoundLowLatencyImplUnitTest, AudioHapticSoundLowLatencyImpl_034, TestSize.Level1)
886 {
887 std::string audioUri = "123";
888 bool muteAudio = true;
889 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
890 bool parallelPlayFlag = true;
891 auto audioHapticSoundLowLatencyImpl =
892 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
893
894 EXPECT_NE(audioHapticSoundLowLatencyImpl, nullptr);
895
896 auto aHSoundFirstFrameCallback = std::make_shared<AHSoundFirstFrameCallback>(audioHapticSoundLowLatencyImpl);
897 EXPECT_NE(aHSoundFirstFrameCallback, nullptr);
898
899 uint64_t latency = 0;
900 std::shared_ptr<AudioHapticSoundLowLatencyImpl> sharedcb =
901 std::make_shared<AudioHapticSoundLowLatencyImpl>(audioUri, muteAudio, streamUsage, parallelPlayFlag);
902 aHSoundFirstFrameCallback->soundLowLatencyImpl_ = sharedcb;
903
904 EXPECT_NE(aHSoundFirstFrameCallback->soundLowLatencyImpl_.lock(), nullptr);
905
906 aHSoundFirstFrameCallback->OnFirstAudioFrameWritingCallback(latency);
907 }
908 } // namespace Media
909 } // namespace OHOS