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