1 /*
2 * Copyright (c) 2023-2025 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 <gtest/gtest.h>
17 #include "iservice_registry.h"
18 #include "system_ability_definition.h"
19
20 #include "audio_service.h"
21 #include "audio_service_log.h"
22 #include "audio_errors.h"
23 #include "audio_system_manager.h"
24
25 #include "audio_manager_proxy.h"
26 #include "audio_manager_listener_stub.h"
27 #include "audio_process_proxy.h"
28 #include "audio_process_in_client.h"
29 #include "fast_audio_stream.h"
30
31 using namespace testing::ext;
32
33 namespace OHOS {
34 namespace AudioStandard {
35 std::unique_ptr<AudioManagerProxy> audioManagerProxy;
36 std::shared_ptr<AudioProcessInClient> processClient_;
37 std::shared_ptr<FastAudioStream> fastAudioStream_;
38 const int32_t TEST_RET_NUM = 0;
39 const int32_t RENDERER_FLAGS = 0;
40 #ifdef HAS_FEATURE_INNERCAPTURER
41 const int32_t MEDIA_SERVICE_UID = 1013;
42 #endif
43 constexpr int32_t ERROR_62980101 = -62980101;
44
45
46 class AudioServiceUnitTest : public testing::Test {
47 public:
48 static void SetUpTestCase(void);
49 static void TearDownTestCase(void);
50 void SetUp();
51 void TearDown();
52 };
53
54 class AudioParameterCallbackTest : public AudioParameterCallback {
OnAudioParameterChange(const std::string networkId,const AudioParamKey key,const std::string & condition,const std::string & value)55 virtual void OnAudioParameterChange(const std::string networkId, const AudioParamKey key,
56 const std::string& condition, const std::string& value) {}
57 };
58
SetUpTestCase(void)59 void AudioServiceUnitTest::SetUpTestCase(void)
60 {
61 // input testsuit setup step，setup invoked before all testcases
62 }
63
TearDownTestCase(void)64 void AudioServiceUnitTest::TearDownTestCase(void)
65 {
66 // input testsuit teardown step，teardown invoked after all testcases
67 }
68
SetUp(void)69 void AudioServiceUnitTest::SetUp(void)
70 {
71 // input testcase setup step，setup invoked before each testcases
72 }
73
TearDown(void)74 void AudioServiceUnitTest::TearDown(void)
75 {
76 // input testcase teardown step，teardown invoked after each testcases
77 }
78
79 /**
80 * @tc.name : Test AudioProcessProxy API
81 * @tc.type : FUNC
82 * @tc.number: AudioProcessProxy_001
83 * @tc.desc : Test AudioProcessProxy interface.
84 */
85 HWTEST(AudioServiceUnitTest, AudioProcessProxy_001, TestSize.Level1)
86 {
87 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
88 EXPECT_NE(nullptr, samgr);
89 sptr<IRemoteObject> object = samgr->GetSystemAbility(AUDIO_DISTRIBUTED_SERVICE_ID);
90 EXPECT_NE(nullptr, object);
91 std::unique_ptr<AudioProcessProxy> audioProcessProxy = std::make_unique<AudioProcessProxy>(object);
92
93 int32_t ret = -1;
94 std::shared_ptr<OHAudioBuffer> buffer;
95 uint32_t spanSizeInFrame = 1000;
96 uint32_t totalSizeInFrame = spanSizeInFrame - 1;
97 uint32_t byteSizePerFrame = 1000;
98 buffer = OHAudioBuffer::CreateFromLocal(totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
99
100 ret=audioProcessProxy->ResolveBuffer(buffer);
101 EXPECT_LT(ret, TEST_RET_NUM);
102
103 ret = audioProcessProxy->Start();
104 EXPECT_LT(ret, TEST_RET_NUM);
105
106 bool isFlush = true;
107 ret = audioProcessProxy->Pause(isFlush);
108 EXPECT_LT(ret, TEST_RET_NUM);
109
110 ret = audioProcessProxy->Resume();
111 EXPECT_LT(ret, TEST_RET_NUM);
112
113 ret = audioProcessProxy->Stop();
114 EXPECT_LT(ret, TEST_RET_NUM);
115
116 ret = audioProcessProxy->RequestHandleInfo();
117 EXPECT_EQ(ret, SUCCESS);
118
119 ret = audioProcessProxy->Release();
120 EXPECT_LT(ret, TEST_RET_NUM);
121 }
122
123 /**
124 * @tc.name : Test AudioManagerProxy API
125 * @tc.type : FUNC
126 * @tc.number: AudioManagerProxy_001
127 * @tc.desc : Test AudioManagerProxy interface.
128 */
129 HWTEST(AudioServiceUnitTest, AudioManagerProxy_001, TestSize.Level1)
130 {
131 int32_t ret = -1;
132
133 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
134 EXPECT_NE(nullptr, samgr);
135 sptr<IRemoteObject> object = samgr->GetSystemAbility(AUDIO_DISTRIBUTED_SERVICE_ID);
136 EXPECT_NE(nullptr, object);
137
138 audioManagerProxy = std::make_unique<AudioManagerProxy>(object);
139
140 bool isMute = true;
141 ret = audioManagerProxy->SetMicrophoneMute(isMute);
142 if (ret == ERR_PERMISSION_DENIED) {
143 return ;
144 }
145 EXPECT_EQ(ret, SUCCESS);
146
147 ret = audioManagerProxy->RegiestPolicyProvider(object);
148 EXPECT_EQ(SUCCESS, ret);
149
150 EXPECT_TRUE(ret == ERROR_62980101 || ret == SUCCESS);
151
152 bool result = audioManagerProxy->CreatePlaybackCapturerManager();
153 EXPECT_EQ(result, true);
154
155 int32_t deviceType = 1;
156 std::string sinkName = "test";
157 audioManagerProxy->SetOutputDeviceSink(deviceType, sinkName);
158 }
159
160 /**
161 * @tc.name : Test AudioManagerProxy API
162 * @tc.type : FUNC
163 * @tc.number: AudioManagerProxy_002
164 * @tc.desc : Test AudioManagerProxy interface.
165 */
166 HWTEST(AudioServiceUnitTest, AudioManagerProxy_002, TestSize.Level1)
167 {
168 int32_t ret = -1;
169
170 float volume = 0.1;
171 ret = audioManagerProxy->SetVoiceVolume(volume);
172
173 const std::string networkId = "LocalDevice";
174 const AudioParamKey key = AudioParamKey::VOLUME;
175 AudioVolumeType volumeType =AudioVolumeType::STREAM_MEDIA;
176 int32_t groupId = 0;
177 std::string condition = "EVENT_TYPE=1;VOLUME_GROUP_ID=" + std::to_string(groupId) + ";AUDIO_VOLUME_TYPE="
178 + std::to_string(volumeType) + ";";
179 std::string value = std::to_string(volume);
180 audioManagerProxy->SetAudioParameter(networkId, key, condition, value);
181 const std::string retStr = audioManagerProxy->GetAudioParameter(networkId, key, condition);
182 EXPECT_NE(retStr, value);
183
184 bool connected = true;
185 audioManagerProxy->NotifyDeviceInfo(networkId, connected);
186 ret = audioManagerProxy->CheckRemoteDeviceState(networkId, DeviceRole::OUTPUT_DEVICE, true);
187 EXPECT_LT(ret, TEST_RET_NUM);
188 }
189
190 /**
191 * @tc.name : Test AudioManagerProxy API
192 * @tc.type : FUNC
193 * @tc.number: AudioManagerProxy_004
194 * @tc.desc : Test AudioManagerProxy interface.
195 */
196 HWTEST(AudioServiceUnitTest, AudioManagerProxy_004, TestSize.Level1)
197 {
198 std::vector<Library> libraries;
199 Library library = {};
200 library.name = "testname";
201 library.path ="test.so";
202 libraries.push_back(library);
203
204 std::vector<Effect> effects;
205 Effect effect = {};
206 effect.name = "test";
207 effect.libraryName = "test";
208 effects.push_back(effect);
209
210 std::vector<Effect> successEffects;
211 bool ret = audioManagerProxy->LoadAudioEffectLibraries(libraries, effects, successEffects);
212 EXPECT_EQ(ret, false);
213 }
214
215 /**
216 * @tc.name : Test AudioManagerListenerStub API
217 * @tc.type : FUNC
218 * @tc.number: AudioManagerListenerStub_001
219 * @tc.desc : Test AudioManagerListenerStub interface.
220 */
221 HWTEST(AudioServiceUnitTest, AudioManagerListenerStub_001, TestSize.Level1)
222 {
223 std::unique_ptr<AudioManagerListenerStub> audioManagerListenerStub = std::make_unique<AudioManagerListenerStub>();
224
225 const std::weak_ptr<AudioParameterCallback> callback = std::make_shared<AudioParameterCallbackTest>();
226 audioManagerListenerStub->SetParameterCallback(callback);
227 float volume = 0.1;
228 const std::string networkId = "LocalDevice";
229 const AudioParamKey key = AudioParamKey::VOLUME;
230 AudioVolumeType volumeType =AudioVolumeType::STREAM_MEDIA;
231 int32_t groupId = 0;
232 std::string condition = "EVENT_TYPE=1;VOLUME_GROUP_ID=" + std::to_string(groupId) + ";AUDIO_VOLUME_TYPE="
233 + std::to_string(volumeType) + ";";
234 std::string value = std::to_string(volume);
235 audioManagerListenerStub->OnAudioParameterChange(networkId, key, condition, value);
236 EXPECT_NE(value, "");
237 }
238
239
240 /**
241 * @tc.name : Test AudioProcessInClientInner API
242 * @tc.type : FUNC
243 * @tc.number: AudioProcessInClientInner_001
244 * @tc.desc : Test AudioProcessInClientInner interface using unsupported parameters.
245 */
246 HWTEST(AudioServiceUnitTest, AudioProcessInClientInner_001, TestSize.Level1)
247 {
248 AudioProcessConfig config;
249 config.appInfo.appPid = getpid();
250 config.appInfo.appUid = getuid();
251
252 config.audioMode = AUDIO_MODE_PLAYBACK;
253
254 config.rendererInfo.contentType = CONTENT_TYPE_MUSIC;
255 config.rendererInfo.streamUsage = STREAM_USAGE_MEDIA;
256 config.rendererInfo.rendererFlags = RENDERER_FLAGS;
257
258 config.streamInfo.channels = STEREO;
259 config.streamInfo.encoding = ENCODING_PCM;
260 config.streamInfo.format = SAMPLE_S16LE;
261 config.streamInfo.samplingRate = SAMPLE_RATE_64000;
262
263 fastAudioStream_ = std::make_shared<FastAudioStream>(config.streamType,
264 AUDIO_MODE_PLAYBACK, config.appInfo.appUid);
265 processClient_ = AudioProcessInClient::Create(config, fastAudioStream_);
266 EXPECT_EQ(processClient_, nullptr);
267 }
268
269 /**
270 * @tc.name : Test AudioDeviceDescriptor API
271 * @tc.type : FUNC
272 * @tc.number: AudioDeviceDescriptor_001
273 * @tc.desc : Test AudioDeviceDescriptor interface.
274 */
275 HWTEST(AudioServiceUnitTest, AudioDeviceDescriptor_001, TestSize.Level1)
276 {
277 DeviceType type = DeviceType::DEVICE_TYPE_SPEAKER;
278 DeviceRole role = DeviceRole::OUTPUT_DEVICE;
279 int32_t interruptGroupId = 1;
280 int32_t volumeGroupId = 1;
281 std::string networkId = "LocalDevice";
282 std::shared_ptr<AudioDeviceDescriptor> audioDeviceDescriptor =
283 std::make_shared<AudioDeviceDescriptor>(type, role, interruptGroupId, volumeGroupId, networkId);
284 EXPECT_NE(audioDeviceDescriptor, nullptr);
285
286 AudioDeviceDescriptor deviceDescriptor;
287 deviceDescriptor.deviceType_ = type;
288 deviceDescriptor.deviceRole_ = role;
289 audioDeviceDescriptor = std::make_shared<AudioDeviceDescriptor>(deviceDescriptor);
290 EXPECT_NE(audioDeviceDescriptor, nullptr);
291
292 std::string deviceName = "";
293 std::string macAddress = "";
294 audioDeviceDescriptor->SetDeviceInfo(deviceName, macAddress);
295
296 DeviceStreamInfo audioStreamInfo = {
297 SAMPLE_RATE_48000,
298 ENCODING_PCM,
299 SAMPLE_S16LE,
300 STEREO
301 };
302 int32_t channelMask = 1;
303 audioDeviceDescriptor->SetDeviceCapability(audioStreamInfo, channelMask);
304
305 DeviceStreamInfo streamInfo = audioDeviceDescriptor->audioStreamInfo_;
306 EXPECT_EQ(streamInfo.channels, audioStreamInfo.channels);
307 EXPECT_EQ(streamInfo.encoding, audioStreamInfo.encoding);
308 EXPECT_EQ(streamInfo.format, audioStreamInfo.format);
309 EXPECT_EQ(streamInfo.samplingRate, audioStreamInfo.samplingRate);
310 }
311
312 /**
313 * @tc.name : Test UpdateMuteControlSet API
314 * @tc.type : FUNC
315 * @tc.number: AudioServiceUpdateMuteControlSet_001
316 * @tc.desc : Test UpdateMuteControlSet interface.
317 */
318 HWTEST(AudioServiceUnitTest, AudioServiceUpdateMuteControlSet_001, TestSize.Level1)
319 {
320 AudioService::GetInstance()->UpdateMuteControlSet(1, true);
321 AudioService::GetInstance()->UpdateMuteControlSet(MAX_STREAMID + 1, true);
322 AudioService::GetInstance()->UpdateMuteControlSet(MAX_STREAMID - 1, false);
323 AudioService::GetInstance()->UpdateMuteControlSet(MAX_STREAMID - 1, true);
324 AudioService::GetInstance()->UpdateMuteControlSet(MAX_STREAMID - 1, false);
325 AudioService::GetInstance()->UpdateMuteControlSet(MAX_STREAMID - 1, true);
326 AudioService::GetInstance()->RemoveIdFromMuteControlSet(MAX_STREAMID - 1);
327 }
328
329 #ifdef HAS_FEATURE_INNERCAPTURER
330 /**
331 * @tc.name : Test ShouldBeInnerCap API
332 * @tc.type : FUNC
333 * @tc.number: AudioServiceShouldBeInnerCap_001
334 * @tc.desc : Test ShouldBeInnerCap interface.
335 */
336 HWTEST(AudioServiceUnitTest, AudioServiceShouldBeInnerCap_001, TestSize.Level1)
337 {
338 AudioProcessConfig config = {};
339 config.privacyType = AudioPrivacyType::PRIVACY_TYPE_PUBLIC;
340 bool ret = AudioService::GetInstance()->ShouldBeInnerCap(config, 0);
341 EXPECT_FALSE(ret);
342 config.privacyType = AudioPrivacyType::PRIVACY_TYPE_PRIVATE;
343 ret = AudioService::GetInstance()->ShouldBeInnerCap(config, 0);
344 EXPECT_FALSE(ret);
345 }
346
347 /**
348 * @tc.name : Test ShouldBeDualTone API
349 * @tc.type : FUNC
350 * @tc.number: AudioServiceShouldBeDualTone_001
351 * @tc.desc : Test ShouldBeDualTone interface.
352 */
353 HWTEST(AudioServiceUnitTest, AudioServiceShouldBeDualTone_001, TestSize.Level1)
354 {
355 AudioProcessConfig config = {};
356 config.audioMode = AUDIO_MODE_RECORD;
357 config.rendererInfo.streamUsage = STREAM_USAGE_ALARM;
358 bool ret = AudioService::GetInstance()->ShouldBeDualTone(config);
359 EXPECT_FALSE(ret);
360 config.audioMode = AUDIO_MODE_PLAYBACK;
361 ret = AudioService::GetInstance()->ShouldBeDualTone(config);
362 EXPECT_FALSE(ret);
363 }
364
365 /**
366 * @tc.name : Test OnInitInnerCapList API
367 * @tc.type : FUNC
368 * @tc.number: AudioServiceOnInitInnerCapList_001
369 * @tc.desc : Test OnInitInnerCapList interface.
370 */
371 HWTEST(AudioServiceUnitTest, AudioServiceOnInitInnerCapList_001, TestSize.Level1)
372 {
373 int32_t floatRet = 0;
374
375 AudioService::GetInstance()->OnInitInnerCapList(1);
376 AudioService::GetInstance()->ResetAudioEndpoint();
377 floatRet = AudioService::GetInstance()->GetMaxAmplitude(true);
378 EXPECT_EQ(0, floatRet);
379
380 AudioProcessConfig config = {};
381 config.privacyType = AudioPrivacyType::PRIVACY_TYPE_PUBLIC;
382 AudioService::GetInstance()->GetAudioProcess(config);
383 AudioService::GetInstance()->OnInitInnerCapList(1);
384 AudioService::GetInstance()->workingConfig_.filterOptions.usages.emplace_back(STREAM_USAGE_MEDIA);
385 AudioService::GetInstance()->OnInitInnerCapList(1);
386
387 AudioService::GetInstance()->workingConfig_.filterOptions.pids.emplace_back(1);
388 AudioService::GetInstance()->OnInitInnerCapList(1);
389 AudioService::GetInstance()->OnUpdateInnerCapList(1);
390 EXPECT_EQ(0, floatRet);
391 config = {};
392 config.privacyType = AudioPrivacyType::PRIVACY_TYPE_PRIVATE;
393 config.audioMode = AUDIO_MODE_RECORD;
394 AudioService::GetInstance()->GetAudioProcess(config);
395
396 AudioService::GetInstance()->OnInitInnerCapList(1);
397 floatRet = AudioService::GetInstance()->GetMaxAmplitude(true);
398 EXPECT_EQ(0, floatRet);
399 floatRet = AudioService::GetInstance()->GetMaxAmplitude(false);
400 EXPECT_EQ(0, floatRet);
401 int32_t ret = AudioService::GetInstance()->EnableDualToneList(MAX_STREAMID - 1);
402 EXPECT_EQ(SUCCESS, ret);
403 ret = AudioService::GetInstance()->DisableDualToneList(MAX_STREAMID - 1);
404 EXPECT_EQ(SUCCESS, ret);
405 AudioService::GetInstance()->ResetAudioEndpoint();
406 }
407
408 /**
409 * @tc.name : Test IsEndpointTypeVoip API
410 * @tc.type : FUNC
411 * @tc.number: AudioServiceIsEndpointTypeVoip_001
412 * @tc.desc : Test IsEndpointTypeVoip interface.
413 */
414 HWTEST(AudioServiceUnitTest, AudioServiceIsEndpointTypeVoip_001, TestSize.Level1)
415 {
416 AudioProcessConfig config = {};
417 AudioDeviceDescriptor info(AudioDeviceDescriptor::DEVICE_INFO);
418 config.rendererInfo.streamUsage = STREAM_USAGE_INVALID;
419 config.capturerInfo.sourceType = SOURCE_TYPE_VOICE_COMMUNICATION;
420 config.rendererInfo.originalFlag = AUDIO_FLAG_VOIP_FAST;
421 bool ret = AudioService::GetInstance()->IsEndpointTypeVoip(config, info);
422 EXPECT_EQ(true, ret);
423
424 config.capturerInfo.sourceType = SOURCE_TYPE_INVALID;
425 ret = AudioService::GetInstance()->IsEndpointTypeVoip(config, info);
426 EXPECT_FALSE(ret);
427
428 config.rendererInfo.streamUsage = STREAM_USAGE_VIDEO_COMMUNICATION;
429 ret = AudioService::GetInstance()->IsEndpointTypeVoip(config, info);
430 EXPECT_TRUE(ret);
431
432 config.rendererInfo.streamUsage = STREAM_USAGE_VOICE_COMMUNICATION;
433 ret = AudioService::GetInstance()->IsEndpointTypeVoip(config, info);
434 EXPECT_TRUE(ret);
435 }
436
437 /**
438 * @tc.name : Test GetCapturerBySessionID API
439 * @tc.type : FUNC
440 * @tc.number: AudioServiceGetCapturerBySessionID_001
441 * @tc.desc : Test GetCapturerBySessionID interface.
442 */
443 HWTEST(AudioServiceUnitTest, AudioServiceGetCapturerBySessionID_001, TestSize.Level1)
444 {
445 AudioProcessConfig config = {};
446 config.audioMode = AUDIO_MODE_RECORD;
447 config.streamInfo.channels = STEREO;
448 config.streamInfo.channelLayout = CH_LAYOUT_STEREO;
449 config.streamType = STREAM_MUSIC;
450
451 int32_t result;
452 AudioService::GetInstance()->RemoveCapturer(-1);
453 sptr<OHOS::AudioStandard::IpcStreamInServer> server = AudioService::GetInstance()->GetIpcStream(config, result);
454 EXPECT_EQ(server, nullptr);
455
456 auto ret = AudioService::GetInstance()->GetCapturerBySessionID(0);
457 EXPECT_EQ(nullptr, ret);
458 }
459
460 /**
461 * @tc.name : Test ShouldBeDualTone API
462 * @tc.type : FUNC
463 * @tc.number: AudioServiceShouldBeDualTone_002
464 * @tc.desc : Test ShouldBeDualTone interface.
465 */
466 HWTEST(AudioServiceUnitTest, AudioServiceShouldBeDualTone_002, TestSize.Level1)
467 {
468 AudioProcessConfig config = {};
469 config.audioMode = AUDIO_MODE_RECORD;
470 bool ret;
471 ret = AudioService::GetInstance()->ShouldBeDualTone(config);
472 EXPECT_EQ(ret, false);
473 config.audioMode = AUDIO_MODE_PLAYBACK;
474 config.rendererInfo.streamUsage = STREAM_USAGE_RINGTONE;
475 ret = AudioService::GetInstance()->ShouldBeDualTone(config);
476 EXPECT_FALSE(ret);
477 }
478
479 /**
480 * @tc.name : Test FilterAllFastProcess API
481 * @tc.type : FUNC
482 * @tc.number: AudioServiceFilterAllFastProcess_001
483 * @tc.desc : Test FilterAllFastProcess interface.
484 */
485 HWTEST(AudioServiceUnitTest, AudioServiceFilterAllFastProcess_001, TestSize.Level1)
486 {
487 int32_t floatRet = 0;
488 AudioService::GetInstance()->FilterAllFastProcess();
489 AudioService::GetInstance()->OnInitInnerCapList(1);
490 AudioService::GetInstance()->ResetAudioEndpoint();
491 floatRet = AudioService::GetInstance()->GetMaxAmplitude(true);
492 EXPECT_EQ(0, floatRet);
493
494 AudioProcessConfig config = {};
495 config.privacyType = AudioPrivacyType::PRIVACY_TYPE_PUBLIC;
496 AudioService::GetInstance()->GetAudioProcess(config);
497 AudioService::GetInstance()->OnInitInnerCapList(1);
498 AudioService::GetInstance()->workingConfig_.filterOptions.usages.emplace_back(STREAM_USAGE_MEDIA);
499 AudioService::GetInstance()->OnInitInnerCapList(1);
500
501 AudioService::GetInstance()->workingConfig_.filterOptions.pids.emplace_back(1);
502 AudioService::GetInstance()->OnInitInnerCapList(1);
503 AudioService::GetInstance()->OnUpdateInnerCapList(1);
504 EXPECT_EQ(0, floatRet);
505 AudioService::GetInstance()->FilterAllFastProcess();
506 }
507
508 /**
509 * @tc.name : Test GetDeviceInfoForProcess API
510 * @tc.type : FUNC
511 * @tc.number: AudioServiceGetDeviceInfoForProcess_001
512 * @tc.desc : Test GetDeviceInfoForProcess interface.
513 */
514 HWTEST(AudioServiceUnitTest, AudioServiceGetDeviceInfoForProcess_001, TestSize.Level1)
515 {
516 AudioProcessConfig config = {};
517 config.audioMode = AUDIO_MODE_PLAYBACK;
518 AudioDeviceDescriptor deviceinfo(AudioDeviceDescriptor::DEVICE_INFO);
519 deviceinfo = AudioService::GetInstance()->GetDeviceInfoForProcess(config);
520 EXPECT_NE(deviceinfo.deviceRole_, INPUT_DEVICE);
521 config.audioMode = AUDIO_MODE_RECORD;
522 deviceinfo = AudioService::GetInstance()->GetDeviceInfoForProcess(config);
523 EXPECT_NE(deviceinfo.deviceRole_, OUTPUT_DEVICE);
524 }
525
526 /**
527 * @tc.name : Test Dump API
528 * @tc.type : FUNC
529 * @tc.number: AudioServiceDump_001
530 * @tc.desc : Test Dump interface.
531 */
532 HWTEST(AudioServiceUnitTest, AudioServiceDump_001, TestSize.Level1)
533 {
534 int32_t floatRet = 0;
535 AudioService::GetInstance()->FilterAllFastProcess();
536 AudioService::GetInstance()->OnInitInnerCapList(1);
537 AudioService::GetInstance()->ResetAudioEndpoint();
538 floatRet = AudioService::GetInstance()->GetMaxAmplitude(true);
539 EXPECT_EQ(0, floatRet);
540
541 AudioProcessConfig config = {};
542 config.privacyType = AudioPrivacyType::PRIVACY_TYPE_PUBLIC;
543 AudioService::GetInstance()->GetAudioProcess(config);
544 AudioService::GetInstance()->OnInitInnerCapList(1);
545 AudioService::GetInstance()->workingConfig_.filterOptions.usages.emplace_back(STREAM_USAGE_MEDIA);
546 AudioService::GetInstance()->OnInitInnerCapList(1);
547
548 AudioService::GetInstance()->workingConfig_.filterOptions.pids.emplace_back(1);
549 AudioService::GetInstance()->OnInitInnerCapList(1);
550 AudioService::GetInstance()->OnUpdateInnerCapList(1);
551 EXPECT_EQ(0, floatRet);
552 std::string dumpString = "This is Dump string";
553 AudioService::GetInstance()->Dump(dumpString);
554 }
555
556 /**
557 * @tc.name : Test SetNonInterruptMute API
558 * @tc.type : FUNC
559 * @tc.number: AudioServiceSetNonInterruptMute_001
560 * @tc.desc : Test SetNonInterruptMute interface.
561 */
562 HWTEST(AudioServiceUnitTest, AudioServiceSetNonInterruptMute_001, TestSize.Level1)
563 {
564 int32_t floatRet = 0;
565 bool muteFlag = true;
566 uint32_t sessionId = 0;
567
568 AudioService::GetInstance()->FilterAllFastProcess();
569 AudioService::GetInstance()->OnInitInnerCapList(1);
570 AudioService::GetInstance()->ResetAudioEndpoint();
571 AudioService::GetInstance()->SetNonInterruptMute(sessionId, muteFlag);
572 floatRet = AudioService::GetInstance()->GetMaxAmplitude(true);
573 EXPECT_EQ(0, floatRet);
574
575 AudioProcessConfig config = {};
576 config.privacyType = AudioPrivacyType::PRIVACY_TYPE_PUBLIC;
577 AudioService::GetInstance()->GetAudioProcess(config);
578 AudioService::GetInstance()->OnInitInnerCapList(1);
579 AudioService::GetInstance()->workingConfig_.filterOptions.usages.emplace_back(STREAM_USAGE_MEDIA);
580 AudioService::GetInstance()->OnInitInnerCapList(1);
581
582 AudioService::GetInstance()->workingConfig_.filterOptions.pids.emplace_back(1);
583 AudioService::GetInstance()->OnInitInnerCapList(1);
584 AudioService::GetInstance()->OnUpdateInnerCapList(1);
585 AudioService::GetInstance()->SetNonInterruptMute(MAX_STREAMID - 1, muteFlag);
586 EXPECT_EQ(0, floatRet);
587 }
588
589 /**
590 * @tc.name : Test OnProcessRelease API
591 * @tc.type : FUNC
592 * @tc.number: AudioServiceOnProcessRelease_001
593 * @tc.desc : Test OnProcessRelease interface.
594 */
595 HWTEST(AudioServiceUnitTest, AudioServiceOnProcessRelease_001, TestSize.Level1)
596 {
597 bool isSwitchStream = false;
598 int32_t floatRet = 0;
599 bool muteFlag = true;
600 uint32_t sessionId = 0;
601
602 AudioService::GetInstance()->FilterAllFastProcess();
603 AudioService::GetInstance()->OnInitInnerCapList(1);
604 AudioService::GetInstance()->ResetAudioEndpoint();
605 AudioService::GetInstance()->SetNonInterruptMute(sessionId, muteFlag);
606 floatRet = AudioService::GetInstance()->GetMaxAmplitude(true);
607 EXPECT_EQ(0, floatRet);
608
609 AudioProcessConfig config = {};
610 config.privacyType = AudioPrivacyType::PRIVACY_TYPE_PUBLIC;
611 AudioDeviceDescriptor deviceInfo(AudioDeviceDescriptor::DEVICE_INFO);
612 sptr<AudioProcessInServer> audioprocess = AudioProcessInServer::Create(config, AudioService::GetInstance());
613 EXPECT_NE(audioprocess, nullptr);
614 audioprocess->Start();
615 AudioService::GetInstance()->GetAudioProcess(config);
616 AudioService::GetInstance()->OnInitInnerCapList(1);
617 AudioService::GetInstance()->workingConfig_.filterOptions.usages.emplace_back(STREAM_USAGE_MEDIA);
618 AudioService::GetInstance()->OnInitInnerCapList(1);
619
620 AudioService::GetInstance()->workingConfig_.filterOptions.pids.emplace_back(1);
621 AudioService::GetInstance()->OnInitInnerCapList(1);
622 AudioService::GetInstance()->OnUpdateInnerCapList(1);
623
624 int32_t ret = 0;
625 ret = AudioService::GetInstance()->OnProcessRelease(audioprocess, isSwitchStream);
626 EXPECT_EQ(ret, 0);
627 }
628
629 /**
630 * @tc.name : Test DelayCallReleaseEndpoint API
631 * @tc.type : FUNC
632 * @tc.number: DelayCallReleaseEndpoint_001
633 * @tc.desc : Test DelayCallReleaseEndpoint interface.
634 */
635 HWTEST(AudioServiceUnitTest, DelayCallReleaseEndpoint_001, TestSize.Level1)
636 {
637 std::string endpointName;
638 int32_t delayInMs = 1;
639 AudioService *audioService = AudioService::GetInstance();
640 audioService->DelayCallReleaseEndpoint(endpointName, delayInMs);
641 }
642
643 /**
644 * @tc.name : Test GetAudioEndpointForDevice API
645 * @tc.type : FUNC
646 * @tc.number: GetAudioEndpointForDevice_001
647 * @tc.desc : Test GetAudioEndpointForDevice interface.
648 */
649 HWTEST(AudioServiceUnitTest, GetAudioEndpointForDevice_001, TestSize.Level1)
650 {
651 AudioService *audioService = AudioService::GetInstance();
652 AudioProcessConfig clientConfig;
653 AudioDeviceDescriptor deviceInfo = audioService->GetDeviceInfoForProcess(clientConfig);
654 bool isVoipStream = true;
655 audioService->GetAudioEndpointForDevice(deviceInfo, clientConfig, isVoipStream);
656 }
657
658 /**
659 * @tc.name : Test Dump API
660 * @tc.type : FUNC
661 * @tc.number: Dump_001
662 * @tc.desc : Test Dump interface.
663 */
664 HWTEST(AudioServiceUnitTest, Dump_001, TestSize.Level1)
665 {
666 std::string dumpString = "abcdefg";
667 AudioService *audioService = AudioService::GetInstance();
668 audioService->Dump(dumpString);
669
670 AudioProcessConfig processConfig;
671
672 std::shared_ptr<StreamListenerHolder> streamListenerHolder =
673 std::make_shared<StreamListenerHolder>();
674
675 std::weak_ptr<IStreamListener> streamListener = streamListenerHolder;
676
677 std::shared_ptr<RendererInServer> rendererInServer =
678 std::make_shared<RendererInServer>(processConfig, streamListener);
679
680 std::shared_ptr<RendererInServer> renderer = rendererInServer;
681
682 audioService->InsertRenderer(1, renderer);
683 audioService->workingConfigs_[1];
684 audioService->Dump(dumpString);
685 audioService->RemoveRenderer(1);
686 }
687
688 /**
689 * @tc.name : Test GetMaxAmplitude API
690 * @tc.type : FUNC
691 * @tc.number: GetMaxAmplitude_001
692 * @tc.desc : Test GetMaxAmplitude interface.
693 */
694 HWTEST(AudioServiceUnitTest, GetMaxAmplitude_001, TestSize.Level1)
695 {
696 AudioService *audioService = AudioService::GetInstance();
697 int ret = audioService->GetMaxAmplitude(true);
698 EXPECT_EQ(0, ret);
699 }
700
701 /**
702 * @tc.name : Test GetCapturerBySessionID API
703 * @tc.type : FUNC
704 * @tc.number: GetCapturerBySessionID_001
705 * @tc.desc : Test GetCapturerBySessionID interface.
706 */
707 HWTEST(AudioServiceUnitTest, GetCapturerBySessionID_001, TestSize.Level1)
708 {
709 uint32_t sessionID = 2;
710 AudioService *audioService = AudioService::GetInstance();
711 std::shared_ptr<CapturerInServer> renderer = nullptr;
712 audioService->InsertCapturer(1, renderer);
713 std::shared_ptr<CapturerInServer> ret = audioService->GetCapturerBySessionID(sessionID);
714 EXPECT_EQ(nullptr, ret);
715 audioService->RemoveCapturer(1);
716 }
717
718 /**
719 * @tc.name : Test GetCapturerBySessionID API
720 * @tc.type : FUNC
721 * @tc.number: GetCapturerBySessionID_002
722 * @tc.desc : Test GetCapturerBySessionID interface.
723 */
724 HWTEST(AudioServiceUnitTest, GetCapturerBySessionID_002, TestSize.Level1)
725 {
726 AudioProcessConfig processConfig;
727
728 std::shared_ptr<StreamListenerHolder> streamListenerHolder =
729 std::make_shared<StreamListenerHolder>();
730
731 std::weak_ptr<IStreamListener> streamListener = streamListenerHolder;
732
733 std::shared_ptr<CapturerInServer> capturerInServer =
734 std::make_shared<CapturerInServer>(processConfig, streamListener);
735
736 std::shared_ptr<CapturerInServer> capturer = capturerInServer;
737 uint32_t sessionID = 1;
738 AudioService *audioService = AudioService::GetInstance();
739 std::shared_ptr<CapturerInServer> renderer = nullptr;
740 audioService->InsertCapturer(1, renderer);
741 std::shared_ptr<CapturerInServer> ret = audioService->GetCapturerBySessionID(sessionID);
742 EXPECT_EQ(nullptr, ret);
743 audioService->RemoveCapturer(1);
744 }
745
746 /**
747 * @tc.name : Test SetNonInterruptMute API
748 * @tc.type : FUNC
749 * @tc.number: SetNonInterruptMute_001
750 * @tc.desc : Test SetNonInterruptMute interface.
751 */
752 HWTEST(AudioServiceUnitTest, SetNonInterruptMute_001, TestSize.Level1)
753 {
754 AudioService *audioService = AudioService::GetInstance();
755 std::shared_ptr<RendererInServer> renderer = nullptr;
756 audioService->InsertRenderer(1, renderer);
757 audioService->SetNonInterruptMute(1, true);
758 audioService->RemoveRenderer(1);
759 }
760
761 /**
762 * @tc.name : Test SetNonInterruptMute API
763 * @tc.type : FUNC
764 * @tc.number: SetNonInterruptMute_002
765 * @tc.desc : Test SetNonInterruptMute interface.
766 */
767 HWTEST(AudioServiceUnitTest, SetNonInterruptMute_002, TestSize.Level1)
768 {
769 AudioProcessConfig processConfig;
770
771 std::shared_ptr<StreamListenerHolder> streamListenerHolder =
772 std::make_shared<StreamListenerHolder>();
773
774 std::weak_ptr<IStreamListener> streamListener = streamListenerHolder;
775
776 std::shared_ptr<RendererInServer> rendererInServer =
777 std::make_shared<RendererInServer>(processConfig, streamListener);
778
779 std::shared_ptr<RendererInServer> renderer = rendererInServer;
780
781 AudioService *audioService = AudioService::GetInstance();
782 audioService->InsertRenderer(1, renderer);
783 audioService->SetNonInterruptMute(1, true);
784 audioService->RemoveRenderer(1);
785 }
786
787 /**
788 * @tc.name : Test SetNonInterruptMute API
789 * @tc.type : FUNC
790 * @tc.number: SetNonInterruptMute_003
791 * @tc.desc : Test SetNonInterruptMute interface.
792 */
793 HWTEST(AudioServiceUnitTest, SetNonInterruptMute_003, TestSize.Level1)
794 {
795 AudioService *audioService = AudioService::GetInstance();
796 std::shared_ptr<CapturerInServer> capturer = nullptr;
797 audioService->InsertCapturer(1, capturer);
798 audioService->SetNonInterruptMute(1, true);
799 audioService->RemoveCapturer(1);
800 }
801
802 /**
803 * @tc.name : Test SetNonInterruptMute API
804 * @tc.type : FUNC
805 * @tc.number: SetNonInterruptMute_004
806 * @tc.desc : Test SetNonInterruptMute interface.
807 */
808 HWTEST(AudioServiceUnitTest, SetNonInterruptMute_004, TestSize.Level1)
809 {
810 AudioProcessConfig processConfig;
811
812 std::shared_ptr<StreamListenerHolder> streamListenerHolder =
813 std::make_shared<StreamListenerHolder>();
814
815 std::weak_ptr<IStreamListener> streamListener = streamListenerHolder;
816
817 std::shared_ptr<CapturerInServer> capturerInServer =
818 std::make_shared<CapturerInServer>(processConfig, streamListener);
819
820 std::shared_ptr<CapturerInServer> capturer = capturerInServer;
821
822 AudioService *audioService = AudioService::GetInstance();
823 audioService->InsertCapturer(1, capturer);
824 audioService->SetNonInterruptMute(1, true);
825 audioService->RemoveCapturer(1);
826 }
827
828 /**
829 * @tc.name : Test SetOffloadMode API
830 * @tc.type : FUNC
831 * @tc.number: SetOffloadMode_001
832 * @tc.desc : Test SetOffloadMode interface.
833 */
834 HWTEST(AudioServiceUnitTest, SetOffloadMode_001, TestSize.Level1)
835 {
836 uint32_t sessionId = 2;
837 int32_t state = 1;
838 bool isAppBack = true;
839 AudioService *audioService = AudioService::GetInstance();
840 std::shared_ptr<CapturerInServer> capturer = nullptr;
841 audioService->InsertCapturer(1, capturer);
842 int32_t ret = audioService->SetOffloadMode(sessionId, state, isAppBack);
843 EXPECT_EQ(ERR_INVALID_INDEX, ret);
844 audioService->RemoveCapturer(1);
845 }
846
847 /**
848 * @tc.name : Test CheckRenderSessionMuteState API
849 * @tc.type : FUNC
850 * @tc.number: CheckRenderSessionMuteState_001
851 * @tc.desc : Test CheckRenderSessionMuteState interface.
852 */
853 HWTEST(AudioServiceUnitTest, CheckRenderSessionMuteState_001, TestSize.Level1)
854 {
855 uint32_t sessionId = 2;
856 AudioService *audioService = AudioService::GetInstance();
857 audioService->UpdateMuteControlSet(sessionId, true);
858
859 std::shared_ptr<RendererInServer> renderer = nullptr;
860 audioService->CheckRenderSessionMuteState(sessionId, renderer);
861
862 std::shared_ptr<CapturerInServer> capturer = nullptr;
863 audioService->CheckCaptureSessionMuteState(sessionId, capturer);
864
865 sptr<AudioProcessInServer> audioprocess = nullptr;
866 audioService->CheckFastSessionMuteState(sessionId, audioprocess);
867
868 audioService->RemoveIdFromMuteControlSet(sessionId);
869 audioService->RemoveIdFromMuteControlSet(1);
870
871 bool ret = audioService->IsExceedingMaxStreamCntPerUid(MEDIA_SERVICE_UID, 1, 0);
872 EXPECT_EQ(ret, true);
873 ret = audioService->IsExceedingMaxStreamCntPerUid(1, 1, 3);
874 EXPECT_EQ(ret, false);
875 int32_t mostAppUid = 1;
876 int32_t mostAppNum = 1;
877 audioService->GetCreatedAudioStreamMostUid(mostAppUid, mostAppNum);
878 }
879
880 /**
881 * @tc.name : Test CheckInnerCapForRenderer API
882 * @tc.type : FUNC
883 * @tc.number: CheckInnerCapForRenderer_001
884 * @tc.desc : Test CheckInnerCapForRenderer interface.
885 */
886 HWTEST(AudioServiceUnitTest, CheckInnerCapForRenderer_001, TestSize.Level1)
887 {
888 AudioService *audioService = AudioService::GetInstance();
889 AudioProcessConfig processConfig;
890
891 std::shared_ptr<StreamListenerHolder> streamListenerHolder =
892 std::make_shared<StreamListenerHolder>();
893
894 std::weak_ptr<IStreamListener> streamListener = streamListenerHolder;
895
896 std::shared_ptr<RendererInServer> rendererInServer =
897 std::make_shared<RendererInServer>(processConfig, streamListener);
898
899 std::shared_ptr<RendererInServer> renderer = rendererInServer;
900 audioService->CheckInnerCapForRenderer(1, renderer);
901 audioService->workingConfigs_[1];
902 audioService->CheckInnerCapForRenderer(1, renderer);
903 int32_t ret = audioService->OnCapturerFilterRemove(1, 1);
904 EXPECT_EQ(SUCCESS, ret);
905 audioService->workingConfigs_.clear();
906 ret = audioService->OnCapturerFilterRemove(1, 1);
907 EXPECT_EQ(SUCCESS, ret);
908 }
909
910 /**
911 * @tc.name : Test OnCapturerFilterChange API
912 * @tc.type : FUNC
913 * @tc.number: OnCapturerFilterChange_001
914 * @tc.desc : Test OnCapturerFilterChange interface.
915 */
916 HWTEST(AudioServiceUnitTest, OnCapturerFilterChange_001, TestSize.Level1)
917 {
918 AudioService *audioService = AudioService::GetInstance();
919 AudioPlaybackCaptureConfig newConfig;
920 int32_t ret = audioService->OnCapturerFilterChange(1, newConfig, 1);
921 EXPECT_EQ(ret, 0);
922 audioService->workingConfigs_[1];
923 ret = audioService->OnCapturerFilterChange(1, newConfig, 1);
924 EXPECT_EQ(ret, 0);
925 audioService->workingConfigs_.clear();
926 }
927
928 /**
929 * @tc.name : Test ShouldBeInnerCap API
930 * @tc.type : FUNC
931 * @tc.number: ShouldBeInnerCap_001
932 * @tc.desc : Test ShouldBeInnerCap interface.
933 */
934 HWTEST(AudioServiceUnitTest, ShouldBeInnerCap_001, TestSize.Level1)
935 {
936 AudioProcessConfig config = {};
937 config.privacyType = AudioPrivacyType::PRIVACY_TYPE_PUBLIC;
938 AudioService *audioService = AudioService::GetInstance();
939 int32_t ret = audioService->ShouldBeInnerCap(config, 0);
940 EXPECT_FALSE(ret);
941 audioService->workingConfig_.filterOptions.usages.push_back(STREAM_USAGE_MUSIC);
942 ret = audioService->ShouldBeInnerCap(config, 0);
943 EXPECT_FALSE(ret);
944 audioService->workingConfig_.filterOptions.pids.push_back(1);
945 ret = audioService->ShouldBeInnerCap(config, 0);
946 EXPECT_FALSE(ret);
947 }
948 #endif
949
950 /**
951 * @tc.name : Test DelayCallReleaseEndpoint API
952 * @tc.type : FUNC
953 * @tc.number: DelayCallReleaseEndpoint_002
954 * @tc.desc : Test DelayCallReleaseEndpoint interface.
955 */
956 HWTEST(AudioServiceUnitTest, DelayCallReleaseEndpoint_002, TestSize.Level1)
957 {
958 AudioService *audioService = AudioService::GetInstance();
959 std::string endpointName = "endpoint";
960 std::shared_ptr<AudioEndpoint> audioEndpoint = nullptr;
961 int32_t delayInMs = 1;
962 audioService->endpointList_[endpointName] = audioEndpoint;
963 audioService->DelayCallReleaseEndpoint(endpointName, delayInMs);
964
965 AudioMode audioMode = AUDIO_MODE_PLAYBACK;
966 audioService->SetIncMaxRendererStreamCnt(audioMode);
967
968 audioService->currentRendererStreamCnt_ = 0;
969 int32_t res = audioService->GetCurrentRendererStreamCnt();
970 EXPECT_EQ(res, 0);
971 }
972
973 /**
974 * @tc.name : Test CheckRenderSessionMuteState API
975 * @tc.type : FUNC
976 * @tc.number: CheckRenderSessionMuteState_002
977 * @tc.desc : Test CheckRenderSessionMuteState interface.
978 */
979 HWTEST(AudioServiceUnitTest, CheckRenderSessionMuteState_002, TestSize.Level1)
980 {
981 AudioProcessConfig processConfig;
982 uint32_t sessionId = 100001;
983 AudioService *audioService = AudioService::GetInstance();
984 audioService->UpdateMuteControlSet(sessionId, true);
985
986 std::shared_ptr<StreamListenerHolder> streamListenerHolder =
987 std::make_shared<StreamListenerHolder>();
988
989 std::weak_ptr<IStreamListener> streamListener = streamListenerHolder;
990 std::shared_ptr<RendererInServer> rendererInServer =
991 std::make_shared<RendererInServer>(processConfig, streamListener);
992 std::shared_ptr<RendererInServer> renderer = rendererInServer;
993 audioService->CheckRenderSessionMuteState(sessionId, renderer);
994
995 audioService->RemoveIdFromMuteControlSet(sessionId);
996
997 bool ret = audioService->IsExceedingMaxStreamCntPerUid(MEDIA_SERVICE_UID, 1, 0);
998 EXPECT_EQ(ret, true);
999 ret = audioService->IsExceedingMaxStreamCntPerUid(1, 1, 3);
1000 EXPECT_EQ(ret, false);
1001 int32_t mostAppUid = 1;
1002 int32_t mostAppNum = 1;
1003 audioService->GetCreatedAudioStreamMostUid(mostAppUid, mostAppNum);
1004 }
1005 /**
1006 * @tc.name : Test CheckRenderSessionMuteState API
1007 * @tc.type : FUNC
1008 * @tc.number: heckRenderSessionMuteState_003
1009 * @tc.desc : Test CheckRenderSessionMuteState interface.
1010 */
1011 HWTEST(AudioServiceUnitTest, CheckRenderSessionMuteState_003, TestSize.Level1)
1012 {
1013 AudioProcessConfig processConfig;
1014 uint32_t sessionId = 100001;
1015 AudioService *audioService = AudioService::GetInstance();
1016 audioService->UpdateMuteControlSet(sessionId, true);
1017
1018 std::shared_ptr<StreamListenerHolder> streamListenerHolder =
1019 std::make_shared<StreamListenerHolder>();
1020
1021 std::weak_ptr<IStreamListener> streamListener = streamListenerHolder;
1022
1023 std::shared_ptr<CapturerInServer> capturerInServer =
1024 std::make_shared<CapturerInServer>(processConfig, streamListener);
1025 std::shared_ptr<CapturerInServer> capturer = capturerInServer;
1026 audioService->CheckCaptureSessionMuteState(sessionId, capturer);
1027
1028 audioService->RemoveIdFromMuteControlSet(sessionId);
1029
1030 bool ret = audioService->IsExceedingMaxStreamCntPerUid(MEDIA_SERVICE_UID, 1, 0);
1031 EXPECT_EQ(ret, true);
1032 ret = audioService->IsExceedingMaxStreamCntPerUid(1, 1, 3);
1033 EXPECT_EQ(ret, false);
1034 int32_t mostAppUid = 1;
1035 int32_t mostAppNum = 1;
1036 audioService->GetCreatedAudioStreamMostUid(mostAppUid, mostAppNum);
1037 }
1038 /**
1039 * @tc.name : Test CheckRenderSessionMuteState API
1040 * @tc.type : FUNC
1041 * @tc.number: CheckRenderSessionMuteState_004
1042 * @tc.desc : Test CheckRenderSessionMuteState interface.
1043 */
1044 HWTEST(AudioServiceUnitTest, CheckRenderSessionMuteState_004, TestSize.Level1)
1045 {
1046 AudioProcessConfig processConfig;
1047 uint32_t sessionId = 100001;
1048 AudioService *audioService = AudioService::GetInstance();
1049 audioService->UpdateMuteControlSet(sessionId, true);
1050
1051 sptr<AudioProcessInServer> audioprocess = AudioProcessInServer::Create(processConfig, AudioService::GetInstance());;
1052 audioService->CheckFastSessionMuteState(sessionId, audioprocess);
1053
1054 audioService->RemoveIdFromMuteControlSet(sessionId);
1055
1056 bool ret = audioService->IsExceedingMaxStreamCntPerUid(MEDIA_SERVICE_UID, 1, 0);
1057 EXPECT_EQ(ret, true);
1058 ret = audioService->IsExceedingMaxStreamCntPerUid(1, 1, 3);
1059 EXPECT_EQ(ret, true);
1060 int32_t mostAppUid = 1;
1061 int32_t mostAppNum = 1;
1062 audioService->GetCreatedAudioStreamMostUid(mostAppUid, mostAppNum);
1063 }
1064 /**
1065 * @tc.name : Test GetStandbyStatus API
1066 * @tc.type : FUNC
1067 * @tc.number: GetStandbyStatus_001
1068 * @tc.desc : Test GetStandbyStatus interface.
1069 */
1070 HWTEST(AudioServiceUnitTest, GetStandbyStatus_001, TestSize.Level1)
1071 {
1072 uint32_t sessionId = 100001;
1073 AudioService *audioService = AudioService::GetInstance();
1074 audioService->UpdateMuteControlSet(sessionId, true);
1075 bool isStandby = false;
1076 int64_t enterStandbyTime = 100000;
1077 int ret = audioService->GetStandbyStatus(sessionId, isStandby, enterStandbyTime);
1078 EXPECT_EQ(ret, ERR_INVALID_PARAM);
1079 }
1080 /**
1081 * @tc.name : Test OnUpdateInnerCapList API
1082 * @tc.type : FUNC
1083 * @tc.number: OnUpdateInnerCapList_001
1084 * @tc.desc : Test OnUpdateInnerCapList interface.
1085 */
1086 HWTEST(AudioServiceUnitTest, OnUpdateInnerCapList_001, TestSize.Level1)
1087 {
1088 AudioService *audioService = AudioService::GetInstance();
1089 std::shared_ptr<RendererInServer> renderer = nullptr;
1090 std::vector<std::weak_ptr<RendererInServer>> rendererVector;
1091 rendererVector.push_back(renderer);
1092 int32_t innerCapId = 1;
1093 audioService->filteredRendererMap_.insert(std::make_pair(innerCapId, rendererVector));
1094 int32_t ret = audioService->OnUpdateInnerCapList(innerCapId);
1095 EXPECT_EQ(ret, SUCCESS);
1096 }
1097 /**
1098 * @tc.name : Test DelayCallReleaseEndpoint API
1099 * @tc.type : FUNC
1100 * @tc.number: DelayCallReleaseEndpoint_003
1101 * @tc.desc : Test DelayCallReleaseEndpoint interface.
1102 */
1103 HWTEST(AudioServiceUnitTest, DelayCallReleaseEndpoint_003, TestSize.Level1)
1104 {
1105 AudioService *audioService = AudioService::GetInstance();
1106 audioService->currentRendererStreamCnt_ = 0;
1107 audioService->DelayCallReleaseEndpoint("endponit", 0);
1108
1109 AudioMode audioMode = AUDIO_MODE_PLAYBACK;
1110 audioService->SetIncMaxRendererStreamCnt(audioMode);
1111 int32_t res = audioService->GetCurrentRendererStreamCnt();
1112 EXPECT_EQ(res, 1);
1113 }
1114 /**
1115 * @tc.name : Test DelayCallReleaseEndpoint API
1116 * @tc.type : FUNC
1117 * @tc.number: DelayCallReleaseEndpoint_004
1118 * @tc.desc : Test DelayCallReleaseEndpoint interface.
1119 */
1120 HWTEST(AudioServiceUnitTest, DelayCallReleaseEndpoint_004, TestSize.Level1)
1121 {
1122 AudioService *audioService = AudioService::GetInstance();
1123 audioService->currentRendererStreamCnt_ = 0;
1124 audioService->releasingEndpointSet_.insert("endponit");
1125 audioService->DelayCallReleaseEndpoint("endponit", 1);
1126
1127 AudioMode audioMode = AUDIO_MODE_PLAYBACK;
1128 audioService->SetIncMaxRendererStreamCnt(audioMode);
1129 int32_t res = audioService->GetCurrentRendererStreamCnt();
1130 EXPECT_EQ(res, 1);
1131 }
1132 /**
1133 * @tc.name : Test EnableDualToneList API
1134 * @tc.type : FUNC
1135 * @tc.number: EnableDualToneList_001
1136 * @tc.desc : Test EnableDualToneList interface.
1137 */
1138 HWTEST(AudioServiceUnitTest, EnableDualToneList_001, TestSize.Level1)
1139 {
1140 AudioService *audioService = AudioService::GetInstance();
1141 std::shared_ptr<RendererInServer> renderer = nullptr;
1142 int32_t sessionId = 1;
1143 audioService->allRendererMap_.insert(std::make_pair(sessionId, renderer));
1144 int32_t ret = audioService->EnableDualToneList(sessionId);
1145 EXPECT_EQ(ret, SUCCESS);
1146 }
1147 /**
1148 * @tc.name : Test DisableDualToneList API
1149 * @tc.type : FUNC
1150 * @tc.number: DisableDualToneList_001
1151 * @tc.desc : Test DisableDualToneList interface.
1152 */
1153 HWTEST(AudioServiceUnitTest, DisableDualToneList_001, TestSize.Level1)
1154 {
1155 AudioService *audioService = AudioService::GetInstance();
1156 std::shared_ptr<RendererInServer> renderer = nullptr;
1157 audioService->filteredDualToneRendererMap_.push_back(renderer);
1158 int32_t sessionId = 1;
1159 int32_t ret = audioService->DisableDualToneList(sessionId);
1160 EXPECT_EQ(ret, SUCCESS);
1161 }
1162 /**
1163 * @tc.name : Test UpdateAudioSinkState API
1164 * @tc.type : FUNC
1165 * @tc.number: UpdateAudioSinkState_001
1166 * @tc.desc : Test UpdateAudioSinkState interface.
1167 */
1168 HWTEST(AudioServiceUnitTest, UpdateAudioSinkState_001, TestSize.Level1)
1169 {
1170 AudioService *audioService = AudioService::GetInstance();
1171 audioService->currentRendererStreamCnt_ = 0;
1172 audioService->UpdateAudioSinkState(1, false);
1173
1174 AudioMode audioMode = AUDIO_MODE_PLAYBACK;
1175 audioService->SetIncMaxRendererStreamCnt(audioMode);
1176 int32_t res = audioService->GetCurrentRendererStreamCnt();
1177 EXPECT_EQ(res, 1);
1178 }
1179 /**
1180 * @tc.name : Test UpdateAudioSinkState API
1181 * @tc.type : FUNC
1182 * @tc.number: UpdateAudioSinkState_002
1183 * @tc.desc : Test UpdateAudioSinkState interface.
1184 */
1185 HWTEST(AudioServiceUnitTest, UpdateAudioSinkState_002, TestSize.Level1)
1186 {
1187 AudioService *audioService = AudioService::GetInstance();
1188 audioService->currentRendererStreamCnt_ = 0;
1189 audioService->UpdateAudioSinkState(1, true);
1190
1191 AudioMode audioMode = AUDIO_MODE_PLAYBACK;
1192 audioService->SetIncMaxRendererStreamCnt(audioMode);
1193 int32_t res = audioService->GetCurrentRendererStreamCnt();
1194 EXPECT_EQ(res, 1);
1195 }
1196 /**
1197 * @tc.name : Test ShouldBeDualTone API
1198 * @tc.type : FUNC
1199 * @tc.number: AudioServiceShouldBeDualTone_003
1200 * @tc.desc : Test ShouldBeDualTone interface.
1201 */
1202 HWTEST(AudioServiceUnitTest, AudioServiceShouldBeDualTone_003, TestSize.Level1)
1203 {
1204 AudioProcessConfig config = {};
1205 config.audioMode = AUDIO_MODE_PLAYBACK;
1206 bool ret;
1207 ret = AudioService::GetInstance()->ShouldBeDualTone(config);
1208 EXPECT_EQ(ret, false);
1209 config.audioMode = AUDIO_MODE_PLAYBACK;
1210 config.rendererInfo.streamUsage = STREAM_USAGE_RINGTONE;
1211 ret = AudioService::GetInstance()->ShouldBeDualTone(config);
1212 EXPECT_FALSE(ret);
1213 }
1214 /**
1215 * @tc.name : Test CheckHibernateState API
1216 * @tc.type : FUNC
1217 * @tc.number: CheckHibernateState_001
1218 * @tc.desc : Test CheckHibernateState interface.
1219 */
1220 HWTEST(AudioServiceUnitTest, CheckHibernateState_001, TestSize.Level1)
1221 {
1222 AudioService *audioService = AudioService::GetInstance();
1223 audioService->currentRendererStreamCnt_ = 0;
1224 audioService->CheckHibernateState(true);
1225
1226 AudioMode audioMode = AUDIO_MODE_PLAYBACK;
1227 audioService->SetIncMaxRendererStreamCnt(audioMode);
1228 int32_t res = audioService->GetCurrentRendererStreamCnt();
1229 EXPECT_EQ(res, 1);
1230 }
1231 /**
1232 * @tc.name : Test CheckHibernateState API
1233 * @tc.type : FUNC
1234 * @tc.number: CheckHibernateState_002
1235 * @tc.desc : Test CheckHibernateState interface.
1236 */
1237 HWTEST(AudioServiceUnitTest, CheckHibernateState_002, TestSize.Level1)
1238 {
1239 AudioService *audioService = AudioService::GetInstance();
1240 audioService->currentRendererStreamCnt_ = 0;
1241 audioService->CheckHibernateState(false);
1242
1243 AudioMode audioMode = AUDIO_MODE_PLAYBACK;
1244 audioService->SetIncMaxRendererStreamCnt(audioMode);
1245 int32_t res = audioService->GetCurrentRendererStreamCnt();
1246 EXPECT_EQ(res, 1);
1247 }
1248 /**
1249 * @tc.name : Test CheckHibernateState API
1250 * @tc.type : FUNC
1251 * @tc.number: CheckHibernateState_003
1252 * @tc.desc : Test CheckHibernateState interface.
1253 */
1254 HWTEST(AudioServiceUnitTest, CheckHibernateState_003, TestSize.Level1)
1255 {
1256 AudioService *audioService = AudioService::GetInstance();
1257 audioService->allRunningSinks_.insert(1);
1258 audioService->currentRendererStreamCnt_ = 0;
1259 audioService->CheckHibernateState(true);
1260
1261 AudioMode audioMode = AUDIO_MODE_PLAYBACK;
1262 audioService->SetIncMaxRendererStreamCnt(audioMode);
1263 int32_t res = audioService->GetCurrentRendererStreamCnt();
1264 EXPECT_EQ(res, 1);
1265 }
1266 /**
1267 * @tc.name : Test UnsetOffloadMode API
1268 * @tc.type : FUNC
1269 * @tc.number: UnsetOffloadMode_001
1270 * @tc.desc : Test UnsetOffloadMode interface.
1271 */
1272 HWTEST(AudioServiceUnitTest, UnsetOffloadMode_001, TestSize.Level1)
1273 {
1274 AudioService *audioService = AudioService::GetInstance();
1275 audioService->allRunningSinks_.insert(1);
1276 int ret = audioService->UnsetOffloadMode(1);
1277 EXPECT_EQ(ret, ERROR);
1278 }
1279 } // namespace AudioStandard
1280 } // namespace OHOS