1 /*
2 * Copyright (c) 2023 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_log.h"
21 #include "audio_errors.h"
22 #include "audio_system_manager.h"
23
24 #include "audio_manager_proxy.h"
25 #include "audio_manager_listener_stub.h"
26 #include "audio_process_proxy.h"
27 #include "audio_process_in_client.h"
28
29 using namespace testing::ext;
30
31 namespace OHOS {
32 namespace AudioStandard {
33 std::unique_ptr<AudioManagerProxy> audioManagerProxy;
34 std::shared_ptr<AudioProcessInClient> processClient_;
35 const int32_t TEST_RET_NUM = 0;
36 const int32_t RENDERER_FLAGS = 0;
37 constexpr int32_t ERROR_62980101 = -62980101;
38
39 class AudioServiceUnitTest : public testing::Test {
40 public:
41 static void SetUpTestCase(void);
42 static void TearDownTestCase(void);
43 void SetUp();
44 void TearDown();
45 };
46
47 class AudioParameterCallbackTest : public AudioParameterCallback {
OnAudioParameterChange(const std::string networkId,const AudioParamKey key,const std::string & condition,const std::string & value)48 virtual void OnAudioParameterChange(const std::string networkId, const AudioParamKey key,
49 const std::string& condition, const std::string& value) {}
50 };
51
SetUpTestCase(void)52 void AudioServiceUnitTest::SetUpTestCase(void)
53 {
54 // input testsuit setup step，setup invoked before all testcases
55 }
56
TearDownTestCase(void)57 void AudioServiceUnitTest::TearDownTestCase(void)
58 {
59 // input testsuit teardown step，teardown invoked after all testcases
60 }
61
SetUp(void)62 void AudioServiceUnitTest::SetUp(void)
63 {
64 // input testcase setup step，setup invoked before each testcases
65 }
66
TearDown(void)67 void AudioServiceUnitTest::TearDown(void)
68 {
69 // input testcase teardown step，teardown invoked after each testcases
70 }
71
72 /**
73 * @tc.name : Test AudioProcessProxy API
74 * @tc.type : FUNC
75 * @tc.number: AudioProcessProxy_001
76 * @tc.desc : Test AudioProcessProxy interface.
77 */
78 HWTEST(AudioServiceUnitTest, AudioProcessProxy_001, TestSize.Level1)
79 {
80 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
81 EXPECT_NE(nullptr, samgr);
82 sptr<IRemoteObject> object = samgr->GetSystemAbility(AUDIO_DISTRIBUTED_SERVICE_ID);
83 EXPECT_NE(nullptr, object);
84 std::unique_ptr<AudioProcessProxy> audioProcessProxy = std::make_unique<AudioProcessProxy>(object);
85
86 int32_t ret = -1;
87 std::shared_ptr<OHAudioBuffer> buffer;
88 uint32_t spanSizeInFrame = 1000;
89 uint32_t totalSizeInFrame = spanSizeInFrame - 1;
90 uint32_t byteSizePerFrame = 1000;
91 buffer = OHAudioBuffer::CreateFromLocal(totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
92
93 ret=audioProcessProxy->ResolveBuffer(buffer);
94 EXPECT_LT(ret, TEST_RET_NUM);
95
96 ret = audioProcessProxy->Start();
97 EXPECT_LT(ret, TEST_RET_NUM);
98
99 bool isFlush = true;
100 ret = audioProcessProxy->Pause(isFlush);
101 EXPECT_LT(ret, TEST_RET_NUM);
102
103 ret = audioProcessProxy->Resume();
104 EXPECT_LT(ret, TEST_RET_NUM);
105
106 ret = audioProcessProxy->Stop();
107 EXPECT_LT(ret, TEST_RET_NUM);
108
109 ret = audioProcessProxy->RequestHandleInfo();
110 EXPECT_EQ(ret, SUCCESS);
111
112 ret = audioProcessProxy->Release();
113 EXPECT_LT(ret, TEST_RET_NUM);
114 }
115
116 /**
117 * @tc.name : Test AudioManagerProxy API
118 * @tc.type : FUNC
119 * @tc.number: AudioManagerProxy_001
120 * @tc.desc : Test AudioManagerProxy interface.
121 */
122 HWTEST(AudioServiceUnitTest, AudioManagerProxy_001, TestSize.Level1)
123 {
124 int32_t ret = -1;
125
126 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
127 EXPECT_NE(nullptr, samgr);
128 sptr<IRemoteObject> object = samgr->GetSystemAbility(AUDIO_DISTRIBUTED_SERVICE_ID);
129 EXPECT_NE(nullptr, object);
130
131 audioManagerProxy = std::make_unique<AudioManagerProxy>(object);
132
133 bool isMute = true;
134 ret = audioManagerProxy->SetMicrophoneMute(isMute);
135 EXPECT_EQ(ret, SUCCESS);
136
137 ret = audioManagerProxy->RegiestPolicyProvider(object);
138 EXPECT_EQ(SUCCESS, ret);
139
140 bool state = false;
141 ret = audioManagerProxy->SetCaptureSilentState(state);
142 EXPECT_TRUE(ERROR_62980101 == ret || SUCCESS == ret);
143
144 bool result = audioManagerProxy->CreatePlaybackCapturerManager();
145 EXPECT_EQ(result, true);
146
147 int32_t deviceType = 1;
148 std::string sinkName = "test";
149 audioManagerProxy->SetOutputDeviceSink(deviceType, sinkName);
150 }
151
152 /**
153 * @tc.name : Test AudioManagerProxy API
154 * @tc.type : FUNC
155 * @tc.number: AudioManagerProxy_002
156 * @tc.desc : Test AudioManagerProxy interface.
157 */
158 HWTEST(AudioServiceUnitTest, AudioManagerProxy_002, TestSize.Level1)
159 {
160 int32_t ret = -1;
161
162 float volume = 0.1;
163 ret = audioManagerProxy->SetVoiceVolume(volume);
164
165 const std::string networkId = "LocalDevice";
166 const AudioParamKey key = AudioParamKey::VOLUME;
167 AudioVolumeType volumeType =AudioVolumeType::STREAM_MEDIA;
168 int32_t groupId = 0;
169 std::string condition = "EVENT_TYPE=1;VOLUME_GROUP_ID=" + std::to_string(groupId) + ";AUDIO_VOLUME_TYPE="
170 + std::to_string(volumeType) + ";";
171 std::string value = std::to_string(volume);
172 audioManagerProxy->SetAudioParameter(networkId, key, condition, value);
173 const std::string retStr = audioManagerProxy->GetAudioParameter(networkId, key, condition);
174 EXPECT_NE(retStr, value);
175
176 bool connected = true;
177 audioManagerProxy->NotifyDeviceInfo(networkId, connected);
178 ret = audioManagerProxy->CheckRemoteDeviceState(networkId, DeviceRole::OUTPUT_DEVICE, true);
179 EXPECT_LT(ret, TEST_RET_NUM);
180 }
181
182 /**
183 * @tc.name : Test AudioManagerProxy API
184 * @tc.type : FUNC
185 * @tc.number: AudioManagerProxy_004
186 * @tc.desc : Test AudioManagerProxy interface.
187 */
188 HWTEST(AudioServiceUnitTest, AudioManagerProxy_004, TestSize.Level1)
189 {
190 std::vector<Library> libraries;
191 Library library = {};
192 library.name = "testname";
193 library.path ="test.so";
194 libraries.push_back(library);
195
196 std::vector<Effect> effects;
197 Effect effect = {};
198 effect.name = "test";
199 effect.libraryName = "test";
200 effects.push_back(effect);
201
202 std::vector<Effect> successEffects;
203 bool ret = audioManagerProxy->LoadAudioEffectLibraries(libraries, effects, successEffects);
204 EXPECT_EQ(ret, false);
205 }
206
207 /**
208 * @tc.name : Test AudioManagerListenerStub API
209 * @tc.type : FUNC
210 * @tc.number: AudioManagerListenerStub_001
211 * @tc.desc : Test AudioManagerListenerStub interface.
212 */
213 HWTEST(AudioServiceUnitTest, AudioManagerListenerStub_001, TestSize.Level1)
214 {
215 std::unique_ptr<AudioManagerListenerStub> audioManagerListenerStub = std::make_unique<AudioManagerListenerStub>();
216
217 const std::weak_ptr<AudioParameterCallback> callback = std::make_shared<AudioParameterCallbackTest>();
218 audioManagerListenerStub->SetParameterCallback(callback);
219 float volume = 0.1;
220 const std::string networkId = "LocalDevice";
221 const AudioParamKey key = AudioParamKey::VOLUME;
222 AudioVolumeType volumeType =AudioVolumeType::STREAM_MEDIA;
223 int32_t groupId = 0;
224 std::string condition = "EVENT_TYPE=1;VOLUME_GROUP_ID=" + std::to_string(groupId) + ";AUDIO_VOLUME_TYPE="
225 + std::to_string(volumeType) + ";";
226 std::string value = std::to_string(volume);
227 audioManagerListenerStub->OnAudioParameterChange(networkId, key, condition, value);
228 EXPECT_NE(value, "");
229 }
230
231
232 /**
233 * @tc.name : Test AudioProcessInClientInner API
234 * @tc.type : FUNC
235 * @tc.number: AudioProcessInClientInner_001
236 * @tc.desc : Test AudioProcessInClientInner interface using unsupported parameters.
237 */
238 HWTEST(AudioServiceUnitTest, AudioProcessInClientInner_001, TestSize.Level1)
239 {
240 AudioProcessConfig config;
241 config.appInfo.appPid = getpid();
242 config.appInfo.appUid = getuid();
243
244 config.audioMode = AUDIO_MODE_PLAYBACK;
245
246 config.rendererInfo.contentType = CONTENT_TYPE_MUSIC;
247 config.rendererInfo.streamUsage = STREAM_USAGE_MEDIA;
248 config.rendererInfo.rendererFlags = RENDERER_FLAGS;
249
250 config.streamInfo.channels = STEREO;
251 config.streamInfo.encoding = ENCODING_PCM;
252 config.streamInfo.format = SAMPLE_S16LE;
253 config.streamInfo.samplingRate = SAMPLE_RATE_64000;
254
255 processClient_ = AudioProcessInClient::Create(config);
256 EXPECT_EQ(processClient_, nullptr);
257 }
258
259 /**
260 * @tc.name : Test AudioDeviceDescriptor API
261 * @tc.type : FUNC
262 * @tc.number: AudioDeviceDescriptor_001
263 * @tc.desc : Test AudioDeviceDescriptor interface.
264 */
265 HWTEST(AudioServiceUnitTest, AudioDeviceDescriptor_001, TestSize.Level1)
266 {
267 DeviceType type = DeviceType::DEVICE_TYPE_SPEAKER;
268 DeviceRole role = DeviceRole::OUTPUT_DEVICE;
269 int32_t interruptGroupId = 1;
270 int32_t volumeGroupId = 1;
271 std::string networkId = "LocalDevice";
272 std::unique_ptr<AudioDeviceDescriptor> audioDeviceDescriptor =
273 std::make_unique<AudioDeviceDescriptor>(type, role, interruptGroupId, volumeGroupId, networkId);
274 EXPECT_NE(audioDeviceDescriptor, nullptr);
275
276 AudioDeviceDescriptor deviceDescriptor;
277 deviceDescriptor.deviceType_ = type;
278 deviceDescriptor.deviceRole_ = role;
279 audioDeviceDescriptor = std::make_unique<AudioDeviceDescriptor>(deviceDescriptor);
280 EXPECT_NE(audioDeviceDescriptor, nullptr);
281
282 std::string deviceName = "";
283 std::string macAddress = "";
284 audioDeviceDescriptor->SetDeviceInfo(deviceName, macAddress);
285
286 DeviceStreamInfo audioStreamInfo = {
287 SAMPLE_RATE_48000,
288 ENCODING_PCM,
289 SAMPLE_S16LE,
290 STEREO
291 };
292 int32_t channelMask = 1;
293 audioDeviceDescriptor->SetDeviceCapability(audioStreamInfo, channelMask);
294
295 DeviceStreamInfo streamInfo = audioDeviceDescriptor->audioStreamInfo_;
296 EXPECT_EQ(streamInfo.channels, audioStreamInfo.channels);
297 EXPECT_EQ(streamInfo.encoding, audioStreamInfo.encoding);
298 EXPECT_EQ(streamInfo.format, audioStreamInfo.format);
299 EXPECT_EQ(streamInfo.samplingRate, audioStreamInfo.samplingRate);
300 }
301 } // namespace AudioStandard
302 } // namespace OHOS