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