1 /*
2 * Copyright (c) 2022 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 <array>
17 #include <string>
18 #include <gmock/gmock.h>
19 #include <gtest/gtest.h>
20
21 #include "audio_renderer_adapter.h"
22 #include "audio_renderer_adapter_impl.h"
23 #include "audio_system_manager_adapter_impl.h"
24 #include "foundation/ability/ability_runtime/interfaces/kits/native/appkit/ability_runtime/context/application_context.h"
25
26 using namespace testing;
27 using namespace testing::ext;
28 using namespace OHOS::AbilityRuntime;
29
30 namespace OHOS {
31 namespace {
32 const int RESULT_OK = 0;
33 const bool TRUE_OK = true;
34 const std::string CACHE_PATH = "/data/local/tmp";
35 std::shared_ptr<NWeb::AudioRendererAdapterImpl> g_audioRender = nullptr;
36 std::shared_ptr<AbilityRuntime::ApplicationContext> g_applicationContext = nullptr;
37 } // namespace
38
39 namespace AbilityRuntime {
GetApplicationContext()40 std::shared_ptr<ApplicationContext> Context::GetApplicationContext()
41 {
42 return g_applicationContext;
43 }
44 } // namespace OHOS::AbilityRuntime
45
46 namespace NWeb {
47 class NWebAudioAdapterTest : public testing::Test {
48 public:
49 static void SetUpTestCase(void);
50 static void TearDownTestCase(void);
51 void SetUp();
52 void TearDown();
53 };
54
55 class ApplicationContextMock : public ApplicationContext {
56 public:
57 MOCK_METHOD0(GetCacheDir, std::string());
58 };
59
60 class AudioCallbackTest : public AudioManagerCallbackAdapter {
61 public:
62 AudioCallbackTest() = default;
63
64 virtual ~AudioCallbackTest() = default;
65
OnSuspend()66 void OnSuspend() override {};
67
OnResume()68 void OnResume() override {};
69 };
70
SetUpTestCase(void)71 void NWebAudioAdapterTest::SetUpTestCase(void) {}
72
TearDownTestCase(void)73 void NWebAudioAdapterTest::TearDownTestCase(void) {}
74
SetUp(void)75 void NWebAudioAdapterTest::SetUp(void) {}
76
TearDown(void)77 void NWebAudioAdapterTest::TearDown(void) {}
78
79 class AudioRendererWriteCallbackAdapterMock : public AudioRendererWriteCallbackAdapter {
80 public:
OnWriteData(size_t length)81 void OnWriteData(size_t length) override {};
82 };
83
84 /**
85 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_001.
86 * @tc.desc: Audio adapter unittest.
87 * @tc.type: FUNC.
88 * @tc.require:I5HRX9
89 */
90 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_001, TestSize.Level1)
91 {
92 g_audioRender = std::make_shared<AudioRendererAdapterImpl>();
93 ASSERT_NE(g_audioRender, nullptr);
94
95 AudioAdapterRendererOptions rendererOptions;
96 rendererOptions.samplingRate = AudioAdapterSamplingRate::SAMPLE_RATE_44100;
97 rendererOptions.encoding = AudioAdapterEncodingType::ENCODING_PCM;
98 rendererOptions.format = AudioAdapterSampleFormat::SAMPLE_S16LE;
99 rendererOptions.channels = AudioAdapterChannel::STEREO;
100 rendererOptions.contentType = AudioAdapterContentType::CONTENT_TYPE_MUSIC;
101 rendererOptions.streamUsage = AudioAdapterStreamUsage::STREAM_USAGE_MEDIA;
102 rendererOptions.rendererFlags = 0;
103 int32_t retNum = g_audioRender->Create(rendererOptions, CACHE_PATH);
104 ASSERT_EQ(retNum, AudioAdapterCode::AUDIO_OK);
105
106 bool ret = g_audioRender->Start();
107 EXPECT_EQ(ret, TRUE_OK);
108
109 std::array<uint8_t, 4> bufferArray = {0, 0, 0, 0};
110 retNum = g_audioRender->Write(bufferArray.data(), bufferArray.size());
111 EXPECT_EQ(retNum, bufferArray.size());
112
113 uint64_t latency;
114 retNum = g_audioRender->GetLatency(latency);
115 EXPECT_EQ(retNum, RESULT_OK);
116
117 float volume = 0.8;
118 retNum = g_audioRender->SetVolume(volume);
119 EXPECT_EQ(retNum, RESULT_OK);
120
121 float nowVolume = g_audioRender->GetVolume();
122 EXPECT_EQ(nowVolume, volume);
123
124 ret = g_audioRender->Stop();
125 EXPECT_EQ(ret, TRUE_OK);
126
127 ret = g_audioRender->Release();
128 EXPECT_EQ(ret, TRUE_OK);
129 }
130
131 /**
132 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_002.
133 * @tc.desc: Audio adapter unittest.
134 * @tc.type: FUNC.
135 * @tc.require:I5HRX9
136 */
137 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_002, TestSize.Level1)
138 {
139 std::array<AudioAdapterSamplingRate, 11> samplingArray = {
140 AudioAdapterSamplingRate::SAMPLE_RATE_8000,
141 AudioAdapterSamplingRate::SAMPLE_RATE_11025,
142 AudioAdapterSamplingRate::SAMPLE_RATE_12000,
143 AudioAdapterSamplingRate::SAMPLE_RATE_16000,
144 AudioAdapterSamplingRate::SAMPLE_RATE_22050,
145 AudioAdapterSamplingRate::SAMPLE_RATE_24000,
146 AudioAdapterSamplingRate::SAMPLE_RATE_32000,
147 AudioAdapterSamplingRate::SAMPLE_RATE_44100,
148 AudioAdapterSamplingRate::SAMPLE_RATE_48000,
149 AudioAdapterSamplingRate::SAMPLE_RATE_64000,
150 AudioAdapterSamplingRate::SAMPLE_RATE_96000,
151 };
152 for (auto& sampling : samplingArray)
153 AudioRendererAdapterImpl::GetAudioSamplingRate(sampling);
154
155 AudioSamplingRate testSampling = AudioRendererAdapterImpl::GetAudioSamplingRate(
156 static_cast<AudioAdapterSamplingRate>(0));
157 EXPECT_EQ(testSampling, AudioSamplingRate::SAMPLE_RATE_44100);
158 }
159
160 /**
161 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_003.
162 * @tc.desc: Audio adapter unittest.
163 * @tc.type: FUNC.
164 * @tc.require:I5HRX9
165 */
166 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_003, TestSize.Level1)
167 {
168 AudioRendererAdapterImpl::GetAudioEncodingType(AudioAdapterEncodingType::ENCODING_PCM);
169 AudioRendererAdapterImpl::GetAudioEncodingType(AudioAdapterEncodingType::ENCODING_INVALID);
170
171 AudioEncodingType testEncodingType = AudioRendererAdapterImpl::GetAudioEncodingType(
172 static_cast<AudioAdapterEncodingType>(1));
173 EXPECT_EQ(testEncodingType, AudioEncodingType::ENCODING_INVALID);
174 }
175
176 /**
177 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_004.
178 * @tc.desc: Audio adapter unittest.
179 * @tc.type: FUNC.
180 * @tc.require:I5HRX9
181 */
182 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_004, TestSize.Level1)
183 {
184 std::array<AudioAdapterSampleFormat, 6> formatArray = {
185 AudioAdapterSampleFormat::SAMPLE_U8,
186 AudioAdapterSampleFormat::SAMPLE_S16LE,
187 AudioAdapterSampleFormat::SAMPLE_S24LE,
188 AudioAdapterSampleFormat::SAMPLE_S32LE,
189 AudioAdapterSampleFormat::SAMPLE_F32LE,
190 AudioAdapterSampleFormat::INVALID_WIDTH,
191 };
192 for (auto& format : formatArray)
193 AudioRendererAdapterImpl::GetAudioSampleFormat(format);
194
195 AudioSampleFormat testFormat = AudioRendererAdapterImpl::GetAudioSampleFormat(
196 static_cast<AudioAdapterSampleFormat>(-2));
197 EXPECT_EQ(testFormat, AudioSampleFormat::INVALID_WIDTH);
198 }
199
200 /**
201 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_005.
202 * @tc.desc: Audio adapter unittest.
203 * @tc.type: FUNC.
204 * @tc.require:I5HRX9
205 */
206 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_005, TestSize.Level1)
207 {
208 std::array<AudioAdapterChannel, 8> channelArray = {
209 AudioAdapterChannel::MONO,
210 AudioAdapterChannel::STEREO,
211 AudioAdapterChannel::CHANNEL_3,
212 AudioAdapterChannel::CHANNEL_4,
213 AudioAdapterChannel::CHANNEL_5,
214 AudioAdapterChannel::CHANNEL_6,
215 AudioAdapterChannel::CHANNEL_7,
216 AudioAdapterChannel::CHANNEL_8,
217 };
218 for (auto& channel : channelArray)
219 AudioRendererAdapterImpl::GetAudioChannel(channel);
220
221 AudioChannel testChannel = AudioRendererAdapterImpl::GetAudioChannel(
222 static_cast<AudioAdapterChannel>(0));
223 EXPECT_EQ(testChannel, AudioChannel::STEREO);
224 }
225
226 /**
227 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_006.
228 * @tc.desc: Audio adapter unittest.
229 * @tc.type: FUNC.
230 * @tc.require:I5HRX9
231 */
232 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_006, TestSize.Level1)
233 {
234 std::array<AudioAdapterContentType, 6> contentArray = {
235 AudioAdapterContentType::CONTENT_TYPE_UNKNOWN,
236 AudioAdapterContentType::CONTENT_TYPE_SPEECH,
237 AudioAdapterContentType::CONTENT_TYPE_MUSIC,
238 AudioAdapterContentType::CONTENT_TYPE_MOVIE,
239 AudioAdapterContentType::CONTENT_TYPE_SONIFICATION,
240 AudioAdapterContentType::CONTENT_TYPE_RINGTONE,
241 };
242 for (auto& content : contentArray)
243 AudioRendererAdapterImpl::GetAudioContentType(content);
244
245 ContentType testContent = AudioRendererAdapterImpl::GetAudioContentType(
246 static_cast<AudioAdapterContentType>(-1));
247 EXPECT_EQ(testContent, ContentType::CONTENT_TYPE_MUSIC);
248 }
249
250 /**
251 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_007.
252 * @tc.desc: Audio adapter unittest.
253 * @tc.type: FUNC.
254 * @tc.require:I5HRX9
255 */
256 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_007, TestSize.Level1)
257 {
258 std::array<AudioAdapterStreamUsage, 5> usageArray = {
259 AudioAdapterStreamUsage::STREAM_USAGE_UNKNOWN,
260 AudioAdapterStreamUsage::STREAM_USAGE_MEDIA,
261 AudioAdapterStreamUsage::STREAM_USAGE_VOICE_COMMUNICATION,
262 AudioAdapterStreamUsage::STREAM_USAGE_VOICE_ASSISTANT,
263 AudioAdapterStreamUsage::STREAM_USAGE_NOTIFICATION_RINGTONE,
264 };
265 for (auto& usage : usageArray)
266 AudioRendererAdapterImpl::GetAudioStreamUsage(usage);
267
268 StreamUsage testUsage = AudioRendererAdapterImpl::GetAudioStreamUsage(
269 static_cast<AudioAdapterStreamUsage>(-1));
270 EXPECT_EQ(testUsage, StreamUsage::STREAM_USAGE_MEDIA);
271 }
272
273 /**
274 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_008.
275 * @tc.desc: Audio adapter unittest.
276 * @tc.type: FUNC.
277 * @tc.require:I5HRX9
278 */
279 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_008, TestSize.Level1)
280 {
281 bool ret = AudioSystemManagerAdapterImpl::GetInstance().HasAudioOutputDevices();
282 EXPECT_EQ(ret, TRUE_OK);
283
284 ret = AudioSystemManagerAdapterImpl::GetInstance().HasAudioInputDevices();
285 EXPECT_EQ(ret, TRUE_OK);
286 }
287
288 /**
289 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_009.
290 * @tc.desc: Audio adapter unittest.
291 * @tc.type: FUNC.
292 * @tc.require:I5HRX9
293 */
294 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_009, TestSize.Level1)
295 {
296 AudioAdapterInterrupt interrupt;
297 interrupt.streamUsage = AudioAdapterStreamUsage::STREAM_USAGE_MEDIA;
298 interrupt.contentType = AudioAdapterContentType::CONTENT_TYPE_MUSIC;
299 interrupt.streamType = AudioAdapterStreamType::STREAM_MUSIC;
300
301 int32_t ret = AudioSystemManagerAdapterImpl::GetInstance().RequestAudioFocus(interrupt);
302 EXPECT_EQ(ret, RESULT_OK);
303
304 ret = AudioSystemManagerAdapterImpl::GetInstance().AbandonAudioFocus(interrupt);
305 EXPECT_EQ(ret, RESULT_OK);
306 }
307
308 /**
309 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_010.
310 * @tc.desc: Audio adapter unittest.
311 * @tc.type: FUNC.
312 * @tc.require:I5HRX9
313 */
314 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_010, TestSize.Level1)
315 {
316 auto callback = std::make_shared<AudioCallbackTest>();
317
318 int32_t ret = AudioSystemManagerAdapterImpl::GetInstance().SetAudioManagerInterruptCallback(callback);
319 EXPECT_EQ(ret, RESULT_OK);
320
321 ret = AudioSystemManagerAdapterImpl::GetInstance().UnsetAudioManagerInterruptCallback();
322 EXPECT_EQ(ret, RESULT_OK);
323 }
324
325 /**
326 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_011.
327 * @tc.desc: Audio adapter unittest.
328 * @tc.type: FUNC.
329 * @tc.require:I5HRX9
330 */
331 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_011, TestSize.Level1)
332 {
333 std::array<AudioAdapterStreamType, 16> streamArray = {
334 AudioAdapterStreamType::STREAM_DEFAULT,
335 AudioAdapterStreamType::STREAM_VOICE_CALL,
336 AudioAdapterStreamType::STREAM_MUSIC,
337 AudioAdapterStreamType::STREAM_RING,
338 AudioAdapterStreamType::STREAM_MEDIA,
339 AudioAdapterStreamType::STREAM_VOICE_ASSISTANT,
340 AudioAdapterStreamType::STREAM_SYSTEM,
341 AudioAdapterStreamType::STREAM_ALARM,
342 AudioAdapterStreamType::STREAM_NOTIFICATION,
343 AudioAdapterStreamType::STREAM_BLUETOOTH_SCO,
344 AudioAdapterStreamType::STREAM_ENFORCED_AUDIBLE,
345 AudioAdapterStreamType::STREAM_DTMF,
346 AudioAdapterStreamType::STREAM_TTS,
347 AudioAdapterStreamType::STREAM_ACCESSIBILITY,
348 AudioAdapterStreamType::STREAM_RECORDING,
349 AudioAdapterStreamType::STREAM_ALL,
350 };
351
352 for (auto& stream : streamArray)
353 AudioSystemManagerAdapterImpl::GetInstance().GetStreamType(stream);
354 AudioStreamType testStream = AudioSystemManagerAdapterImpl::GetInstance().GetStreamType(
355 static_cast<AudioAdapterStreamType>(-2));
356 EXPECT_EQ(testStream, AudioStreamType::STREAM_DEFAULT);
357 }
358
359 /**
360 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_012.
361 * @tc.desc: Audio adapter unittest.
362 * @tc.type: FUNC.
363 * @tc.require:I5HRX9
364 */
365 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_012, TestSize.Level1)
366 {
367 auto callback = std::make_shared<AudioCallbackTest>();
368 auto callbackTest = std::make_shared<AudioManagerCallbackAdapterImpl>(callback);
369 ASSERT_NE(callbackTest, nullptr);
370
371 InterruptAction interruptAction;
372
373 interruptAction.interruptHint = InterruptHint::INTERRUPT_HINT_PAUSE;
374 callbackTest->OnInterrupt(interruptAction);
375
376 interruptAction.interruptHint = InterruptHint::INTERRUPT_HINT_STOP;
377 callbackTest->OnInterrupt(interruptAction);
378
379 interruptAction.interruptHint = InterruptHint::INTERRUPT_HINT_RESUME;
380 callbackTest->OnInterrupt(interruptAction);
381
382 interruptAction.interruptHint = static_cast<InterruptHint>(-1);
383 callbackTest->OnInterrupt(interruptAction);
384 }
385
386 /**
387 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_013.
388 * @tc.desc: Audio adapter unittest.
389 * @tc.type: FUNC.
390 * @tc.require:I5HRX9
391 */
392 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_013, TestSize.Level1)
393 {
394 g_audioRender = std::make_shared<AudioRendererAdapterImpl>();
395 ASSERT_NE(g_audioRender, nullptr);
396
397 AudioAdapterRendererOptions rendererOptions;
398 rendererOptions.samplingRate = AudioAdapterSamplingRate::SAMPLE_RATE_44100;
399 rendererOptions.encoding = AudioAdapterEncodingType::ENCODING_PCM;
400 rendererOptions.format = AudioAdapterSampleFormat::SAMPLE_S16LE;
401 rendererOptions.channels = AudioAdapterChannel::STEREO;
402 rendererOptions.contentType = AudioAdapterContentType::CONTENT_TYPE_MUSIC;
403 rendererOptions.streamUsage = AudioAdapterStreamUsage::STREAM_USAGE_MEDIA;
404 rendererOptions.rendererFlags = 0;
405 int32_t retNum = g_audioRender->Create(rendererOptions);
406 ASSERT_NE(retNum, AudioAdapterCode::AUDIO_OK);
407
408 bool ret = g_audioRender->Start();
409 EXPECT_NE(ret, TRUE_OK);
410
411 std::array<uint8_t, 4> bufferArray = {0, 0, 0, 0};
412 retNum = g_audioRender->Write(bufferArray.data(), bufferArray.size());
413 EXPECT_NE(retNum, bufferArray.size());
414
415 uint64_t latency;
416 retNum = g_audioRender->GetLatency(latency);
417 EXPECT_NE(retNum, RESULT_OK);
418
419 float volume = 0.8;
420 retNum = g_audioRender->SetVolume(volume);
421 EXPECT_NE(retNum, RESULT_OK);
422
423 float nowVolume = g_audioRender->GetVolume();
424 EXPECT_NE(nowVolume, volume);
425
426 BufferDescAdapter bufDesc;
427 retNum = g_audioRender->GetBufferDesc(bufDesc);
428 EXPECT_NE(retNum, AudioAdapterCode::AUDIO_OK);
429 retNum = g_audioRender->Enqueue(bufDesc);
430 EXPECT_NE(retNum, AudioAdapterCode::AUDIO_OK);
431 auto writeCallback = std::make_shared<AudioRendererWriteCallbackAdapterMock>();
432 EXPECT_NE(writeCallback, nullptr);
433 retNum = g_audioRender->SetAudioRendererWriteCallbackAdapter(writeCallback);
434 EXPECT_NE(retNum, AudioAdapterCode::AUDIO_OK);
435
436 ret = g_audioRender->Stop();
437 EXPECT_NE(ret, TRUE_OK);
438
439 ret = g_audioRender->Release();
440 EXPECT_NE(ret, TRUE_OK);
441 }
442
443 /**
444 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_014.
445 * @tc.desc: Audio adapter unittest.
446 * @tc.type: FUNC
447 * @tc.require:I5RWOG
448 */
449 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_014, TestSize.Level1)
450 {
451 ApplicationContextMock *contextMock = new ApplicationContextMock();
452 EXPECT_NE(contextMock, nullptr);
453 EXPECT_CALL(*contextMock, GetCacheDir())
454 .Times(1)
455 .WillRepeatedly(::testing::Return(""));
456 EXPECT_EQ(g_applicationContext, nullptr);
457 g_applicationContext.reset(contextMock);
458 EXPECT_NE(g_applicationContext, nullptr);
459
460 std::shared_ptr<AudioRendererAdapterImpl> audioRenderImpl = std::make_shared<AudioRendererAdapterImpl>();
461 EXPECT_NE(audioRenderImpl, nullptr);
462
463 AudioAdapterRendererOptions rendererOptions;
464 rendererOptions.samplingRate = AudioAdapterSamplingRate::SAMPLE_RATE_44100;
465 rendererOptions.encoding = AudioAdapterEncodingType::ENCODING_PCM;
466 rendererOptions.format = AudioAdapterSampleFormat::SAMPLE_S16LE;
467 rendererOptions.channels = AudioAdapterChannel::STEREO;
468 rendererOptions.contentType = AudioAdapterContentType::CONTENT_TYPE_MUSIC;
469 rendererOptions.streamUsage = AudioAdapterStreamUsage::STREAM_USAGE_MEDIA;
470 rendererOptions.rendererFlags = 0;
471 int32_t retNum = audioRenderImpl->Create(rendererOptions);
472 g_applicationContext.reset();
473 EXPECT_EQ(g_applicationContext, nullptr);
474 EXPECT_EQ(retNum, AudioAdapterCode::AUDIO_ERROR);
475 }
476
477 /**
478 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_015.
479 * @tc.desc: Audio adapter unittest.
480 * @tc.type: FUNC
481 * @tc.require:I5HRX9
482 */
483 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_015, TestSize.Level1)
484 {
485 ApplicationContextMock *contextMock = new ApplicationContextMock();
486 EXPECT_NE(contextMock, nullptr);
487 EXPECT_CALL(*contextMock, GetCacheDir())
488 .Times(1)
489 .WillRepeatedly(::testing::Return(CACHE_PATH));
490 EXPECT_EQ(g_applicationContext, nullptr);
491 g_applicationContext.reset(contextMock);
492 EXPECT_NE(g_applicationContext, nullptr);
493
494 std::shared_ptr<AudioRendererAdapterImpl> audioRenderImpl = std::make_shared<AudioRendererAdapterImpl>();
495 EXPECT_NE(audioRenderImpl, nullptr);
496
497 AudioAdapterRendererOptions rendererOptions;
498 rendererOptions.samplingRate = AudioAdapterSamplingRate::SAMPLE_RATE_44100;
499 rendererOptions.encoding = AudioAdapterEncodingType::ENCODING_PCM;
500 rendererOptions.format = AudioAdapterSampleFormat::SAMPLE_S16LE;
501 rendererOptions.channels = AudioAdapterChannel::STEREO;
502 rendererOptions.contentType = AudioAdapterContentType::CONTENT_TYPE_MUSIC;
503 rendererOptions.streamUsage = AudioAdapterStreamUsage::STREAM_USAGE_MEDIA;
504 rendererOptions.rendererFlags = 0;
505 int32_t retNum = audioRenderImpl->Create(rendererOptions);
506 g_applicationContext.reset();
507 EXPECT_EQ(g_applicationContext, nullptr);
508 EXPECT_EQ(retNum, AudioAdapterCode::AUDIO_OK);
509 }
510
511 /**
512 * @tc.name: NWebAudioAdapterTest_GetBufferDesc_016.
513 * @tc.desc: Audio adapter unittest.
514 * @tc.type: FUNC
515 * @tc.require:I5HRX9
516 */
517 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_GetBufferDesc_016, TestSize.Level1)
518 {
519 std::shared_ptr<AudioRendererAdapterImpl> audioRenderImpl = std::make_shared<AudioRendererAdapterImpl>();
520 EXPECT_NE(audioRenderImpl, nullptr);
521
522 AudioAdapterRendererOptions rendererOptions;
523 rendererOptions.samplingRate = AudioAdapterSamplingRate::SAMPLE_RATE_44100;
524 rendererOptions.encoding = AudioAdapterEncodingType::ENCODING_PCM;
525 rendererOptions.format = AudioAdapterSampleFormat::SAMPLE_S16LE;
526 rendererOptions.channels = AudioAdapterChannel::STEREO;
527 rendererOptions.contentType = AudioAdapterContentType::CONTENT_TYPE_MUSIC;
528 rendererOptions.streamUsage = AudioAdapterStreamUsage::STREAM_USAGE_MEDIA;
529 rendererOptions.rendererFlags = 0;
530 int32_t retNum = audioRenderImpl->Create(rendererOptions, CACHE_PATH);
531 EXPECT_EQ(retNum, AudioAdapterCode::AUDIO_OK);
532
533 auto writeCallback = std::make_shared<AudioRendererWriteCallbackAdapterMock>();
534 EXPECT_NE(writeCallback, nullptr);
535 retNum = audioRenderImpl->SetAudioRendererWriteCallbackAdapter(nullptr);
536 EXPECT_NE(retNum, AudioAdapterCode::AUDIO_OK);
537 retNum = audioRenderImpl->SetAudioRendererWriteCallbackAdapter(writeCallback);
538 EXPECT_EQ(retNum, AudioAdapterCode::AUDIO_OK);
539 BufferDescAdapter bufDesc;
540 retNum = audioRenderImpl->GetBufferDesc(bufDesc);
541 EXPECT_EQ(retNum, AudioAdapterCode::AUDIO_OK);
542 retNum = audioRenderImpl->Enqueue(bufDesc);
543 EXPECT_EQ(retNum, AudioAdapterCode::AUDIO_OK);
544
545 AudioRendererWriteCallbackImpl writeCallbackImplNull(nullptr);
546 writeCallbackImplNull.OnWriteData(0);
547 AudioRendererWriteCallbackImpl writeCallbackImpl(writeCallback);
548 writeCallbackImpl.OnWriteData(0);
549 }
550 } // namespace OHOS::NWeb
551 } // namespace OHOS