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 <gmock/gmock.h>
18 #include <gtest/gtest.h>
19 #include <string>
20
21 #define private public
22 #include "accesstoken_kit.h"
23 #include "audio_capturer_adapter.h"
24 #include "audio_capturer_adapter_impl.h"
25 #include "audio_renderer_adapter.h"
26 #include "audio_renderer_adapter_impl.h"
27 #include "audio_system_manager_adapter_impl.h"
28 #include "foundation/ability/ability_runtime/interfaces/kits/native/appkit/ability_runtime/context/application_context.h"
29 #include "nativetoken_kit.h"
30 #include "token_setproc.h"
31
32 using namespace testing;
33 using namespace testing::ext;
34 using namespace OHOS::AbilityRuntime;
35
36 namespace OHOS {
37 namespace {
38 const int RESULT_OK = 0;
39 const bool TRUE_OK = true;
40 const std::string CACHE_PATH = "/data/local/tmp";
41 std::shared_ptr<NWeb::AudioRendererAdapterImpl> g_audioRender = nullptr;
42 std::shared_ptr<NWeb::AudioCapturerAdapterImpl> g_audioCapturer = nullptr;
43 std::shared_ptr<AbilityRuntime::ApplicationContext> g_applicationContext = nullptr;
44 } // namespace
45
46 namespace AbilityRuntime {
GetApplicationContext()47 std::shared_ptr<ApplicationContext> Context::GetApplicationContext()
48 {
49 return g_applicationContext;
50 }
51 } // namespace AbilityRuntime
52
53 namespace NWeb {
54 class NWebAudioAdapterTest : public testing::Test {
55 public:
56 static void SetUpTestCase(void);
57 static void TearDownTestCase(void);
58 void SetUp();
59 void TearDown();
60 };
61
62 class ApplicationContextMock : public ApplicationContext {
63 public:
64 MOCK_METHOD0(GetCacheDir, std::string());
65 };
66
67 class AudioCallbackTest : public AudioManagerCallbackAdapter {
68 public:
69 AudioCallbackTest() = default;
70
71 virtual ~AudioCallbackTest() = default;
72
OnSuspend()73 void OnSuspend() override {};
74
OnResume()75 void OnResume() override {};
76 };
77
78 class AudioRendererCallbackMock : public AudioRendererCallbackAdapter {
79 public:
80 AudioRendererCallbackMock() = default;
81
82 virtual ~AudioRendererCallbackMock() = default;
83
OnSuspend()84 void OnSuspend() override {};
85
OnResume()86 void OnResume() override {};
87 };
88
89 class AudioCapturerCallbackMock : public AudioCapturerReadCallbackAdapter {
90 public:
91 AudioCapturerCallbackMock() = default;
92
93 virtual ~AudioCapturerCallbackMock() = default;
94
OnReadData(size_t length)95 void OnReadData(size_t length) override {};
96 };
97
SetUpTestCase(void)98 void NWebAudioAdapterTest::SetUpTestCase(void)
99 {
100 uint64_t tokenId;
101 const char* perms[1];
102 perms[0] = "ohos.permission.MICROPHONE";
103 NativeTokenInfoParams infoInstance = {
104 .dcapsNum = 0,
105 .permsNum = 1,
106 .aclsNum = 0,
107 .dcaps = NULL,
108 .perms = perms,
109 .acls = NULL,
110 .processName = "web_audio_tdd",
111 .aplStr = "system_basic",
112 };
113 tokenId = GetAccessTokenId(&infoInstance);
114 SetSelfTokenID(tokenId);
115 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
116 }
117
TearDownTestCase(void)118 void NWebAudioAdapterTest::TearDownTestCase(void) {}
119
SetUp(void)120 void NWebAudioAdapterTest::SetUp(void) {}
121
TearDown(void)122 void NWebAudioAdapterTest::TearDown(void) {}
123
124 /**
125 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_001.
126 * @tc.desc: Audio adapter unittest.
127 * @tc.type: FUNC.
128 * @tc.require:I5HRX9
129 */
130 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_001, TestSize.Level1)
131 {
132 g_audioRender = std::make_shared<AudioRendererAdapterImpl>();
133 ASSERT_NE(g_audioRender, nullptr);
134 AudioAdapterRendererOptions rendererOptions;
135 rendererOptions.samplingRate = AudioAdapterSamplingRate::SAMPLE_RATE_44100;
136 rendererOptions.encoding = AudioAdapterEncodingType::ENCODING_PCM;
137 rendererOptions.format = AudioAdapterSampleFormat::SAMPLE_S16LE;
138 rendererOptions.channels = AudioAdapterChannel::STEREO;
139 rendererOptions.contentType = AudioAdapterContentType::CONTENT_TYPE_MUSIC;
140 rendererOptions.streamUsage = AudioAdapterStreamUsage::STREAM_USAGE_MEDIA;
141 rendererOptions.rendererFlags = 0;
142 int32_t retNum = g_audioRender->Create(rendererOptions, CACHE_PATH);
143 ASSERT_EQ(retNum, AudioAdapterCode::AUDIO_OK);
144
145 bool ret = g_audioRender->Start();
146 EXPECT_EQ(ret, TRUE_OK);
147
148 std::array<uint8_t, 4> bufferArray = { 0, 0, 0, 0 };
149 retNum = g_audioRender->Write(bufferArray.data(), bufferArray.size());
150 EXPECT_EQ(retNum, bufferArray.size());
151
152 uint64_t latency;
153 retNum = g_audioRender->GetLatency(latency);
154 EXPECT_EQ(retNum, RESULT_OK);
155
156 float volume = 0.8;
157 retNum = g_audioRender->SetVolume(volume);
158 EXPECT_EQ(retNum, RESULT_OK);
159
160 float nowVolume = g_audioRender->GetVolume();
161 EXPECT_EQ(nowVolume, volume);
162 retNum = g_audioRender->SetAudioRendererCallback(nullptr);
163 EXPECT_NE(retNum, 0);
164 std::shared_ptr<AudioRendererCallbackAdapter> callback = std::make_shared<AudioRendererCallbackMock>();
165 EXPECT_NE(callback, nullptr);
166 retNum = g_audioRender->SetAudioRendererCallback(callback);
167 EXPECT_EQ(retNum, 0);
168 g_audioRender->SetInterruptMode(true);
169 g_audioRender->SetInterruptMode(false);
170 ret = g_audioRender->IsRendererStateRunning();
171 EXPECT_EQ(ret, TRUE_OK);
172 ret = g_audioRender->Pause();
173 EXPECT_EQ(ret, TRUE_OK);
174 ret = g_audioRender->Stop();
175 EXPECT_EQ(ret, TRUE_OK);
176 ret = g_audioRender->Release();
177 EXPECT_EQ(ret, TRUE_OK);
178 }
179
180 /**
181 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_002.
182 * @tc.desc: Audio adapter unittest.
183 * @tc.type: FUNC.
184 * @tc.require:I5HRX9
185 */
186 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_002, TestSize.Level1)
187 {
188 std::array<AudioAdapterSamplingRate, 11> samplingArray = {
189 AudioAdapterSamplingRate::SAMPLE_RATE_8000,
190 AudioAdapterSamplingRate::SAMPLE_RATE_11025,
191 AudioAdapterSamplingRate::SAMPLE_RATE_12000,
192 AudioAdapterSamplingRate::SAMPLE_RATE_16000,
193 AudioAdapterSamplingRate::SAMPLE_RATE_22050,
194 AudioAdapterSamplingRate::SAMPLE_RATE_24000,
195 AudioAdapterSamplingRate::SAMPLE_RATE_32000,
196 AudioAdapterSamplingRate::SAMPLE_RATE_44100,
197 AudioAdapterSamplingRate::SAMPLE_RATE_48000,
198 AudioAdapterSamplingRate::SAMPLE_RATE_64000,
199 AudioAdapterSamplingRate::SAMPLE_RATE_96000,
200 };
201 for (auto& sampling : samplingArray)
202 AudioRendererAdapterImpl::GetAudioSamplingRate(sampling);
203
204 AudioSamplingRate testSampling =
205 AudioRendererAdapterImpl::GetAudioSamplingRate(static_cast<AudioAdapterSamplingRate>(0));
206 EXPECT_EQ(testSampling, AudioSamplingRate::SAMPLE_RATE_44100);
207 }
208
209 /**
210 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_003.
211 * @tc.desc: Audio adapter unittest.
212 * @tc.type: FUNC.
213 * @tc.require:I5HRX9
214 */
215 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_003, TestSize.Level1)
216 {
217 AudioRendererAdapterImpl::GetAudioEncodingType(AudioAdapterEncodingType::ENCODING_PCM);
218 AudioRendererAdapterImpl::GetAudioEncodingType(AudioAdapterEncodingType::ENCODING_INVALID);
219
220 AudioEncodingType testEncodingType =
221 AudioRendererAdapterImpl::GetAudioEncodingType(static_cast<AudioAdapterEncodingType>(1));
222 EXPECT_EQ(testEncodingType, AudioEncodingType::ENCODING_INVALID);
223 }
224
225 /**
226 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_004.
227 * @tc.desc: Audio adapter unittest.
228 * @tc.type: FUNC.
229 * @tc.require:I5HRX9
230 */
231 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_004, TestSize.Level1)
232 {
233 std::array<AudioAdapterSampleFormat, 6> formatArray = {
234 AudioAdapterSampleFormat::SAMPLE_U8,
235 AudioAdapterSampleFormat::SAMPLE_S16LE,
236 AudioAdapterSampleFormat::SAMPLE_S24LE,
237 AudioAdapterSampleFormat::SAMPLE_S32LE,
238 AudioAdapterSampleFormat::SAMPLE_F32LE,
239 AudioAdapterSampleFormat::INVALID_WIDTH,
240 };
241 for (auto& format : formatArray)
242 AudioRendererAdapterImpl::GetAudioSampleFormat(format);
243
244 AudioSampleFormat testFormat =
245 AudioRendererAdapterImpl::GetAudioSampleFormat(static_cast<AudioAdapterSampleFormat>(-2));
246 EXPECT_EQ(testFormat, AudioSampleFormat::INVALID_WIDTH);
247 }
248
249 /**
250 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_005.
251 * @tc.desc: Audio adapter unittest.
252 * @tc.type: FUNC.
253 * @tc.require:I5HRX9
254 */
255 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_005, TestSize.Level1)
256 {
257 std::array<AudioAdapterChannel, 8> channelArray = {
258 AudioAdapterChannel::MONO,
259 AudioAdapterChannel::STEREO,
260 AudioAdapterChannel::CHANNEL_3,
261 AudioAdapterChannel::CHANNEL_4,
262 AudioAdapterChannel::CHANNEL_5,
263 AudioAdapterChannel::CHANNEL_6,
264 AudioAdapterChannel::CHANNEL_7,
265 AudioAdapterChannel::CHANNEL_8,
266 };
267 for (auto& channel : channelArray)
268 AudioRendererAdapterImpl::GetAudioChannel(channel);
269
270 AudioChannel testChannel = AudioRendererAdapterImpl::GetAudioChannel(static_cast<AudioAdapterChannel>(0));
271 EXPECT_EQ(testChannel, AudioChannel::STEREO);
272 }
273
274 /**
275 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_006.
276 * @tc.desc: Audio adapter unittest.
277 * @tc.type: FUNC.
278 * @tc.require:I5HRX9
279 */
280 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_006, TestSize.Level1)
281 {
282 std::array<AudioAdapterContentType, 6> contentArray = {
283 AudioAdapterContentType::CONTENT_TYPE_UNKNOWN,
284 AudioAdapterContentType::CONTENT_TYPE_SPEECH,
285 AudioAdapterContentType::CONTENT_TYPE_MUSIC,
286 AudioAdapterContentType::CONTENT_TYPE_MOVIE,
287 AudioAdapterContentType::CONTENT_TYPE_SONIFICATION,
288 AudioAdapterContentType::CONTENT_TYPE_RINGTONE,
289 };
290 for (auto& content : contentArray)
291 AudioRendererAdapterImpl::GetAudioContentType(content);
292
293 ContentType testContent = AudioRendererAdapterImpl::GetAudioContentType(static_cast<AudioAdapterContentType>(-1));
294 EXPECT_EQ(testContent, ContentType::CONTENT_TYPE_MUSIC);
295 }
296
297 /**
298 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_007.
299 * @tc.desc: Audio adapter unittest.
300 * @tc.type: FUNC.
301 * @tc.require:I5HRX9
302 */
303 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_007, TestSize.Level1)
304 {
305 std::array<AudioAdapterStreamUsage, 5> usageArray = {
306 AudioAdapterStreamUsage::STREAM_USAGE_UNKNOWN,
307 AudioAdapterStreamUsage::STREAM_USAGE_MEDIA,
308 AudioAdapterStreamUsage::STREAM_USAGE_VOICE_COMMUNICATION,
309 AudioAdapterStreamUsage::STREAM_USAGE_VOICE_ASSISTANT,
310 AudioAdapterStreamUsage::STREAM_USAGE_NOTIFICATION_RINGTONE,
311 };
312 for (auto& usage : usageArray)
313 AudioRendererAdapterImpl::GetAudioStreamUsage(usage);
314
315 StreamUsage testUsage = AudioRendererAdapterImpl::GetAudioStreamUsage(static_cast<AudioAdapterStreamUsage>(-1));
316 EXPECT_EQ(testUsage, StreamUsage::STREAM_USAGE_MEDIA);
317 }
318
319 /**
320 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_008.
321 * @tc.desc: Audio adapter unittest.
322 * @tc.type: FUNC.
323 * @tc.require:I5HRX9
324 */
325 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_008, TestSize.Level1)
326 {
327 bool ret = AudioSystemManagerAdapterImpl::GetInstance().HasAudioOutputDevices();
328 EXPECT_EQ(ret, TRUE_OK);
329
330 ret = AudioSystemManagerAdapterImpl::GetInstance().HasAudioInputDevices();
331 EXPECT_EQ(ret, TRUE_OK);
332 }
333
334 /**
335 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_009.
336 * @tc.desc: Audio adapter unittest.
337 * @tc.type: FUNC.
338 * @tc.require:I5HRX9
339 */
340 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_009, TestSize.Level1)
341 {
342 AudioAdapterInterrupt interrupt;
343 interrupt.streamUsage = AudioAdapterStreamUsage::STREAM_USAGE_MEDIA;
344 interrupt.contentType = AudioAdapterContentType::CONTENT_TYPE_MUSIC;
345 interrupt.streamType = AudioAdapterStreamType::STREAM_DEFAULT;
346
347 int32_t ret = AudioSystemManagerAdapterImpl::GetInstance().RequestAudioFocus(interrupt);
348 EXPECT_NE(ret, RESULT_OK);
349 ret = AudioSystemManagerAdapterImpl::GetInstance().AbandonAudioFocus(interrupt);
350 EXPECT_NE(ret, RESULT_OK);
351
352 interrupt.streamType = AudioAdapterStreamType::STREAM_MUSIC;
353 ret = AudioSystemManagerAdapterImpl::GetInstance().RequestAudioFocus(interrupt);
354 EXPECT_EQ(ret, RESULT_OK);
355
356 ret = AudioSystemManagerAdapterImpl::GetInstance().AbandonAudioFocus(interrupt);
357 EXPECT_EQ(ret, RESULT_OK);
358 }
359
360 /**
361 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_010.
362 * @tc.desc: Audio adapter unittest.
363 * @tc.type: FUNC.
364 * @tc.require:I5HRX9
365 */
366 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_010, TestSize.Level1)
367 {
368 auto callback = std::make_shared<AudioCallbackTest>();
369 int32_t ret = AudioSystemManagerAdapterImpl::GetInstance().SetAudioManagerInterruptCallback(nullptr);
370 EXPECT_NE(ret, RESULT_OK);
371
372 ret = AudioSystemManagerAdapterImpl::GetInstance().SetAudioManagerInterruptCallback(callback);
373 EXPECT_EQ(ret, RESULT_OK);
374
375 ret = AudioSystemManagerAdapterImpl::GetInstance().UnsetAudioManagerInterruptCallback();
376 EXPECT_EQ(ret, RESULT_OK);
377
378 AudioSystemManagerAdapterImpl::GetInstance().GetDevices(AdapterDeviceFlag::OUTPUT_DEVICES_FLAG);
379 AudioSystemManagerAdapterImpl::GetInstance().GetDevices(static_cast<AdapterDeviceFlag>(-1));
380
381 AudioAdapterDeviceDesc desc;
382 desc.deviceId = -1;
383 desc.deviceName = std::string();
384 ret = AudioSystemManagerAdapterImpl::GetInstance().SelectAudioDevice(desc, true);
385 EXPECT_NE(ret, RESULT_OK);
386 ret = AudioSystemManagerAdapterImpl::GetInstance().SelectAudioDevice(desc, false);
387 EXPECT_NE(ret, RESULT_OK);
388 }
389
390 /**
391 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_011.
392 * @tc.desc: Audio adapter unittest.
393 * @tc.type: FUNC.
394 * @tc.require:I5HRX9
395 */
396 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_011, TestSize.Level1)
397 {
398 std::array<AudioAdapterStreamType, 16> streamArray = {
399 AudioAdapterStreamType::STREAM_DEFAULT,
400 AudioAdapterStreamType::STREAM_VOICE_CALL,
401 AudioAdapterStreamType::STREAM_MUSIC,
402 AudioAdapterStreamType::STREAM_RING,
403 AudioAdapterStreamType::STREAM_MEDIA,
404 AudioAdapterStreamType::STREAM_VOICE_ASSISTANT,
405 AudioAdapterStreamType::STREAM_SYSTEM,
406 AudioAdapterStreamType::STREAM_ALARM,
407 AudioAdapterStreamType::STREAM_NOTIFICATION,
408 AudioAdapterStreamType::STREAM_BLUETOOTH_SCO,
409 AudioAdapterStreamType::STREAM_ENFORCED_AUDIBLE,
410 AudioAdapterStreamType::STREAM_DTMF,
411 AudioAdapterStreamType::STREAM_TTS,
412 AudioAdapterStreamType::STREAM_ACCESSIBILITY,
413 AudioAdapterStreamType::STREAM_RECORDING,
414 AudioAdapterStreamType::STREAM_ALL,
415 };
416
417 for (auto& stream : streamArray)
418 AudioSystemManagerAdapterImpl::GetInstance().GetStreamType(stream);
419 AudioStreamType testStream =
420 AudioSystemManagerAdapterImpl::GetInstance().GetStreamType(static_cast<AudioAdapterStreamType>(-2));
421 EXPECT_EQ(testStream, AudioStreamType::STREAM_DEFAULT);
422 }
423
424 /**
425 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_012.
426 * @tc.desc: Audio adapter unittest.
427 * @tc.type: FUNC.
428 * @tc.require:I5HRX9
429 */
430 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_012, TestSize.Level1)
431 {
432 auto callback = std::make_shared<AudioCallbackTest>();
433 auto callbackTest = std::make_shared<AudioManagerCallbackAdapterImpl>(callback);
434 ASSERT_NE(callbackTest, nullptr);
435
436 InterruptAction interruptAction;
437
438 interruptAction.interruptHint = InterruptHint::INTERRUPT_HINT_PAUSE;
439 callbackTest->OnInterrupt(interruptAction);
440
441 interruptAction.interruptHint = InterruptHint::INTERRUPT_HINT_STOP;
442 callbackTest->OnInterrupt(interruptAction);
443
444 interruptAction.interruptHint = InterruptHint::INTERRUPT_HINT_RESUME;
445 callbackTest->OnInterrupt(interruptAction);
446
447 interruptAction.interruptHint = static_cast<InterruptHint>(-1);
448 callbackTest->OnInterrupt(interruptAction);
449 callbackTest->cb_ = nullptr;
450 callbackTest->OnInterrupt(interruptAction);
451 }
452
453 /**
454 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_013.
455 * @tc.desc: Audio adapter unittest.
456 * @tc.type: FUNC.
457 * @tc.require:I5HRX9
458 */
459 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_013, TestSize.Level1)
460 {
461 g_audioRender = std::make_shared<AudioRendererAdapterImpl>();
462 ASSERT_NE(g_audioRender, nullptr);
463
464 AudioAdapterRendererOptions rendererOptions;
465 rendererOptions.samplingRate = AudioAdapterSamplingRate::SAMPLE_RATE_44100;
466 rendererOptions.encoding = AudioAdapterEncodingType::ENCODING_PCM;
467 rendererOptions.format = AudioAdapterSampleFormat::SAMPLE_S16LE;
468 rendererOptions.channels = AudioAdapterChannel::STEREO;
469 rendererOptions.contentType = AudioAdapterContentType::CONTENT_TYPE_MUSIC;
470 rendererOptions.streamUsage = AudioAdapterStreamUsage::STREAM_USAGE_MEDIA;
471 rendererOptions.rendererFlags = 0;
472 int32_t retNum = g_audioRender->Create(rendererOptions);
473 ASSERT_NE(retNum, AudioAdapterCode::AUDIO_OK);
474
475 bool ret = g_audioRender->Start();
476 EXPECT_NE(ret, TRUE_OK);
477
478 std::array<uint8_t, 4> bufferArray = { 0, 0, 0, 0 };
479 retNum = g_audioRender->Write(bufferArray.data(), bufferArray.size());
480 EXPECT_NE(retNum, bufferArray.size());
481
482 uint64_t latency;
483 retNum = g_audioRender->GetLatency(latency);
484 EXPECT_NE(retNum, RESULT_OK);
485
486 float volume = 0.8;
487 retNum = g_audioRender->SetVolume(volume);
488 EXPECT_NE(retNum, RESULT_OK);
489
490 float nowVolume = g_audioRender->GetVolume();
491 EXPECT_NE(nowVolume, volume);
492
493 ret = g_audioRender->Pause();
494 EXPECT_NE(ret, TRUE_OK);
495
496 ret = g_audioRender->Stop();
497 EXPECT_NE(ret, TRUE_OK);
498
499 ret = g_audioRender->Release();
500 EXPECT_NE(ret, TRUE_OK);
501 }
502
503 /**
504 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_014.
505 * @tc.desc: Audio adapter unittest.
506 * @tc.type: FUNC
507 * @tc.require:I5RWOG
508 */
509 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_014, TestSize.Level1)
510 {
511 ApplicationContextMock* contextMock = new ApplicationContextMock();
512 EXPECT_NE(contextMock, nullptr);
513 EXPECT_CALL(*contextMock, GetCacheDir()).Times(1).WillRepeatedly(::testing::Return(""));
514 EXPECT_EQ(g_applicationContext, nullptr);
515 g_applicationContext.reset(contextMock);
516 EXPECT_NE(g_applicationContext, nullptr);
517
518 std::shared_ptr<AudioRendererAdapterImpl> audioRenderImpl = std::make_shared<AudioRendererAdapterImpl>();
519 EXPECT_NE(audioRenderImpl, nullptr);
520
521 AudioAdapterRendererOptions rendererOptions;
522 rendererOptions.samplingRate = AudioAdapterSamplingRate::SAMPLE_RATE_44100;
523 rendererOptions.encoding = AudioAdapterEncodingType::ENCODING_PCM;
524 rendererOptions.format = AudioAdapterSampleFormat::SAMPLE_S16LE;
525 rendererOptions.channels = AudioAdapterChannel::STEREO;
526 rendererOptions.contentType = AudioAdapterContentType::CONTENT_TYPE_MUSIC;
527 rendererOptions.streamUsage = AudioAdapterStreamUsage::STREAM_USAGE_MEDIA;
528 rendererOptions.rendererFlags = 0;
529 int32_t retNum = audioRenderImpl->Create(rendererOptions);
530 g_applicationContext.reset();
531 EXPECT_EQ(g_applicationContext, nullptr);
532 EXPECT_EQ(retNum, AudioAdapterCode::AUDIO_ERROR);
533 EXPECT_EQ(audioRenderImpl->audio_renderer_, nullptr);
534 audioRenderImpl->SetInterruptMode(false);
535 }
536
537 /**
538 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_015.
539 * @tc.desc: Audio adapter unittest.
540 * @tc.type: FUNC
541 * @tc.require:I5HRX9
542 */
543 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_015, TestSize.Level1)
544 {
545 ApplicationContextMock* contextMock = new ApplicationContextMock();
546 EXPECT_NE(contextMock, nullptr);
547 EXPECT_CALL(*contextMock, GetCacheDir()).Times(1).WillRepeatedly(::testing::Return(CACHE_PATH));
548 EXPECT_EQ(g_applicationContext, nullptr);
549 g_applicationContext.reset(contextMock);
550 EXPECT_NE(g_applicationContext, nullptr);
551
552 std::shared_ptr<AudioRendererAdapterImpl> audioRenderImpl = std::make_shared<AudioRendererAdapterImpl>();
553 EXPECT_NE(audioRenderImpl, nullptr);
554
555 AudioAdapterRendererOptions rendererOptions;
556 rendererOptions.samplingRate = AudioAdapterSamplingRate::SAMPLE_RATE_44100;
557 rendererOptions.encoding = AudioAdapterEncodingType::ENCODING_PCM;
558 rendererOptions.format = AudioAdapterSampleFormat::SAMPLE_S16LE;
559 rendererOptions.channels = AudioAdapterChannel::STEREO;
560 rendererOptions.contentType = AudioAdapterContentType::CONTENT_TYPE_MUSIC;
561 rendererOptions.streamUsage = AudioAdapterStreamUsage::STREAM_USAGE_MEDIA;
562 rendererOptions.rendererFlags = 0;
563 int32_t retNum = audioRenderImpl->Create(rendererOptions);
564 g_applicationContext.reset();
565 EXPECT_EQ(g_applicationContext, nullptr);
566 EXPECT_EQ(retNum, AudioAdapterCode::AUDIO_OK);
567 }
568
569 /**
570 * @tc.name: NWebAudioAdapterTest_OnInterrupt_016.
571 * @tc.desc: Audio adapter unittest.
572 * @tc.type: FUNC
573 * @tc.require:I5HRX9
574 */
575 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_OnInterrupt_016, TestSize.Level1)
576 {
577 std::shared_ptr<AudioRendererCallbackAdapter> cb = std::make_shared<AudioRendererCallbackMock>();
578 EXPECT_NE(cb, nullptr);
579 auto callBack = std::make_shared<AudioRendererCallbackImpl>(cb);
580 EXPECT_NE(callBack, nullptr);
581 InterruptEvent interruptEvent;
582 interruptEvent.hintType = OHOS::AudioStandard::InterruptHint::INTERRUPT_HINT_PAUSE;
583 callBack->OnInterrupt(interruptEvent);
584 interruptEvent.hintType = OHOS::AudioStandard::InterruptHint::INTERRUPT_HINT_STOP;
585 callBack->OnInterrupt(interruptEvent);
586 interruptEvent.hintType = OHOS::AudioStandard::InterruptHint::INTERRUPT_HINT_RESUME;
587 callBack->OnInterrupt(interruptEvent);
588 interruptEvent.hintType = OHOS::AudioStandard::InterruptHint::INTERRUPT_HINT_NONE;
589 callBack->OnInterrupt(interruptEvent);
590 callBack->OnStateChange(RendererState::RENDERER_PAUSED, StateChangeCmdType::CMD_FROM_SYSTEM);
591 callBack->cb_ = nullptr;
592 callBack->OnInterrupt(interruptEvent);
593 }
594
595 /**
596 * @tc.name: NWebAudioAdapterTest_SetAudioRendererCallback_017.
597 * @tc.desc: Audio adapter unittest.
598 * @tc.type: FUNC
599 * @tc.require:I5HRX9
600 */
601 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_SetAudioRendererCallback_017, TestSize.Level1)
602 {
603 auto audioRender = std::make_shared<AudioRendererAdapterImpl>();
604 ASSERT_NE(audioRender, nullptr);
605 std::shared_ptr<AudioRendererCallbackAdapter> callback = std::make_shared<AudioRendererCallbackMock>();
606 ASSERT_NE(callback, nullptr);
607 int32_t retNum = audioRender->SetAudioRendererCallback(callback);
608 EXPECT_NE(retNum, 0);
609 }
610
611 /**
612 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_018.
613 * @tc.desc: Audio adapter unittest.
614 * @tc.type: FUNC.
615 * @tc.require:AR000I7I7N
616 */
617 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_018, TestSize.Level1)
618 {
619 g_audioCapturer = std::make_shared<AudioCapturerAdapterImpl>();
620 ASSERT_NE(g_audioCapturer, nullptr);
621
622 AudioAdapterCapturerOptions capturerOptions;
623 capturerOptions.samplingRate = AudioAdapterSamplingRate::SAMPLE_RATE_48000;
624 capturerOptions.encoding = AudioAdapterEncodingType::ENCODING_PCM;
625 capturerOptions.format = AudioAdapterSampleFormat::SAMPLE_S16LE;
626 capturerOptions.channels = AudioAdapterChannel::STEREO;
627 capturerOptions.sourceType = AudioAdapterSourceType::SOURCE_TYPE_VOICE_COMMUNICATION;
628 capturerOptions.capturerFlags = 0;
629 int32_t retNum = g_audioCapturer->Create(capturerOptions, CACHE_PATH);
630 ASSERT_EQ(retNum, AudioAdapterCode::AUDIO_OK);
631
632 std::shared_ptr<AudioCapturerReadCallbackAdapter> callback = std::make_shared<AudioCapturerCallbackMock>();
633 EXPECT_NE(callback, nullptr);
634 retNum = g_audioCapturer->SetCapturerReadCallback(callback);
635 EXPECT_EQ(retNum, AudioAdapterCode::AUDIO_OK);
636
637 bool ret = g_audioCapturer->Start();
638 EXPECT_EQ(ret, TRUE_OK);
639 ret = g_audioCapturer->Start();
640 EXPECT_EQ(ret, TRUE_OK);
641
642 BufferDescAdapter bufferDesc;
643 retNum = g_audioCapturer->GetBufferDesc(bufferDesc);
644 EXPECT_EQ(retNum, 0);
645
646 retNum = g_audioCapturer->Enqueue(bufferDesc);
647 EXPECT_EQ(retNum, 0);
648
649 uint32_t frameCount = 0;
650 retNum = g_audioCapturer->GetFrameCount(frameCount);
651 EXPECT_EQ(retNum, 0);
652
653 int64_t result = g_audioCapturer->GetAudioTime();
654 EXPECT_NE(result, AudioAdapterCode::AUDIO_NULL_ERROR);
655
656 ret = g_audioCapturer->Stop();
657 EXPECT_EQ(ret, TRUE_OK);
658
659 ret = g_audioCapturer->Release();
660 EXPECT_EQ(ret, TRUE_OK);
661 }
662
663 /**
664 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_019.
665 * @tc.desc: Audio adapter unittest.
666 * @tc.type: FUNC.
667 * @tc.require:AR000I7I7N
668 */
669 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_019, TestSize.Level1)
670 {
671 g_audioCapturer = std::make_shared<AudioCapturerAdapterImpl>();
672 ASSERT_NE(g_audioCapturer, nullptr);
673
674 std::shared_ptr<AudioCapturerReadCallbackAdapter> callback = std::make_shared<AudioCapturerCallbackMock>();
675 int32_t retNum = g_audioCapturer->SetCapturerReadCallback(callback);
676 EXPECT_EQ(retNum, AudioAdapterCode::AUDIO_NULL_ERROR);
677
678 bool ret = g_audioCapturer->Start();
679 EXPECT_NE(ret, TRUE_OK);
680
681 BufferDescAdapter bufferDesc;
682 retNum = g_audioCapturer->GetBufferDesc(bufferDesc);
683 EXPECT_EQ(retNum, AudioAdapterCode::AUDIO_NULL_ERROR);
684
685 retNum = g_audioCapturer->Enqueue(bufferDesc);
686 EXPECT_EQ(retNum, AudioAdapterCode::AUDIO_NULL_ERROR);
687
688 uint32_t frameCount = 0;
689 retNum = g_audioCapturer->GetFrameCount(frameCount);
690 EXPECT_EQ(retNum, AudioAdapterCode::AUDIO_NULL_ERROR);
691
692 int64_t result = g_audioCapturer->GetAudioTime();
693 EXPECT_EQ(result, AudioAdapterCode::AUDIO_NULL_ERROR);
694
695 ret = g_audioCapturer->Stop();
696 EXPECT_NE(ret, TRUE_OK);
697
698 ret = g_audioCapturer->Release();
699 EXPECT_NE(ret, TRUE_OK);
700 }
701
702 /**
703 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_020.
704 * @tc.desc: Audio adapter unittest.
705 * @tc.type: FUNC.
706 * @tc.require:AR000I7I7N
707 */
708 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_020, TestSize.Level1)
709 {
710 auto callback = std::make_shared<AudioCapturerCallbackMock>();
711 auto callbackTest = std::make_shared<AudioCapturerReadCallbackImpl>(callback);
712 EXPECT_NE(callbackTest, nullptr);
713
714 size_t length = 0;
715 callbackTest->OnReadData(length);
716
717 auto callbackTestNull = std::make_shared<AudioCapturerReadCallbackImpl>(nullptr);
718 EXPECT_EQ(callbackTestNull->cb_, nullptr);
719 callbackTest->OnReadData(length);
720 callbackTest->cb_ = nullptr;
721 callbackTest->OnReadData(length);
722 }
723
724 /**
725 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_0021.
726 * @tc.desc: Audio adapter unittest.
727 * @tc.type: FUNC.
728 * @tc.require:AR000I7I7N
729 */
730 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_021, TestSize.Level1)
731 {
732 std::array<AudioAdapterSamplingRate, 11> samplingArray = {
733 AudioAdapterSamplingRate::SAMPLE_RATE_8000,
734 AudioAdapterSamplingRate::SAMPLE_RATE_11025,
735 AudioAdapterSamplingRate::SAMPLE_RATE_12000,
736 AudioAdapterSamplingRate::SAMPLE_RATE_16000,
737 AudioAdapterSamplingRate::SAMPLE_RATE_22050,
738 AudioAdapterSamplingRate::SAMPLE_RATE_24000,
739 AudioAdapterSamplingRate::SAMPLE_RATE_32000,
740 AudioAdapterSamplingRate::SAMPLE_RATE_44100,
741 AudioAdapterSamplingRate::SAMPLE_RATE_48000,
742 AudioAdapterSamplingRate::SAMPLE_RATE_64000,
743 AudioAdapterSamplingRate::SAMPLE_RATE_96000,
744 };
745 for (auto& sampling : samplingArray)
746 AudioCapturerAdapterImpl::GetAudioSamplingRate(sampling);
747
748 AudioSamplingRate testSampling =
749 AudioCapturerAdapterImpl::GetAudioSamplingRate(static_cast<AudioAdapterSamplingRate>(0));
750 EXPECT_EQ(testSampling, AudioSamplingRate::SAMPLE_RATE_44100);
751 }
752
753 /**
754 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_022.
755 * @tc.desc: Audio adapter unittest.
756 * @tc.type: FUNC.
757 * @tc.require:AR000I7I7N
758 */
759 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_022, TestSize.Level1)
760 {
761 AudioCapturerAdapterImpl::GetAudioEncodingType(AudioAdapterEncodingType::ENCODING_PCM);
762 AudioCapturerAdapterImpl::GetAudioEncodingType(AudioAdapterEncodingType::ENCODING_INVALID);
763
764 AudioEncodingType testEncodingType =
765 AudioCapturerAdapterImpl::GetAudioEncodingType(static_cast<AudioAdapterEncodingType>(1));
766 EXPECT_EQ(testEncodingType, AudioEncodingType::ENCODING_INVALID);
767 }
768
769 /**
770 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_023.
771 * @tc.desc: Audio adapter unittest.
772 * @tc.type: FUNC.
773 * @tc.require:AR000I7I7N
774 */
775 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_023, TestSize.Level1)
776 {
777 std::array<AudioAdapterSampleFormat, 6> formatArray = {
778 AudioAdapterSampleFormat::SAMPLE_U8,
779 AudioAdapterSampleFormat::SAMPLE_S16LE,
780 AudioAdapterSampleFormat::SAMPLE_S24LE,
781 AudioAdapterSampleFormat::SAMPLE_S32LE,
782 AudioAdapterSampleFormat::SAMPLE_F32LE,
783 AudioAdapterSampleFormat::INVALID_WIDTH,
784 };
785 for (auto& format : formatArray)
786 AudioCapturerAdapterImpl::GetAudioSampleFormat(format);
787
788 AudioSampleFormat testFormat =
789 AudioCapturerAdapterImpl::GetAudioSampleFormat(static_cast<AudioAdapterSampleFormat>(-2));
790 EXPECT_EQ(testFormat, AudioSampleFormat::INVALID_WIDTH);
791 }
792
793 /**
794 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_024.
795 * @tc.desc: Audio adapter unittest.
796 * @tc.type: FUNC.
797 * @tc.require:AR000I7I7N
798 */
799 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_024, TestSize.Level1)
800 {
801 std::array<AudioAdapterChannel, 8> channelArray = {
802 AudioAdapterChannel::MONO,
803 AudioAdapterChannel::STEREO,
804 AudioAdapterChannel::CHANNEL_3,
805 AudioAdapterChannel::CHANNEL_4,
806 AudioAdapterChannel::CHANNEL_5,
807 AudioAdapterChannel::CHANNEL_6,
808 AudioAdapterChannel::CHANNEL_7,
809 AudioAdapterChannel::CHANNEL_8,
810 };
811 for (auto& channel : channelArray)
812 AudioCapturerAdapterImpl::GetAudioChannel(channel);
813
814 AudioChannel testChannel = AudioCapturerAdapterImpl::GetAudioChannel(static_cast<AudioAdapterChannel>(0));
815 EXPECT_EQ(testChannel, AudioChannel::STEREO);
816 }
817
818 /**
819 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_025.
820 * @tc.desc: Audio adapter unittest.
821 * @tc.type: FUNC.
822 * @tc.require:AR000I7I7N
823 */
824 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_025, TestSize.Level1)
825 {
826 std::array<AudioAdapterSourceType, 6> sourceArray = {
827 AudioAdapterSourceType::SOURCE_TYPE_INVALID,
828 AudioAdapterSourceType::SOURCE_TYPE_MIC,
829 AudioAdapterSourceType::SOURCE_TYPE_VOICE_RECOGNITION,
830 AudioAdapterSourceType::SOURCE_TYPE_VOICE_COMMUNICATION,
831 AudioAdapterSourceType::SOURCE_TYPE_ULTRASONIC,
832 };
833 for (auto& source : sourceArray)
834 AudioCapturerAdapterImpl::GetAudioSourceType(source);
835
836 SourceType testSource = AudioCapturerAdapterImpl::GetAudioSourceType(static_cast<AudioAdapterSourceType>(-2));
837 EXPECT_EQ(testSource, SourceType::SOURCE_TYPE_VOICE_RECOGNITION);
838 }
839
840 /**
841 * @tc.name: NWebAudioAdapterTest_Create_026.
842 * @tc.desc: Audio adapter unittest.
843 * @tc.type: FUNC.
844 * @tc.require:AR000I7I7N
845 */
846 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_Create_026, TestSize.Level1)
847 {
848 auto audioCapturer = std::make_shared<AudioCapturerAdapterImpl>();
849 ASSERT_NE(audioCapturer, nullptr);
850 AudioAdapterCapturerOptions capturerOptions;
851 capturerOptions.samplingRate = AudioAdapterSamplingRate::SAMPLE_RATE_48000;
852 capturerOptions.encoding = AudioAdapterEncodingType::ENCODING_PCM;
853 capturerOptions.format = AudioAdapterSampleFormat::SAMPLE_S16LE;
854 capturerOptions.channels = AudioAdapterChannel::STEREO;
855 capturerOptions.sourceType = AudioAdapterSourceType::SOURCE_TYPE_VOICE_COMMUNICATION;
856 capturerOptions.capturerFlags = 0;
857 int32_t retNum = audioCapturer->Create(capturerOptions);
858 ASSERT_NE(retNum, AudioAdapterCode::AUDIO_OK);
859 }
860 } // namespace NWeb
861 } // namespace OHOS