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 "application_context.h"
24 #include "audio_capturer_adapter.h"
25 #include "audio_capturer_adapter_impl.h"
26 #include "audio_renderer_adapter.h"
27 #include "audio_renderer_adapter_impl.h"
28 #include "audio_system_manager_adapter_impl.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 LANGUAGE_EN = "en";
41 const std::string DEVICE_TYPE_NONE_TEST = "device/none";
42 const std::string DEVICE_TYPE_NONE_ZH_CN_TEST = "无";
43 const std::string CACHE_PATH = "/data/local/tmp";
44 std::shared_ptr<NWeb::AudioRendererAdapterImpl> g_audioRender = nullptr;
45 std::shared_ptr<NWeb::AudioCapturerAdapterImpl> g_audioCapturer = nullptr;
46 std::shared_ptr<AbilityRuntime::ApplicationContext> g_applicationContext = nullptr;
47 const int32_t ADAPTER_AUDIO_UNDEFINED_DEVICEID = 1000001;
48 } // namespace
49
50 namespace AbilityRuntime {
GetApplicationContext()51 std::shared_ptr<ApplicationContext> Context::GetApplicationContext()
52 {
53 return g_applicationContext;
54 }
55 } // namespace AbilityRuntime
56
57 namespace NWeb {
58 class NWebAudioAdapterTest : public testing::Test {
59 public:
60 static void SetUpTestCase(void);
61 static void TearDownTestCase(void);
62 void SetUp();
63 void TearDown();
64 };
65
66 class AudioRendererOptionsAdapterMock : public AudioRendererOptionsAdapter {
67 public:
68 AudioRendererOptionsAdapterMock() = default;
69
GetSamplingRate()70 AudioAdapterSamplingRate GetSamplingRate() override
71 {
72 return samplingRate;
73 }
74
GetEncodingType()75 AudioAdapterEncodingType GetEncodingType() override
76 {
77 return encoding;
78 }
79
GetSampleFormat()80 AudioAdapterSampleFormat GetSampleFormat() override
81 {
82 return format;
83 }
84
GetChannel()85 AudioAdapterChannel GetChannel() override
86 {
87 return channels;
88 }
89
GetContentType()90 AudioAdapterContentType GetContentType() override
91 {
92 return contentType;
93 }
94
GetStreamUsage()95 AudioAdapterStreamUsage GetStreamUsage() override
96 {
97 return streamUsage;
98 }
99
GetRenderFlags()100 int32_t GetRenderFlags() override
101 {
102 return rendererFlags;
103 }
104
105 AudioAdapterSamplingRate samplingRate;
106 AudioAdapterEncodingType encoding;
107 AudioAdapterSampleFormat format;
108 AudioAdapterChannel channels;
109 AudioAdapterContentType contentType;
110 AudioAdapterStreamUsage streamUsage;
111 int32_t rendererFlags;
112 };
113
114 class AudioInterruptAdapterMock : public AudioInterruptAdapter {
115 public:
116 AudioInterruptAdapterMock() = default;
117
GetStreamUsage()118 AudioAdapterStreamUsage GetStreamUsage() override
119 {
120 return streamUsage;
121 }
122
GetContentType()123 AudioAdapterContentType GetContentType() override
124 {
125 return contentType;
126 }
127
GetStreamType()128 AudioAdapterStreamType GetStreamType() override
129 {
130 return streamType;
131 }
132
GetSessionID()133 uint32_t GetSessionID() override
134 {
135 return sessionID;
136 }
137
GetPauseWhenDucked()138 bool GetPauseWhenDucked() override
139 {
140 return pauseWhenDucked;
141 }
142
143 AudioAdapterStreamUsage streamUsage;
144 AudioAdapterContentType contentType;
145 AudioAdapterStreamType streamType;
146 uint32_t sessionID;
147 bool pauseWhenDucked;
148 };
149
150 class AudioCapturerOptionsAdapterMock : public AudioCapturerOptionsAdapter {
151 public:
152 AudioCapturerOptionsAdapterMock() = default;
153
GetSamplingRate()154 AudioAdapterSamplingRate GetSamplingRate() override
155 {
156 return samplingRate;
157 }
158
GetEncoding()159 AudioAdapterEncodingType GetEncoding() override
160 {
161 return encoding;
162 }
163
GetSampleFormat()164 AudioAdapterSampleFormat GetSampleFormat() override
165 {
166 return format;
167 }
168
GetChannels()169 AudioAdapterChannel GetChannels() override
170 {
171 return channels;
172 }
173
GetSourceType()174 AudioAdapterSourceType GetSourceType() override
175 {
176 return sourceType;
177 }
178
GetCapturerFlags()179 int32_t GetCapturerFlags() override
180 {
181 return capturerFlags;
182 }
183
184 AudioAdapterSamplingRate samplingRate;
185 AudioAdapterEncodingType encoding;
186 AudioAdapterSampleFormat format;
187 AudioAdapterChannel channels;
188 AudioAdapterSourceType sourceType;
189 int32_t capturerFlags;
190 };
191
192 class BufferDescAdapterMock : public BufferDescAdapter {
193 public:
194 BufferDescAdapterMock() = default;
195
GetBuffer()196 uint8_t* GetBuffer() override
197 {
198 return buffer;
199 }
200
GetBufLength()201 size_t GetBufLength() override
202 {
203 return bufLength;
204 }
205
GetDataLength()206 size_t GetDataLength() override
207 {
208 return dataLength;
209 }
210
SetBuffer(uint8_t * buf)211 void SetBuffer(uint8_t* buf) override
212 {
213 buffer = buf;
214 }
215
SetBufLength(size_t bufLen)216 void SetBufLength(size_t bufLen) override
217 {
218 bufLength = bufLen;
219 }
220
SetDataLength(size_t dataLen)221 void SetDataLength(size_t dataLen) override
222 {
223 dataLength = dataLen;
224 }
225
226 uint8_t* buffer;
227 size_t bufLength;
228 size_t dataLength;
229 };
230
231 class ApplicationContextMock : public ApplicationContext {
232 public:
233 MOCK_METHOD0(GetCacheDir, std::string());
234 };
235
236 class AudioCallbackTest : public AudioManagerCallbackAdapter {
237 public:
238 AudioCallbackTest() = default;
239
240 virtual ~AudioCallbackTest() = default;
241
OnSuspend()242 void OnSuspend() override {};
243
OnResume()244 void OnResume() override {};
245 };
246
247 class AudioRendererCallbackMock : public AudioRendererCallbackAdapter {
248 public:
249 AudioRendererCallbackMock() = default;
250
251 virtual ~AudioRendererCallbackMock() = default;
252
OnSuspend()253 void OnSuspend() override {};
254
OnResume()255 void OnResume() override {};
256 };
257
258 class AudioOutputChangeCallbackMock : public AudioOutputChangeCallbackAdapter {
259 public:
260 AudioOutputChangeCallbackMock() = default;
261
262 virtual ~AudioOutputChangeCallbackMock() = default;
263
OnOutputDeviceChange(int32_t reason)264 void OnOutputDeviceChange(int32_t reason) override {};
265 };
266
267 class AudioCapturerCallbackMock : public AudioCapturerReadCallbackAdapter {
268 public:
269 AudioCapturerCallbackMock() = default;
270
271 virtual ~AudioCapturerCallbackMock() = default;
272
OnReadData(size_t length)273 void OnReadData(size_t length) override {};
274 };
275
276 class AudioManagerDeviceChangeCallbackAdapterMock : public AudioManagerDeviceChangeCallbackAdapter {
277 public:
278 AudioManagerDeviceChangeCallbackAdapterMock() = default;
279
280 virtual ~AudioManagerDeviceChangeCallbackAdapterMock() = default;
281
OnDeviceChange()282 void OnDeviceChange() override {};
283 };
284
SetUpTestCase(void)285 void NWebAudioAdapterTest::SetUpTestCase(void)
286 {
287 uint64_t tokenId;
288 const char* perms[1];
289 perms[0] = "ohos.permission.MICROPHONE";
290 NativeTokenInfoParams infoInstance = {
291 .dcapsNum = 0,
292 .permsNum = 1,
293 .aclsNum = 0,
294 .dcaps = NULL,
295 .perms = perms,
296 .acls = NULL,
297 .processName = "web_audio_tdd",
298 .aplStr = "system_basic",
299 };
300 tokenId = GetAccessTokenId(&infoInstance);
301 SetSelfTokenID(tokenId);
302 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
303 }
304
TearDownTestCase(void)305 void NWebAudioAdapterTest::TearDownTestCase(void) {}
306
SetUp(void)307 void NWebAudioAdapterTest::SetUp(void) {}
308
TearDown(void)309 void NWebAudioAdapterTest::TearDown(void) {}
310
311 /**
312 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_001.
313 * @tc.desc: Audio adapter unittest.
314 * @tc.type: FUNC.
315 * @tc.require:I5HRX9
316 */
317 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_001, TestSize.Level1)
318 {
319 ApplicationContextMock* contextMock = new ApplicationContextMock();
320 EXPECT_NE(contextMock, nullptr);
321 EXPECT_EQ(g_applicationContext, nullptr);
322 g_applicationContext.reset(contextMock);
323 EXPECT_NE(g_applicationContext, nullptr);
324
325 g_audioRender = std::make_shared<AudioRendererAdapterImpl>();
326 ASSERT_NE(g_audioRender, nullptr);
327
328 AudioRendererOptions rendererOptions;
329 AudioRendererInfo renderInfo;
330 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
331 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
332 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
333 rendererOptions.streamInfo.channels = AudioChannel::STEREO;
334 rendererOptions.rendererInfo = renderInfo;
335 g_audioRender->audio_renderer_ = AudioRenderer::Create(rendererOptions);
336 ASSERT_NE(g_audioRender->audio_renderer_, nullptr);
337
338 bool ret = g_audioRender->Start();
339 EXPECT_EQ(ret, TRUE_OK);
340
341 std::array<uint8_t, 4> bufferArray = { 0, 0, 0, 0 };
342 g_audioRender->Write(bufferArray.data(), bufferArray.size());
343
344 uint64_t latency;
345 int32_t retNum = g_audioRender->GetLatency(latency);
346 EXPECT_EQ(retNum, RESULT_OK);
347
348 float volume = 0.8;
349 retNum = g_audioRender->SetVolume(volume);
350 EXPECT_EQ(retNum, RESULT_OK);
351
352 float nowVolume = g_audioRender->GetVolume();
353 EXPECT_EQ(nowVolume, volume);
354 retNum = g_audioRender->SetAudioRendererCallback(nullptr);
355 EXPECT_NE(retNum, 0);
356 std::shared_ptr<AudioRendererCallbackAdapter> callback = std::make_shared<AudioRendererCallbackMock>();
357 EXPECT_NE(callback, nullptr);
358 retNum = g_audioRender->SetAudioRendererCallback(callback);
359 EXPECT_EQ(retNum, 0);
360 g_audioRender->SetInterruptMode(true);
361 g_audioRender->SetInterruptMode(false);
362 g_audioRender->SetAudioSilentMode(true);
363 g_audioRender->SetAudioSilentMode(false);
364 ret = g_audioRender->IsRendererStateRunning();
365 EXPECT_EQ(ret, TRUE_OK);
366 ret = g_audioRender->Pause();
367 EXPECT_EQ(ret, TRUE_OK);
368 ret = g_audioRender->Stop();
369 EXPECT_EQ(ret, TRUE_OK);
370 ret = g_audioRender->Release();
371 EXPECT_EQ(ret, TRUE_OK);
372 }
373
374 /**
375 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_002.
376 * @tc.desc: Audio adapter unittest.
377 * @tc.type: FUNC.
378 * @tc.require:I5HRX9
379 */
380 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_002, TestSize.Level1)
381 {
382 std::array<AudioAdapterSamplingRate, 11> samplingArray = {
383 AudioAdapterSamplingRate::SAMPLE_RATE_8000,
384 AudioAdapterSamplingRate::SAMPLE_RATE_11025,
385 AudioAdapterSamplingRate::SAMPLE_RATE_12000,
386 AudioAdapterSamplingRate::SAMPLE_RATE_16000,
387 AudioAdapterSamplingRate::SAMPLE_RATE_22050,
388 AudioAdapterSamplingRate::SAMPLE_RATE_24000,
389 AudioAdapterSamplingRate::SAMPLE_RATE_32000,
390 AudioAdapterSamplingRate::SAMPLE_RATE_44100,
391 AudioAdapterSamplingRate::SAMPLE_RATE_48000,
392 AudioAdapterSamplingRate::SAMPLE_RATE_64000,
393 AudioAdapterSamplingRate::SAMPLE_RATE_96000,
394 };
395 for (auto& sampling : samplingArray)
396 AudioRendererAdapterImpl::GetAudioSamplingRate(sampling);
397
398 AudioSamplingRate testSampling =
399 AudioRendererAdapterImpl::GetAudioSamplingRate(static_cast<AudioAdapterSamplingRate>(0));
400 EXPECT_EQ(testSampling, AudioSamplingRate::SAMPLE_RATE_44100);
401 }
402
403 /**
404 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_003.
405 * @tc.desc: Audio adapter unittest.
406 * @tc.type: FUNC.
407 * @tc.require:I5HRX9
408 */
409 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_003, TestSize.Level1)
410 {
411 AudioRendererAdapterImpl::GetAudioEncodingType(AudioAdapterEncodingType::ENCODING_PCM);
412 AudioRendererAdapterImpl::GetAudioEncodingType(AudioAdapterEncodingType::ENCODING_INVALID);
413
414 AudioEncodingType testEncodingType =
415 AudioRendererAdapterImpl::GetAudioEncodingType(static_cast<AudioAdapterEncodingType>(1));
416 EXPECT_EQ(testEncodingType, AudioEncodingType::ENCODING_INVALID);
417 }
418
419 /**
420 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_004.
421 * @tc.desc: Audio adapter unittest.
422 * @tc.type: FUNC.
423 * @tc.require:I5HRX9
424 */
425 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_004, TestSize.Level1)
426 {
427 std::array<AudioAdapterSampleFormat, 6> formatArray = {
428 AudioAdapterSampleFormat::SAMPLE_U8,
429 AudioAdapterSampleFormat::SAMPLE_S16LE,
430 AudioAdapterSampleFormat::SAMPLE_S24LE,
431 AudioAdapterSampleFormat::SAMPLE_S32LE,
432 AudioAdapterSampleFormat::SAMPLE_F32LE,
433 AudioAdapterSampleFormat::INVALID_WIDTH,
434 };
435 for (auto& format : formatArray)
436 AudioRendererAdapterImpl::GetAudioSampleFormat(format);
437
438 AudioSampleFormat testFormat =
439 AudioRendererAdapterImpl::GetAudioSampleFormat(static_cast<AudioAdapterSampleFormat>(-2));
440 EXPECT_EQ(testFormat, AudioSampleFormat::INVALID_WIDTH);
441 }
442
443 /**
444 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_005.
445 * @tc.desc: Audio adapter unittest.
446 * @tc.type: FUNC.
447 * @tc.require:I5HRX9
448 */
449 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_005, TestSize.Level1)
450 {
451 std::array<AudioAdapterChannel, 8> channelArray = {
452 AudioAdapterChannel::MONO,
453 AudioAdapterChannel::STEREO,
454 AudioAdapterChannel::CHANNEL_3,
455 AudioAdapterChannel::CHANNEL_4,
456 AudioAdapterChannel::CHANNEL_5,
457 AudioAdapterChannel::CHANNEL_6,
458 AudioAdapterChannel::CHANNEL_7,
459 AudioAdapterChannel::CHANNEL_8,
460 };
461 for (auto& channel : channelArray)
462 AudioRendererAdapterImpl::GetAudioChannel(channel);
463
464 AudioChannel testChannel = AudioRendererAdapterImpl::GetAudioChannel(static_cast<AudioAdapterChannel>(0));
465 EXPECT_EQ(testChannel, AudioChannel::STEREO);
466 }
467
468 /**
469 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_006.
470 * @tc.desc: Audio adapter unittest.
471 * @tc.type: FUNC.
472 * @tc.require:I5HRX9
473 */
474 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_006, TestSize.Level1)
475 {
476 std::array<AudioAdapterContentType, 6> contentArray = {
477 AudioAdapterContentType::CONTENT_TYPE_UNKNOWN,
478 AudioAdapterContentType::CONTENT_TYPE_SPEECH,
479 AudioAdapterContentType::CONTENT_TYPE_MUSIC,
480 AudioAdapterContentType::CONTENT_TYPE_MOVIE,
481 AudioAdapterContentType::CONTENT_TYPE_SONIFICATION,
482 AudioAdapterContentType::CONTENT_TYPE_RINGTONE,
483 };
484 for (auto& content : contentArray)
485 AudioRendererAdapterImpl::GetAudioContentType(content);
486
487 ContentType testContent = AudioRendererAdapterImpl::GetAudioContentType(static_cast<AudioAdapterContentType>(-1));
488 EXPECT_EQ(testContent, ContentType::CONTENT_TYPE_MUSIC);
489 }
490
491 /**
492 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_007.
493 * @tc.desc: Audio adapter unittest.
494 * @tc.type: FUNC.
495 * @tc.require:I5HRX9
496 */
497 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_007, TestSize.Level1)
498 {
499 std::array<AudioAdapterStreamUsage, 5> usageArray = {
500 AudioAdapterStreamUsage::STREAM_USAGE_UNKNOWN,
501 AudioAdapterStreamUsage::STREAM_USAGE_MEDIA,
502 AudioAdapterStreamUsage::STREAM_USAGE_VOICE_COMMUNICATION,
503 AudioAdapterStreamUsage::STREAM_USAGE_VOICE_ASSISTANT,
504 AudioAdapterStreamUsage::STREAM_USAGE_NOTIFICATION_RINGTONE,
505 };
506 for (auto& usage : usageArray)
507 AudioRendererAdapterImpl::GetAudioStreamUsage(usage);
508
509 StreamUsage testUsage = AudioRendererAdapterImpl::GetAudioStreamUsage(static_cast<AudioAdapterStreamUsage>(-1));
510 EXPECT_EQ(testUsage, StreamUsage::STREAM_USAGE_MEDIA);
511 }
512
513 /**
514 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_008.
515 * @tc.desc: Audio adapter unittest.
516 * @tc.type: FUNC.
517 * @tc.require:I5HRX9
518 */
519 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_008, TestSize.Level1)
520 {
521 bool ret = AudioSystemManagerAdapterImpl::GetInstance().HasAudioOutputDevices();
522 EXPECT_EQ(ret, TRUE_OK);
523
524 AudioSystemManagerAdapterImpl::GetInstance().HasAudioInputDevices();
525
526 std::shared_ptr<AudioDeviceDescAdapter> result =
527 AudioSystemManagerAdapterImpl::GetInstance().GetDefaultOutputDevice();
528 EXPECT_NE(result, nullptr);
529 EXPECT_NE(result->GetDeviceId(), -1);
530 int32_t status = AudioSystemManagerAdapterImpl::GetInstance().SetDeviceChangeCallback(nullptr);
531 EXPECT_NE(status, 0);
532 auto mock = std::make_shared<AudioManagerDeviceChangeCallbackAdapterMock>();
533 status = AudioSystemManagerAdapterImpl::GetInstance().SetDeviceChangeCallback(mock);
534 EXPECT_EQ(status, 0);
535
536 AudioStreamType type =
537 AudioSystemManagerAdapterImpl::GetInstance().GetStreamType(AudioAdapterStreamType::STREAM_VOICE_CALL);
538 EXPECT_EQ(type, AudioStreamType::STREAM_VOICE_CALL);
539 type = AudioSystemManagerAdapterImpl::GetInstance().GetStreamType(static_cast<AudioAdapterStreamType>(-2));
540 EXPECT_EQ(type, AudioStreamType::STREAM_DEFAULT);
541
542 std::vector<sptr<AudioDeviceDescriptor>> device;
543 int32_t select = AudioSystemManagerAdapterImpl::GetInstance().SelectAudioOutputDevice(false, device);
544 EXPECT_NE(select, 0);
545 select = AudioSystemManagerAdapterImpl::GetInstance().SelectAudioOutputDevice(true, device);
546 EXPECT_NE(select, 0);
547 AudioSystemManagerAdapterImpl::GetInstance().GetDefaultInputDevice();
548 }
549
550 /**
551 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_009.
552 * @tc.desc: Audio adapter unittest.
553 * @tc.type: FUNC.
554 * @tc.require:I5HRX9
555 */
556 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_009, TestSize.Level1)
557 {
558 std::shared_ptr<AudioInterruptAdapterMock> interrupt = std::make_shared<AudioInterruptAdapterMock>();
559 EXPECT_NE(interrupt, nullptr);
560 interrupt->streamUsage = AudioAdapterStreamUsage::STREAM_USAGE_MEDIA;
561 interrupt->contentType = AudioAdapterContentType::CONTENT_TYPE_MUSIC;
562 interrupt->streamType = AudioAdapterStreamType::STREAM_DEFAULT;
563
564 int32_t ret = AudioSystemManagerAdapterImpl::GetInstance().RequestAudioFocus(interrupt);
565 EXPECT_NE(ret, RESULT_OK);
566 ret = AudioSystemManagerAdapterImpl::GetInstance().AbandonAudioFocus(interrupt);
567 EXPECT_NE(ret, RESULT_OK);
568
569 interrupt->streamType = AudioAdapterStreamType::STREAM_MUSIC;
570 ret = AudioSystemManagerAdapterImpl::GetInstance().RequestAudioFocus(interrupt);
571 EXPECT_EQ(ret, RESULT_OK);
572
573 ret = AudioSystemManagerAdapterImpl::GetInstance().AbandonAudioFocus(interrupt);
574 EXPECT_EQ(ret, RESULT_OK);
575 ret = AudioSystemManagerAdapterImpl::GetInstance().RequestAudioFocus(nullptr);
576 EXPECT_NE(ret, RESULT_OK);
577 ret = AudioSystemManagerAdapterImpl::GetInstance().AbandonAudioFocus(nullptr);
578 EXPECT_NE(ret, RESULT_OK);
579 }
580
581 /**
582 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_010.
583 * @tc.desc: Audio adapter unittest.
584 * @tc.type: FUNC.
585 * @tc.require:I5HRX9
586 */
587 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_010, TestSize.Level1)
588 {
589 auto callback = std::make_shared<AudioCallbackTest>();
590 int32_t ret = AudioSystemManagerAdapterImpl::GetInstance().SetAudioManagerInterruptCallback(nullptr);
591 EXPECT_NE(ret, RESULT_OK);
592
593 ret = AudioSystemManagerAdapterImpl::GetInstance().SetAudioManagerInterruptCallback(callback);
594 EXPECT_EQ(ret, RESULT_OK);
595
596 ret = AudioSystemManagerAdapterImpl::GetInstance().UnsetAudioManagerInterruptCallback();
597 EXPECT_EQ(ret, RESULT_OK);
598
599 AudioSystemManagerAdapterImpl::GetInstance().GetDevices(AdapterDeviceFlag::OUTPUT_DEVICES_FLAG);
600 AudioSystemManagerAdapterImpl::GetInstance().GetDevices(static_cast<AdapterDeviceFlag>(-1));
601
602 ret = AudioSystemManagerAdapterImpl::GetInstance().SelectAudioDeviceById(-1, true);
603 EXPECT_NE(ret, RESULT_OK);
604 ret = AudioSystemManagerAdapterImpl::GetInstance().SelectAudioDeviceById(-1, false);
605 EXPECT_NE(ret, RESULT_OK);
606 ret = AudioSystemManagerAdapterImpl::GetInstance().SelectAudioDeviceById(
607 (int32_t)ADAPTER_AUDIO_UNDEFINED_DEVICEID, false);
608 EXPECT_NE(ret, RESULT_OK);
609 }
610
611 /**
612 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_011.
613 * @tc.desc: Audio adapter unittest.
614 * @tc.type: FUNC.
615 * @tc.require:I5HRX9
616 */
617 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_011, TestSize.Level1)
618 {
619 std::array<AudioAdapterStreamType, 16> streamArray = {
620 AudioAdapterStreamType::STREAM_DEFAULT,
621 AudioAdapterStreamType::STREAM_VOICE_CALL,
622 AudioAdapterStreamType::STREAM_MUSIC,
623 AudioAdapterStreamType::STREAM_RING,
624 AudioAdapterStreamType::STREAM_MEDIA,
625 AudioAdapterStreamType::STREAM_VOICE_ASSISTANT,
626 AudioAdapterStreamType::STREAM_SYSTEM,
627 AudioAdapterStreamType::STREAM_ALARM,
628 AudioAdapterStreamType::STREAM_NOTIFICATION,
629 AudioAdapterStreamType::STREAM_BLUETOOTH_SCO,
630 AudioAdapterStreamType::STREAM_ENFORCED_AUDIBLE,
631 AudioAdapterStreamType::STREAM_DTMF,
632 AudioAdapterStreamType::STREAM_TTS,
633 AudioAdapterStreamType::STREAM_ACCESSIBILITY,
634 AudioAdapterStreamType::STREAM_RECORDING,
635 AudioAdapterStreamType::STREAM_ALL,
636 };
637
638 for (auto& stream : streamArray)
639 AudioSystemManagerAdapterImpl::GetInstance().GetStreamType(stream);
640 AudioStreamType testStream =
641 AudioSystemManagerAdapterImpl::GetInstance().GetStreamType(static_cast<AudioAdapterStreamType>(-2));
642 EXPECT_EQ(testStream, AudioStreamType::STREAM_DEFAULT);
643 }
644
645 /**
646 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_012.
647 * @tc.desc: Audio adapter unittest.
648 * @tc.type: FUNC.
649 * @tc.require:I5HRX9
650 */
651 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_012, TestSize.Level1)
652 {
653 auto callback = std::make_shared<AudioCallbackTest>();
654 auto callbackTest = std::make_shared<AudioManagerCallbackAdapterImpl>(callback);
655 ASSERT_NE(callbackTest, nullptr);
656
657 InterruptAction interruptAction;
658
659 interruptAction.interruptHint = InterruptHint::INTERRUPT_HINT_PAUSE;
660 callbackTest->OnInterrupt(interruptAction);
661
662 interruptAction.interruptHint = InterruptHint::INTERRUPT_HINT_STOP;
663 callbackTest->OnInterrupt(interruptAction);
664
665 interruptAction.interruptHint = InterruptHint::INTERRUPT_HINT_RESUME;
666 callbackTest->OnInterrupt(interruptAction);
667
668 interruptAction.interruptHint = static_cast<InterruptHint>(-1);
669 callbackTest->OnInterrupt(interruptAction);
670 callbackTest->cb_ = nullptr;
671 callbackTest->OnInterrupt(interruptAction);
672 }
673
674 /**
675 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_013.
676 * @tc.desc: Audio adapter unittest.
677 * @tc.type: FUNC.
678 * @tc.require:I5HRX9
679 */
680 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_013, TestSize.Level1)
681 {
682 g_audioRender = std::make_shared<AudioRendererAdapterImpl>();
683 ASSERT_NE(g_audioRender, nullptr);
684
685 std::shared_ptr<AudioRendererOptionsAdapterMock> rendererOptions =
686 std::make_shared<AudioRendererOptionsAdapterMock>();
687 rendererOptions->samplingRate = AudioAdapterSamplingRate::SAMPLE_RATE_44100;
688 rendererOptions->encoding = AudioAdapterEncodingType::ENCODING_PCM;
689 rendererOptions->format = AudioAdapterSampleFormat::SAMPLE_S16LE;
690 rendererOptions->channels = AudioAdapterChannel::STEREO;
691 rendererOptions->contentType = AudioAdapterContentType::CONTENT_TYPE_MUSIC;
692 rendererOptions->streamUsage = AudioAdapterStreamUsage::STREAM_USAGE_MEDIA;
693 rendererOptions->rendererFlags = 0;
694 int32_t retNum = g_audioRender->Create(rendererOptions);
695 ASSERT_NE(retNum, AudioAdapterCode::AUDIO_OK);
696
697 bool ret = g_audioRender->Start();
698 EXPECT_NE(ret, TRUE_OK);
699
700 std::array<uint8_t, 4> bufferArray = { 0, 0, 0, 0 };
701 retNum = g_audioRender->Write(bufferArray.data(), bufferArray.size());
702 EXPECT_NE(retNum, bufferArray.size());
703
704 uint64_t latency;
705 retNum = g_audioRender->GetLatency(latency);
706 EXPECT_NE(retNum, RESULT_OK);
707
708 float volume = 0.8;
709 retNum = g_audioRender->SetVolume(volume);
710 EXPECT_NE(retNum, RESULT_OK);
711
712 float nowVolume = g_audioRender->GetVolume();
713 EXPECT_NE(nowVolume, volume);
714
715 ret = g_audioRender->Pause();
716 EXPECT_NE(ret, TRUE_OK);
717
718 ret = g_audioRender->Stop();
719 EXPECT_NE(ret, TRUE_OK);
720
721 ret = g_audioRender->Release();
722 EXPECT_NE(ret, TRUE_OK);
723 }
724
725 /**
726 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_014.
727 * @tc.desc: Audio adapter unittest.
728 * @tc.type: FUNC
729 * @tc.require:I5RWOG
730 */
731 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_014, TestSize.Level1)
732 {
733 g_applicationContext.reset();
734 ApplicationContextMock* contextMock = new ApplicationContextMock();
735 EXPECT_NE(contextMock, nullptr);
736 EXPECT_CALL(*contextMock, GetCacheDir()).Times(1).WillRepeatedly(::testing::Return(""));
737 EXPECT_EQ(g_applicationContext, nullptr);
738 g_applicationContext.reset(contextMock);
739 EXPECT_NE(g_applicationContext, nullptr);
740
741 std::shared_ptr<AudioRendererAdapterImpl> audioRenderImpl = std::make_shared<AudioRendererAdapterImpl>();
742 EXPECT_NE(audioRenderImpl, nullptr);
743
744 std::shared_ptr<AudioRendererOptionsAdapterMock> rendererOptions =
745 std::make_shared<AudioRendererOptionsAdapterMock>();
746 rendererOptions->samplingRate = AudioAdapterSamplingRate::SAMPLE_RATE_44100;
747 rendererOptions->encoding = AudioAdapterEncodingType::ENCODING_PCM;
748 rendererOptions->format = AudioAdapterSampleFormat::SAMPLE_S16LE;
749 rendererOptions->channels = AudioAdapterChannel::STEREO;
750 rendererOptions->contentType = AudioAdapterContentType::CONTENT_TYPE_MUSIC;
751 rendererOptions->streamUsage = AudioAdapterStreamUsage::STREAM_USAGE_MEDIA;
752 rendererOptions->rendererFlags = 0;
753 int32_t retNum = audioRenderImpl->Create(rendererOptions);
754 g_applicationContext.reset();
755 EXPECT_EQ(g_applicationContext, nullptr);
756 EXPECT_EQ(retNum, AudioAdapterCode::AUDIO_ERROR);
757 EXPECT_EQ(audioRenderImpl->audio_renderer_, nullptr);
758 audioRenderImpl->SetInterruptMode(false);
759 audioRenderImpl->SetAudioSilentMode(false);
760 retNum = audioRenderImpl->Create(nullptr);
761 }
762
763 /**
764 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_015.
765 * @tc.desc: Audio adapter unittest.
766 * @tc.type: FUNC
767 * @tc.require:I5HRX9
768 */
769 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_015, TestSize.Level1)
770 {
771 ApplicationContextMock* contextMock = new ApplicationContextMock();
772 EXPECT_NE(contextMock, nullptr);
773 EXPECT_CALL(*contextMock, GetCacheDir()).Times(1).WillRepeatedly(::testing::Return(CACHE_PATH));
774 EXPECT_EQ(g_applicationContext, nullptr);
775 g_applicationContext.reset(contextMock);
776 EXPECT_NE(g_applicationContext, nullptr);
777
778 std::shared_ptr<AudioRendererAdapterImpl> audioRenderImpl = std::make_shared<AudioRendererAdapterImpl>();
779 EXPECT_NE(audioRenderImpl, nullptr);
780
781 std::shared_ptr<AudioRendererOptionsAdapterMock> rendererOptions =
782 std::make_shared<AudioRendererOptionsAdapterMock>();
783 rendererOptions->samplingRate = AudioAdapterSamplingRate::SAMPLE_RATE_44100;
784 rendererOptions->encoding = AudioAdapterEncodingType::ENCODING_PCM;
785 rendererOptions->format = AudioAdapterSampleFormat::SAMPLE_S16LE;
786 rendererOptions->channels = AudioAdapterChannel::STEREO;
787 rendererOptions->contentType = AudioAdapterContentType::CONTENT_TYPE_MUSIC;
788 rendererOptions->streamUsage = AudioAdapterStreamUsage::STREAM_USAGE_MEDIA;
789 rendererOptions->rendererFlags = 0;
790 audioRenderImpl->Create(rendererOptions);
791 g_applicationContext.reset();
792 EXPECT_EQ(g_applicationContext, nullptr);
793 }
794
795 /**
796 * @tc.name: NWebAudioAdapterTest_OnInterrupt_016.
797 * @tc.desc: Audio adapter unittest.
798 * @tc.type: FUNC
799 * @tc.require:I5HRX9
800 */
801 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_OnInterrupt_016, TestSize.Level1)
802 {
803 std::shared_ptr<AudioRendererCallbackAdapter> cb = std::make_shared<AudioRendererCallbackMock>();
804 EXPECT_NE(cb, nullptr);
805 auto callBack = std::make_shared<AudioRendererCallbackImpl>(cb);
806 EXPECT_NE(callBack, nullptr);
807 InterruptEvent interruptEvent;
808 interruptEvent.hintType = OHOS::AudioStandard::InterruptHint::INTERRUPT_HINT_PAUSE;
809 callBack->OnInterrupt(interruptEvent);
810 interruptEvent.hintType = OHOS::AudioStandard::InterruptHint::INTERRUPT_HINT_STOP;
811 callBack->OnInterrupt(interruptEvent);
812 interruptEvent.hintType = OHOS::AudioStandard::InterruptHint::INTERRUPT_HINT_RESUME;
813 callBack->OnInterrupt(interruptEvent);
814 interruptEvent.hintType = OHOS::AudioStandard::InterruptHint::INTERRUPT_HINT_NONE;
815 callBack->OnInterrupt(interruptEvent);
816 callBack->OnStateChange(RendererState::RENDERER_PAUSED, StateChangeCmdType::CMD_FROM_SYSTEM);
817 callBack->cb_ = nullptr;
818 callBack->OnInterrupt(interruptEvent);
819 }
820
821 /**
822 * @tc.name: NWebAudioAdapterTest_SetAudioRendererCallback_017.
823 * @tc.desc: Audio adapter unittest.
824 * @tc.type: FUNC
825 * @tc.require:I5HRX9
826 */
827 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_SetAudioRendererCallback_017, TestSize.Level1)
828 {
829 auto audioRender = std::make_shared<AudioRendererAdapterImpl>();
830 ASSERT_NE(audioRender, nullptr);
831 std::shared_ptr<AudioRendererCallbackAdapter> callback = std::make_shared<AudioRendererCallbackMock>();
832 ASSERT_NE(callback, nullptr);
833 int32_t retNum = audioRender->SetAudioRendererCallback(callback);
834 EXPECT_NE(retNum, 0);
835 }
836
837 /**
838 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_018.
839 * @tc.desc: Audio adapter unittest.
840 * @tc.type: FUNC.
841 * @tc.require:AR000I7I7N
842 */
843 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_018, TestSize.Level1)
844 {
845 g_audioCapturer = std::make_shared<AudioCapturerAdapterImpl>();
846 ASSERT_NE(g_audioCapturer, nullptr);
847 g_audioCapturer->audio_capturer_ = AudioCapturer::Create(STREAM_MUSIC);
848 ASSERT_NE(g_audioCapturer->audio_capturer_, nullptr);
849 std::shared_ptr<AudioCapturerReadCallbackAdapter> callback = std::make_shared<AudioCapturerCallbackMock>();
850 EXPECT_NE(callback, nullptr);
851 g_audioCapturer->SetCapturerReadCallback(callback);
852 g_audioCapturer->Start();
853 std::shared_ptr<BufferDescAdapterMock> bufferDesc = std::make_shared<BufferDescAdapterMock>();
854 EXPECT_NE(bufferDesc, nullptr);
855 int32_t retNum = g_audioCapturer->GetBufferDesc(bufferDesc);
856 EXPECT_EQ(retNum, 0);
857 g_audioCapturer->Enqueue(bufferDesc);
858 uint32_t frameCount = 0;
859 retNum = g_audioCapturer->GetFrameCount(frameCount);
860 EXPECT_EQ(retNum, 0);
861 int64_t result = g_audioCapturer->GetAudioTime();
862 EXPECT_NE(result, AudioAdapterCode::AUDIO_NULL_ERROR);
863 g_audioCapturer->Stop();
864 int32_t ret = g_audioCapturer->Release();
865 EXPECT_EQ(ret, TRUE_OK);
866 retNum = g_audioCapturer->GetBufferDesc(nullptr);
867 EXPECT_NE(retNum, 0);
868 retNum = g_audioCapturer->Enqueue(nullptr);
869 EXPECT_NE(retNum, 0);
870 }
871
872 /**
873 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_019.
874 * @tc.desc: Audio adapter unittest.
875 * @tc.type: FUNC.
876 * @tc.require:AR000I7I7N
877 */
878 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_019, TestSize.Level1)
879 {
880 g_audioCapturer = std::make_shared<AudioCapturerAdapterImpl>();
881 ASSERT_NE(g_audioCapturer, nullptr);
882
883 std::shared_ptr<AudioCapturerReadCallbackAdapter> callback = std::make_shared<AudioCapturerCallbackMock>();
884 int32_t retNum = g_audioCapturer->SetCapturerReadCallback(callback);
885 EXPECT_EQ(retNum, AudioAdapterCode::AUDIO_NULL_ERROR);
886 retNum = g_audioCapturer->SetCapturerReadCallback(nullptr);
887 EXPECT_EQ(retNum, AudioAdapterCode::AUDIO_NULL_ERROR);
888
889 bool ret = g_audioCapturer->Start();
890 EXPECT_NE(ret, TRUE_OK);
891
892 std::shared_ptr<BufferDescAdapterMock> bufferDesc = std::make_shared<BufferDescAdapterMock>();
893 EXPECT_NE(bufferDesc, nullptr);
894 retNum = g_audioCapturer->GetBufferDesc(bufferDesc);
895 EXPECT_EQ(retNum, AudioAdapterCode::AUDIO_NULL_ERROR);
896
897 retNum = g_audioCapturer->Enqueue(bufferDesc);
898 EXPECT_EQ(retNum, AudioAdapterCode::AUDIO_NULL_ERROR);
899
900 uint32_t frameCount = 0;
901 retNum = g_audioCapturer->GetFrameCount(frameCount);
902 EXPECT_EQ(retNum, AudioAdapterCode::AUDIO_NULL_ERROR);
903
904 int64_t result = g_audioCapturer->GetAudioTime();
905 EXPECT_EQ(result, AudioAdapterCode::AUDIO_NULL_ERROR);
906
907 ret = g_audioCapturer->Stop();
908 EXPECT_NE(ret, TRUE_OK);
909
910 ret = g_audioCapturer->Release();
911 EXPECT_NE(ret, TRUE_OK);
912 }
913
914 /**
915 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_020.
916 * @tc.desc: Audio adapter unittest.
917 * @tc.type: FUNC.
918 * @tc.require:AR000I7I7N
919 */
920 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_020, TestSize.Level1)
921 {
922 auto callback = std::make_shared<AudioCapturerCallbackMock>();
923 auto callbackTest = std::make_shared<AudioCapturerReadCallbackImpl>(callback);
924 EXPECT_NE(callbackTest, nullptr);
925
926 size_t length = 0;
927 callbackTest->OnReadData(length);
928
929 auto callbackTestNull = std::make_shared<AudioCapturerReadCallbackImpl>(nullptr);
930 EXPECT_EQ(callbackTestNull->cb_, nullptr);
931 callbackTest->OnReadData(length);
932 callbackTest->cb_ = nullptr;
933 callbackTest->OnReadData(length);
934 }
935
936 /**
937 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_0021.
938 * @tc.desc: Audio adapter unittest.
939 * @tc.type: FUNC.
940 * @tc.require:AR000I7I7N
941 */
942 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_021, TestSize.Level1)
943 {
944 std::array<AudioAdapterSamplingRate, 11> samplingArray = {
945 AudioAdapterSamplingRate::SAMPLE_RATE_8000,
946 AudioAdapterSamplingRate::SAMPLE_RATE_11025,
947 AudioAdapterSamplingRate::SAMPLE_RATE_12000,
948 AudioAdapterSamplingRate::SAMPLE_RATE_16000,
949 AudioAdapterSamplingRate::SAMPLE_RATE_22050,
950 AudioAdapterSamplingRate::SAMPLE_RATE_24000,
951 AudioAdapterSamplingRate::SAMPLE_RATE_32000,
952 AudioAdapterSamplingRate::SAMPLE_RATE_44100,
953 AudioAdapterSamplingRate::SAMPLE_RATE_48000,
954 AudioAdapterSamplingRate::SAMPLE_RATE_64000,
955 AudioAdapterSamplingRate::SAMPLE_RATE_96000,
956 };
957 for (auto& sampling : samplingArray)
958 AudioCapturerAdapterImpl::GetAudioSamplingRate(sampling);
959
960 AudioSamplingRate testSampling =
961 AudioCapturerAdapterImpl::GetAudioSamplingRate(static_cast<AudioAdapterSamplingRate>(0));
962 EXPECT_EQ(testSampling, AudioSamplingRate::SAMPLE_RATE_44100);
963 }
964
965 /**
966 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_022.
967 * @tc.desc: Audio adapter unittest.
968 * @tc.type: FUNC.
969 * @tc.require:AR000I7I7N
970 */
971 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_022, TestSize.Level1)
972 {
973 AudioCapturerAdapterImpl::GetAudioEncodingType(AudioAdapterEncodingType::ENCODING_PCM);
974 AudioCapturerAdapterImpl::GetAudioEncodingType(AudioAdapterEncodingType::ENCODING_INVALID);
975
976 AudioEncodingType testEncodingType =
977 AudioCapturerAdapterImpl::GetAudioEncodingType(static_cast<AudioAdapterEncodingType>(1));
978 EXPECT_EQ(testEncodingType, AudioEncodingType::ENCODING_INVALID);
979 }
980
981 /**
982 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_023.
983 * @tc.desc: Audio adapter unittest.
984 * @tc.type: FUNC.
985 * @tc.require:AR000I7I7N
986 */
987 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_023, TestSize.Level1)
988 {
989 std::array<AudioAdapterSampleFormat, 6> formatArray = {
990 AudioAdapterSampleFormat::SAMPLE_U8,
991 AudioAdapterSampleFormat::SAMPLE_S16LE,
992 AudioAdapterSampleFormat::SAMPLE_S24LE,
993 AudioAdapterSampleFormat::SAMPLE_S32LE,
994 AudioAdapterSampleFormat::SAMPLE_F32LE,
995 AudioAdapterSampleFormat::INVALID_WIDTH,
996 };
997 for (auto& format : formatArray)
998 AudioCapturerAdapterImpl::GetAudioSampleFormat(format);
999
1000 AudioSampleFormat testFormat =
1001 AudioCapturerAdapterImpl::GetAudioSampleFormat(static_cast<AudioAdapterSampleFormat>(-2));
1002 EXPECT_EQ(testFormat, AudioSampleFormat::INVALID_WIDTH);
1003 }
1004
1005 /**
1006 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_024.
1007 * @tc.desc: Audio adapter unittest.
1008 * @tc.type: FUNC.
1009 * @tc.require:AR000I7I7N
1010 */
1011 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_024, TestSize.Level1)
1012 {
1013 std::array<AudioAdapterChannel, 8> channelArray = {
1014 AudioAdapterChannel::MONO,
1015 AudioAdapterChannel::STEREO,
1016 AudioAdapterChannel::CHANNEL_3,
1017 AudioAdapterChannel::CHANNEL_4,
1018 AudioAdapterChannel::CHANNEL_5,
1019 AudioAdapterChannel::CHANNEL_6,
1020 AudioAdapterChannel::CHANNEL_7,
1021 AudioAdapterChannel::CHANNEL_8,
1022 };
1023 for (auto& channel : channelArray)
1024 AudioCapturerAdapterImpl::GetAudioChannel(channel);
1025
1026 AudioChannel testChannel = AudioCapturerAdapterImpl::GetAudioChannel(static_cast<AudioAdapterChannel>(0));
1027 EXPECT_EQ(testChannel, AudioChannel::STEREO);
1028 }
1029
1030 /**
1031 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_025.
1032 * @tc.desc: Audio adapter unittest.
1033 * @tc.type: FUNC.
1034 * @tc.require:AR000I7I7N
1035 */
1036 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_025, TestSize.Level1)
1037 {
1038 std::array<AudioAdapterSourceType, 6> sourceArray = {
1039 AudioAdapterSourceType::SOURCE_TYPE_INVALID,
1040 AudioAdapterSourceType::SOURCE_TYPE_MIC,
1041 AudioAdapterSourceType::SOURCE_TYPE_VOICE_RECOGNITION,
1042 AudioAdapterSourceType::SOURCE_TYPE_VOICE_COMMUNICATION,
1043 AudioAdapterSourceType::SOURCE_TYPE_ULTRASONIC,
1044 };
1045 for (auto& source : sourceArray)
1046 AudioCapturerAdapterImpl::GetAudioSourceType(source);
1047
1048 SourceType testSource = AudioCapturerAdapterImpl::GetAudioSourceType(static_cast<AudioAdapterSourceType>(-2));
1049 EXPECT_EQ(testSource, SourceType::SOURCE_TYPE_VOICE_RECOGNITION);
1050 }
1051
1052 /**
1053 * @tc.name: NWebAudioAdapterTest_Create_026.
1054 * @tc.desc: Audio adapter unittest.
1055 * @tc.type: FUNC.
1056 * @tc.require:AR000I7I7N
1057 */
1058 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_Create_026, TestSize.Level1)
1059 {
1060 auto audioCapturer = std::make_shared<AudioCapturerAdapterImpl>();
1061 ASSERT_NE(audioCapturer, nullptr);
1062 std::shared_ptr<AudioCapturerOptionsAdapterMock> capturerOptions =
1063 std::make_shared<AudioCapturerOptionsAdapterMock>();
1064 EXPECT_NE(capturerOptions, nullptr);
1065 capturerOptions->samplingRate = AudioAdapterSamplingRate::SAMPLE_RATE_48000;
1066 capturerOptions->encoding = AudioAdapterEncodingType::ENCODING_PCM;
1067 capturerOptions->format = AudioAdapterSampleFormat::SAMPLE_S16LE;
1068 capturerOptions->channels = AudioAdapterChannel::STEREO;
1069 capturerOptions->sourceType = AudioAdapterSourceType::SOURCE_TYPE_VOICE_COMMUNICATION;
1070 capturerOptions->capturerFlags = 0;
1071 int32_t retNum = audioCapturer->Create(capturerOptions);
1072 ASSERT_NE(retNum, AudioAdapterCode::AUDIO_OK);
1073 }
1074
1075 /**
1076 * @tc.name: NWebAudioAdapterTest_OnDeviceChange_027.
1077 * @tc.desc: Audio adapter unittest.
1078 * @tc.type: FUNC.
1079 * @tc.require:AR000I7I7N
1080 */
1081 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_OnDeviceChange_027, TestSize.Level1)
1082 {
1083 auto mock = std::make_shared<AudioManagerDeviceChangeCallbackAdapterMock>();
1084 ASSERT_NE(mock, nullptr);
1085 auto callbackAdapter = std::make_shared<AudioManagerDeviceChangeCallbackAdapterImpl>(mock);
1086 ASSERT_NE(callbackAdapter, nullptr);
1087 DeviceChangeAction deviceChangeAction = { .type = DeviceChangeType::CONNECT,
1088 .flag = DeviceFlag::NONE_DEVICES_FLAG };
1089 callbackAdapter->OnDeviceChange(deviceChangeAction);
1090 callbackAdapter->cb_ = nullptr;
1091 callbackAdapter->OnDeviceChange(deviceChangeAction);
1092 }
1093
1094 /**
1095 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_028.
1096 * @tc.desc: Audio adapter unittest.
1097 * @tc.type: FUNC.
1098 * @tc.require:I5HRX9
1099 */
1100 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_AudioAdapterImpl_028, TestSize.Level1)
1101 {
1102 std::string deviceName = AudioSystemManagerAdapterImpl::GetInstance().GetDeviceName(DeviceType::DEVICE_TYPE_NONE);
1103 EXPECT_EQ(deviceName, DEVICE_TYPE_NONE_ZH_CN_TEST);
1104 bool ret = AudioSystemManagerAdapterImpl::GetInstance().SetLanguage(LANGUAGE_EN);
1105 EXPECT_EQ(ret, TRUE_OK);
1106 deviceName = AudioSystemManagerAdapterImpl::GetInstance().GetDeviceName(DeviceType::DEVICE_TYPE_NONE);
1107 EXPECT_EQ(deviceName, DEVICE_TYPE_NONE_TEST);
1108 }
1109
1110 /**
1111 * @tc.name: NWebAudioAdapterTest_AudioAdapterImpl_029.
1112 * @tc.desc: Audio adapter unittest.
1113 * @tc.type: FUNC.
1114 * @tc.require:I5HRX9
1115 */
1116 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_GetChangeReason_029, TestSize.Level1)
1117 {
1118 std::array<AudioStreamDeviceChangeReason, 5> reasonArray = {
1119 AudioStreamDeviceChangeReason::UNKNOWN,
1120 AudioStreamDeviceChangeReason::NEW_DEVICE_AVAILABLE,
1121 AudioStreamDeviceChangeReason::OLD_DEVICE_UNAVALIABLE,
1122 AudioStreamDeviceChangeReason::OVERRODE,
1123 };
1124
1125 std::shared_ptr<AudioOutputChangeCallbackAdapter> cb = std::make_shared<AudioOutputChangeCallbackMock>();
1126 EXPECT_NE(cb, nullptr);
1127 auto callBack = std::make_shared<AudioOutputChangeCallbackImpl>(cb);
1128 EXPECT_NE(callBack, nullptr);
1129
1130 for (auto& reason : reasonArray)
1131 callBack->GetChangeReason(reason);
1132
1133 AudioAdapterDeviceChangeReason testReason = callBack->GetChangeReason(
1134 static_cast<AudioStreamDeviceChangeReason>(-1)
1135 );
1136 EXPECT_EQ(testReason, AudioAdapterDeviceChangeReason::UNKNOWN);
1137 }
1138
1139 /**
1140 * @tc.name: NWebAudioAdapterTest_GetChangeReason_030.
1141 * @tc.desc: Audio adapter unittest.
1142 * @tc.type: FUNC.
1143 * @tc.require:I5HRX9
1144 */
1145 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_OnOutputDeviceChange_030, TestSize.Level1)
1146 {
1147 std::shared_ptr<AudioOutputChangeCallbackAdapter> cb = std::make_shared<AudioOutputChangeCallbackMock>();
1148 EXPECT_NE(cb, nullptr);
1149 auto callBack = std::make_shared<AudioOutputChangeCallbackImpl>(cb);
1150 ASSERT_NE(callBack, nullptr);
1151
1152 DeviceInfo deviceInfo;
1153
1154 AudioStreamDeviceChangeReason reason = AudioStreamDeviceChangeReason::UNKNOWN;
1155 callBack->OnOutputDeviceChange(deviceInfo, reason);
1156
1157 reason = AudioStreamDeviceChangeReason::NEW_DEVICE_AVAILABLE;
1158 callBack->OnOutputDeviceChange(deviceInfo, reason);
1159
1160 reason = AudioStreamDeviceChangeReason::OLD_DEVICE_UNAVALIABLE;
1161 callBack->OnOutputDeviceChange(deviceInfo, reason);
1162
1163 reason = AudioStreamDeviceChangeReason::OVERRODE;
1164 callBack->OnOutputDeviceChange(deviceInfo, reason);
1165
1166 reason = static_cast<AudioStreamDeviceChangeReason>(-1);
1167 callBack->OnOutputDeviceChange(deviceInfo, reason);
1168
1169 callBack->cb_ = nullptr;
1170 callBack->OnOutputDeviceChange(deviceInfo, reason);
1171 }
1172
1173 /**
1174 * @tc.name: NWebAudioAdapterTest_SetAudioOutputChangeCallback_031.
1175 * @tc.desc: Audio adapter unittest.
1176 * @tc.type: FUNC.
1177 * @tc.require:I5HRX9
1178 */
1179 HWTEST_F(NWebAudioAdapterTest, NWebAudioAdapterTest_SetAudioOutputChangeCallback_031, TestSize.Level1)
1180 {
1181 auto audioOutputChange = std::make_shared<AudioRendererAdapterImpl>();
1182 ASSERT_NE(audioOutputChange, nullptr);
1183 int32_t retNum = audioOutputChange->SetAudioOutputChangeCallback(nullptr);
1184 EXPECT_NE(retNum, 0);
1185
1186 std::shared_ptr<AudioOutputChangeCallbackAdapter> callback = std::make_shared<AudioOutputChangeCallbackMock>();
1187 ASSERT_NE(callback, nullptr);
1188 retNum = audioOutputChange->SetAudioOutputChangeCallback(callback);
1189 EXPECT_NE(retNum, 0);
1190
1191 AudioRendererOptions rendererOptions;
1192 AudioRendererInfo renderInfo;
1193 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
1194 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
1195 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
1196 rendererOptions.streamInfo.channels = AudioChannel::STEREO;
1197 rendererOptions.rendererInfo = renderInfo;
1198 audioOutputChange->audio_renderer_ = AudioRenderer::Create(rendererOptions);
1199 ASSERT_NE(audioOutputChange->audio_renderer_, nullptr);
1200
1201 retNum = audioOutputChange->SetAudioOutputChangeCallback(callback);
1202 EXPECT_EQ(retNum, 0);
1203 }
1204
1205 } // namespace NWeb
1206 } // namespace OHOS
1207