1 /*
2 * Copyright (c) 2021-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 "audio_errors.h"
17 #include "audio_system_manager.h"
18 #include "audio_policy_test.h"
19
20 using namespace std;
21 using namespace OHOS::AudioStandard;
22 using namespace testing::ext;
23
24 namespace OHOS {
25 namespace AudioStandard {
26 namespace V1_0 {
SetUpTestCase(void)27 void AudioPolicyTest::SetUpTestCase(void)
28 {
29 ASSERT_NE(nullptr, AudioSystemManager::GetInstance());
30 }
31
TearDownTestCase(void)32 void AudioPolicyTest::TearDownTestCase(void) {}
33
SetUp(void)34 void AudioPolicyTest::SetUp(void) {}
35
TearDown(void)36 void AudioPolicyTest::TearDown(void) {}
37
OnRingerModeUpdated(const AudioRingerMode & ringerMode)38 void AudioRingerModeCallbackTest::OnRingerModeUpdated(const AudioRingerMode &ringerMode)
39 {
40 ringerMode_ = ringerMode;
41 }
42
43 namespace {
44 const PolicyParam VOLUME_PARAMS[] = {
45 {
46 .volume = 8,
47 .streamType = STREAM_MUSIC
48 },
49 {
50 .volume = 8,
51 .streamType = STREAM_RING
52 }
53 };
54
55 const PolicyParam MUTE_PARAMS[] = {
56 {
57 .streamType = STREAM_MUSIC,
58 .mute = true
59 },
60 {
61 .streamType = STREAM_MUSIC,
62 .mute = false
63 }
64 };
65
66 const PolicyParam STREAM_PARAMS[] = {
67 {
68 .streamType = STREAM_MUSIC,
69 .active = true
70 },
71 {
72 .streamType = STREAM_RING,
73 .active = false
74 }
75 };
76
77 const PolicyParam RINGER_MODE_PARAMS[] = {
78 {
79 .ringerMode = RINGER_MODE_NORMAL
80 },
81 {
82 .ringerMode = RINGER_MODE_SILENT
83 },
84 {
85 .ringerMode = RINGER_MODE_VIBRATE
86 },
87 };
88
89 const PolicyParam MIC_MUTE_PARAMS[] = {
90 {
91 .mute = true
92 },
93 {
94 .mute = false
95 }
96 };
97
98 const PolicyParam VOLUME_RANGE_PARAMS[] = {
99 {
100 .streamType = STREAM_MUSIC
101 },
102 {
103 .streamType = STREAM_RING
104 }
105 };
106
107 const PolicyParam AUDIO_PARAMS[] = {
108 {
109 .key = "sampling_rate",
110 .value = "8000"
111 },
112 {
113 .key = "sampling_rate",
114 .value = "44100"
115 },
116 {
117 .key = "sampling_rate",
118 .value = "96000"
119 }
120 };
121
122 const PolicyParam DEVICES_PARAMS[] = {
123 {
124 .deviceType = DEVICE_TYPE_MIC,
125 .deviceFlag = INPUT_DEVICES_FLAG,
126 .deviceRole = INPUT_DEVICE
127 },
128 {
129 .deviceType = DEVICE_TYPE_SPEAKER,
130 .deviceFlag = OUTPUT_DEVICES_FLAG,
131 .deviceRole = OUTPUT_DEVICE
132 }
133 };
134
135 const PolicyParam AUDIO_SCENE_PARAMS[] = {
136 {
137 .audioScene = AUDIO_SCENE_DEFAULT
138 },
139 {
140 .audioScene = AUDIO_SCENE_PHONE_CHAT
141 }
142 };
143 } // namespace
144
145 /*
146 * Set Volume
147 *
148 */
149 class AudioPolicySetVolumeTest : public AudioPolicyTest {};
150
151 HWTEST_P(AudioPolicySetVolumeTest, SetVolume, TestSize.Level1)
152 {
153 PolicyParam params = GetParam();
154
155 AudioVolumeType volumeType
156 = static_cast<AudioVolumeType>(params.streamType);
157 float volume = params.volume;
158 EXPECT_EQ(AUDIO_OK, AudioSystemManager::GetInstance()->SetVolume(volumeType, volume));
159 }
160
161 INSTANTIATE_TEST_SUITE_P(
162 SetVolume,
163 AudioPolicySetVolumeTest,
164 ValuesIn(VOLUME_PARAMS));
165
166 /*
167 * Get Volume
168 *
169 */
170 class AudioPolicyGetVolumeTest : public AudioPolicyTest {};
171
172 HWTEST_P(AudioPolicyGetVolumeTest, GetVolume, TestSize.Level1)
173 {
174 PolicyParam params = GetParam();
175 AudioVolumeType volumeType
176 = static_cast<AudioVolumeType>(params.streamType);
177 float volume = params.volume;
178
179 EXPECT_EQ(AUDIO_OK, AudioSystemManager::GetInstance()->SetVolume(volumeType, volume));
180 EXPECT_EQ(volume, AudioSystemManager::GetInstance()->GetVolume(volumeType));
181 }
182
183 INSTANTIATE_TEST_SUITE_P(
184 GetVolume,
185 AudioPolicyGetVolumeTest,
186 ValuesIn(VOLUME_PARAMS));
187
188 /*
189 * Set Mute
190 *
191 */
192 class AudioPolicySetMuteTest : public AudioPolicyTest {};
193
194 HWTEST_P(AudioPolicySetMuteTest, SetMute, TestSize.Level1)
195 {
196 PolicyParam params = GetParam();
197 AudioVolumeType volumeType
198 = static_cast<AudioVolumeType>(params.streamType);
199 bool mute = params.mute;
200
201 EXPECT_EQ(AUDIO_OK, AudioSystemManager::GetInstance()->SetMute(volumeType, mute));
202 }
203
204 INSTANTIATE_TEST_SUITE_P(
205 SetMute,
206 AudioPolicySetMuteTest,
207 ValuesIn(MUTE_PARAMS));
208
209 /*
210 * Set Ringer Mode
211 *
212 */
213 class AudioPolicySetRingerModeTest : public AudioPolicyTest {};
214
215 HWTEST_P(AudioPolicySetRingerModeTest, SetRingerMode, TestSize.Level1)
216 {
217 PolicyParam params = GetParam();
218 AudioRingerMode ringerMode = params.ringerMode;
219
220 EXPECT_EQ(AUDIO_OK, AudioSystemManager::GetInstance()->SetRingerMode(ringerMode));
221 }
222
223
224 INSTANTIATE_TEST_SUITE_P(
225 SetRingerMode,
226 AudioPolicySetRingerModeTest,
227 ValuesIn(RINGER_MODE_PARAMS));
228
229 /*
230 * Get Ringer Mode
231 *
232 */
233 class AudioPolicyGetRingerModeTest : public AudioPolicyTest {};
234
235 HWTEST_P(AudioPolicyGetRingerModeTest, GetRingerMode, TestSize.Level1)
236 {
237 PolicyParam params = GetParam();
238 AudioRingerMode ringerMode = params.ringerMode;
239
240 EXPECT_EQ(AUDIO_OK, AudioSystemManager::GetInstance()->SetRingerMode(ringerMode));
241 EXPECT_EQ(ringerMode, AudioSystemManager::GetInstance()->GetRingerMode());
242 }
243
244 INSTANTIATE_TEST_SUITE_P(
245 GetRingerMode,
246 AudioPolicyGetRingerModeTest,
247 ValuesIn(RINGER_MODE_PARAMS));
248
249 /*
250 * Check ringer mode callback
251 *
252 */
253 class AudioPolicySetRingerModeCallbackTest : public AudioPolicyTest {};
254
255 HWTEST_P(AudioPolicySetRingerModeCallbackTest, SetRingerModeCallback, TestSize.Level1)
256 {
257 int32_t ret = -1;
258 PolicyParam params = GetParam();
259 AudioRingerMode ringerMode = params.ringerMode;
260
261 AudioSystemManager *audioSystemMgr = AudioSystemManager::GetInstance();
262
263 shared_ptr<AudioRingerModeCallbackTest> ringerModeCB = std::make_shared<AudioRingerModeCallbackTest>();
264 ret = audioSystemMgr->SetRingerModeCallback(1, ringerModeCB);
265 EXPECT_EQ(SUCCESS, ret);
266
267 audioSystemMgr->SetRingerMode(ringerMode);
268 sleep(1);
269 EXPECT_EQ(ringerModeCB->ringerMode_, ringerMode);
270
271 ret = audioSystemMgr->UnsetRingerModeCallback(1);
272 EXPECT_EQ(SUCCESS, ret);
273 }
274
275 INSTANTIATE_TEST_SUITE_P(
276 SetRingerModeCallback,
277 AudioPolicySetRingerModeCallbackTest,
278 ValuesIn(RINGER_MODE_PARAMS));
279
280 /*
281 * Set microphone mute
282 *
283 */
284 class AudioPolicySetMicrophoneMuteTest : public AudioPolicyTest {};
285
286 HWTEST_P(AudioPolicySetMicrophoneMuteTest, SetMicrophoneMute, TestSize.Level1)
287 {
288 PolicyParam params = GetParam();
289 bool mute = params.mute;
290
291 EXPECT_EQ(AUDIO_OK, AudioSystemManager::GetInstance()->SetMicrophoneMute(mute));
292 }
293
294 INSTANTIATE_TEST_SUITE_P(
295 SetMicrophoneMute,
296 AudioPolicySetMicrophoneMuteTest,
297 ValuesIn(MIC_MUTE_PARAMS));
298
299 /*
300 * Is Microphone Mute
301 *
302 */
303 class AudioPolicyGetMicrophoneMuteTest : public AudioPolicyTest {};
304
305 HWTEST_P(AudioPolicyGetMicrophoneMuteTest, IsMicrophoneMute, TestSize.Level1)
306 {
307 PolicyParam params = GetParam();
308 bool mute = params.mute;
309
310 EXPECT_EQ(AUDIO_OK, AudioSystemManager::GetInstance()->SetMicrophoneMute(mute));
311 }
312
313 INSTANTIATE_TEST_SUITE_P(
314 IsMicrophoneMute,
315 AudioPolicyGetMicrophoneMuteTest,
316 ValuesIn(MIC_MUTE_PARAMS));
317
318 /*
319 * Check volume range
320 *
321 */
322 class AudioPolicyVolumeRangeTest : public AudioPolicyTest {};
323
324 HWTEST_P(AudioPolicyVolumeRangeTest, GetMaxVolume, TestSize.Level1)
325 {
326 PolicyParam params = GetParam();
327 AudioVolumeType volumeType
328 = static_cast<AudioVolumeType>(params.streamType);
329 EXPECT_EQ(15, AudioSystemManager::GetInstance()->GetMaxVolume(volumeType));
330 }
331
332 HWTEST_P(AudioPolicyVolumeRangeTest, GetMinVolume, TestSize.Level1)
333 {
334 PolicyParam params = GetParam();
335 AudioVolumeType volumeType
336 = static_cast<AudioVolumeType>(params.streamType);
337 EXPECT_EQ(0, AudioSystemManager::GetInstance()->GetMinVolume(volumeType));
338 }
339
340 INSTANTIATE_TEST_SUITE_P(
341 GetMaxVolume,
342 AudioPolicyVolumeRangeTest,
343 ValuesIn(VOLUME_RANGE_PARAMS));
344
345 INSTANTIATE_TEST_SUITE_P(
346 GetMinVolume,
347 AudioPolicyVolumeRangeTest,
348 ValuesIn(VOLUME_RANGE_PARAMS));
349
350 /*
351 * Check volume range
352 *
353 */
354 class AudioPolicyAudioParameterTest : public AudioPolicyTest {};
355
356 HWTEST_P(AudioPolicyAudioParameterTest, SetAudioParameter, TestSize.Level1)
357 {
358 PolicyParam params = GetParam();
359 AudioSystemManager::GetInstance()->SetAudioParameter(params.key, params.value);
360 EXPECT_EQ(params.value, AudioSystemManager::GetInstance()->GetAudioParameter(params.key));
361 }
362
363 INSTANTIATE_TEST_SUITE_P(
364 SetAudioParameter,
365 AudioPolicyAudioParameterTest,
366 ValuesIn(AUDIO_PARAMS));
367
368 HWTEST_P(AudioPolicyAudioParameterTest, GetAudioParameter, TestSize.Level1)
369 {
370 PolicyParam params = GetParam();
371 AudioSystemManager::GetInstance()->SetAudioParameter(params.key, params.value);
372 EXPECT_EQ(params.value, AudioSystemManager::GetInstance()->GetAudioParameter(params.key));
373 }
374
375 INSTANTIATE_TEST_SUITE_P(
376 GetAudioParameter,
377 AudioPolicyAudioParameterTest,
378 ValuesIn(AUDIO_PARAMS));
379
380 /*
381 * Check set audio scene
382 *
383 */
384 class AudioPolicySetAudioSceneTest : public AudioPolicyTest {};
385
386 HWTEST_P(AudioPolicySetAudioSceneTest, SetAudioScene, TestSize.Level1)
387 {
388 PolicyParam params = GetParam();
389 AudioScene scene = params.audioScene;
390 int32_t ret = AudioSystemManager::GetInstance()->SetAudioScene(scene);
391 EXPECT_EQ(SUCCESS, ret);
392 ret = AudioSystemManager::GetInstance()->SetAudioScene(AUDIO_SCENE_DEFAULT);
393 EXPECT_EQ(SUCCESS, ret);
394 }
395
396 INSTANTIATE_TEST_SUITE_P(
397 SetAudioScene,
398 AudioPolicySetAudioSceneTest,
399 ValuesIn(AUDIO_SCENE_PARAMS));
400
401 /*
402 * Check get audio scene
403 *
404 */
405 class AudioPolicyGetAudioSceneTest : public AudioPolicyTest {};
406
407 HWTEST_P(AudioPolicyGetAudioSceneTest, GetAudioScene, TestSize.Level1)
408 {
409 PolicyParam params = GetParam();
410 AudioScene scene = params.audioScene;
411 EXPECT_EQ(AudioSystemManager::GetInstance()->GetAudioScene(), AUDIO_SCENE_DEFAULT);
412
413 int32_t ret = AudioSystemManager::GetInstance()->SetAudioScene(scene);
414 EXPECT_EQ(SUCCESS, ret);
415
416 EXPECT_EQ(AudioSystemManager::GetInstance()->GetAudioScene(), scene);
417
418 ret = AudioSystemManager::GetInstance()->SetAudioScene(AUDIO_SCENE_DEFAULT);
419 EXPECT_EQ(SUCCESS, ret);
420 }
421
422 INSTANTIATE_TEST_SUITE_P(
423 GetAudioScene,
424 AudioPolicyGetAudioSceneTest,
425 ValuesIn(AUDIO_SCENE_PARAMS));
426 } // namespace V1_0
427 } // namespace AudioStandard
428 } // namespace OHOS
429