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