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