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 EXPECT_EQ(mute, AudioSystemManager::GetInstance()->IsMicrophoneMute());
312 }
313
314 INSTANTIATE_TEST_SUITE_P(
315 IsMicrophoneMute,
316 AudioPolicyGetMicrophoneMuteTest,
317 ValuesIn(MIC_MUTE_PARAMS));
318
319 /*
320 * Check volume range
321 *
322 */
323 class AudioPolicyVolumeRangeTest : public AudioPolicyTest {};
324
325 HWTEST_P(AudioPolicyVolumeRangeTest, GetMaxVolume, TestSize.Level1)
326 {
327 PolicyParam params = GetParam();
328 AudioVolumeType volumeType
329 = static_cast<AudioVolumeType>(params.streamType);
330 EXPECT_EQ(15, AudioSystemManager::GetInstance()->GetMaxVolume(volumeType));
331 }
332
333 HWTEST_P(AudioPolicyVolumeRangeTest, GetMinVolume, TestSize.Level1)
334 {
335 PolicyParam params = GetParam();
336 AudioVolumeType volumeType
337 = static_cast<AudioVolumeType>(params.streamType);
338 EXPECT_EQ(0, AudioSystemManager::GetInstance()->GetMinVolume(volumeType));
339 }
340
341 INSTANTIATE_TEST_SUITE_P(
342 GetMaxVolume,
343 AudioPolicyVolumeRangeTest,
344 ValuesIn(VOLUME_RANGE_PARAMS));
345
346 INSTANTIATE_TEST_SUITE_P(
347 GetMinVolume,
348 AudioPolicyVolumeRangeTest,
349 ValuesIn(VOLUME_RANGE_PARAMS));
350
351 /*
352 * Check volume range
353 *
354 */
355 class AudioPolicyAudioParameterTest : public AudioPolicyTest {};
356
357 HWTEST_P(AudioPolicyAudioParameterTest, SetAudioParameter, TestSize.Level1)
358 {
359 PolicyParam params = GetParam();
360 AudioSystemManager::GetInstance()->SetAudioParameter(params.key, params.value);
361 EXPECT_EQ(params.value, AudioSystemManager::GetInstance()->GetAudioParameter(params.key));
362 }
363
364 INSTANTIATE_TEST_SUITE_P(
365 SetAudioParameter,
366 AudioPolicyAudioParameterTest,
367 ValuesIn(AUDIO_PARAMS));
368
369 HWTEST_P(AudioPolicyAudioParameterTest, GetAudioParameter, TestSize.Level1)
370 {
371 PolicyParam params = GetParam();
372 AudioSystemManager::GetInstance()->SetAudioParameter(params.key, params.value);
373 EXPECT_EQ(params.value, AudioSystemManager::GetInstance()->GetAudioParameter(params.key));
374 }
375
376 INSTANTIATE_TEST_SUITE_P(
377 GetAudioParameter,
378 AudioPolicyAudioParameterTest,
379 ValuesIn(AUDIO_PARAMS));
380
381 /*
382 * Check set audio scene
383 *
384 */
385 class AudioPolicySetAudioSceneTest : public AudioPolicyTest {};
386
387 HWTEST_P(AudioPolicySetAudioSceneTest, SetAudioScene, TestSize.Level1)
388 {
389 PolicyParam params = GetParam();
390 AudioScene scene = params.audioScene;
391 int32_t ret = AudioSystemManager::GetInstance()->SetAudioScene(scene);
392 EXPECT_EQ(SUCCESS, ret);
393 ret = AudioSystemManager::GetInstance()->SetAudioScene(AUDIO_SCENE_DEFAULT);
394 EXPECT_EQ(SUCCESS, ret);
395 }
396
397 INSTANTIATE_TEST_SUITE_P(
398 SetAudioScene,
399 AudioPolicySetAudioSceneTest,
400 ValuesIn(AUDIO_SCENE_PARAMS));
401
402 /*
403 * Check get audio scene
404 *
405 */
406 class AudioPolicyGetAudioSceneTest : public AudioPolicyTest {};
407
408 HWTEST_P(AudioPolicyGetAudioSceneTest, GetAudioScene, TestSize.Level1)
409 {
410 PolicyParam params = GetParam();
411 AudioScene scene = params.audioScene;
412 EXPECT_EQ(AudioSystemManager::GetInstance()->GetAudioScene(), AUDIO_SCENE_DEFAULT);
413
414 int32_t ret = AudioSystemManager::GetInstance()->SetAudioScene(scene);
415 EXPECT_EQ(SUCCESS, ret);
416
417 EXPECT_EQ(AudioSystemManager::GetInstance()->GetAudioScene(), scene);
418
419 ret = AudioSystemManager::GetInstance()->SetAudioScene(AUDIO_SCENE_DEFAULT);
420 EXPECT_EQ(SUCCESS, ret);
421 }
422
423 INSTANTIATE_TEST_SUITE_P(
424 GetAudioScene,
425 AudioPolicyGetAudioSceneTest,
426 ValuesIn(AUDIO_SCENE_PARAMS));
427 } // namespace V1_0
428 } // namespace AudioStandard
429 } // namespace OHOS
430