1 /*
2 * Copyright (c) 2024-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 "audio_policy_utils_unit_test.h"
17 #include "audio_errors.h"
18
19 using namespace testing;
20 using namespace testing::ext;
21
22 namespace OHOS {
23 namespace AudioStandard {
24
SetUp(void)25 void AudioPolicyUtilsUnitTest::SetUp(void) {}
26
TearDown(void)27 void AudioPolicyUtilsUnitTest::TearDown(void) {}
28
29 /**
30 * @tc.name : Test ErasePreferredDeviceByType API
31 * @tc.type : FUNC
32 * @tc.number: AudioPolicyUtilsUnitTest_001
33 * @tc.desc : Test ErasePreferredDeviceByType
34 */
35 HWTEST(AudioPolicyUtilsUnitTest, AudioPolicyUtilsUnitTest_001, TestSize.Level1)
36 {
37 AudioPolicyUtils* audioPolicyUtilsTest_ = nullptr;
38 audioPolicyUtilsTest_ = &AudioPolicyUtils::GetInstance();
39 ASSERT_TRUE(audioPolicyUtilsTest_ != nullptr);
40
41 PreferredType preferredType = AUDIO_MEDIA_RENDER;
42 audioPolicyUtilsTest_->isBTReconnecting_ = false;
43
44 int32_t ret = audioPolicyUtilsTest_->ErasePreferredDeviceByType(preferredType);
45 EXPECT_EQ(ret, SUCCESS);
46 }
47
48 /**
49 * @tc.name : Test GetNewSinkPortName API
50 * @tc.type : FUNC
51 * @tc.number: AudioPolicyUtilsUnitTest_002
52 * @tc.desc : Test GetNewSinkPortName
53 */
54 HWTEST(AudioPolicyUtilsUnitTest, AudioPolicyUtilsUnitTest_002, TestSize.Level1)
55 {
56 AudioPolicyUtils* audioPolicyUtilsTest_ = nullptr;
57 audioPolicyUtilsTest_ = &AudioPolicyUtils::GetInstance();
58 ASSERT_TRUE(audioPolicyUtilsTest_ != nullptr);
59
60 DeviceType deviceType = DeviceType::DEVICE_TYPE_ACCESSORY;
61
62 std::string ret = audioPolicyUtilsTest_->GetNewSinkPortName(deviceType);
63 EXPECT_EQ(ret, ACCESSORY_SOURCE);
64 }
65
66 /**
67 * @tc.name : Test GetNewSinkPortName API
68 * @tc.type : FUNC
69 * @tc.number: AudioPolicyUtilsUnitTest_003
70 * @tc.desc : Test GetNewSinkPortName
71 */
72 HWTEST(AudioPolicyUtilsUnitTest, AudioPolicyUtilsUnitTest_003, TestSize.Level1)
73 {
74 AudioPolicyUtils* audioPolicyUtilsTest_ = nullptr;
75 audioPolicyUtilsTest_ = &AudioPolicyUtils::GetInstance();
76 ASSERT_TRUE(audioPolicyUtilsTest_ != nullptr);
77
78 DeviceType deviceType = DeviceType::DEVICE_TYPE_HEARING_AID;
79
80 std::string ret = audioPolicyUtilsTest_->GetNewSinkPortName(deviceType);
81 EXPECT_EQ(ret, HEARING_AID_SPEAKER);
82 }
83
84 /**
85 * @tc.name : Test GetSinkName API
86 * @tc.type : FUNC
87 * @tc.number: AudioPolicyUtilsUnitTest_004
88 * @tc.desc : Test GetSinkName
89 */
90 HWTEST(AudioPolicyUtilsUnitTest, AudioPolicyUtilsUnitTest_004, TestSize.Level1)
91 {
92 AudioPolicyUtils* audioPolicyUtilsTest_ = nullptr;
93 audioPolicyUtilsTest_ = &AudioPolicyUtils::GetInstance();
94 ASSERT_TRUE(audioPolicyUtilsTest_ != nullptr);
95
96 int32_t descriptorType = 0;
97 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>(descriptorType);;
98 desc->networkId_ = LOCAL_NETWORK_ID;
99 desc->deviceType_ = DEVICE_TYPE_BLUETOOTH_SCO;
100 int32_t sessionId = 0;
101
102 std::string ret = audioPolicyUtilsTest_->GetSinkName(desc, sessionId);
103 EXPECT_EQ(ret, PRIMARY_SPEAKER);
104 }
105
106 /**
107 * @tc.name : Test GetSinkName API
108 * @tc.type : FUNC
109 * @tc.number: AudioPolicyUtilsUnitTest_005
110 * @tc.desc : Test GetSinkName
111 */
112 HWTEST(AudioPolicyUtilsUnitTest, AudioPolicyUtilsUnitTest_005, TestSize.Level1)
113 {
114 AudioPolicyUtils* audioPolicyUtilsTest_ = nullptr;
115 audioPolicyUtilsTest_ = &AudioPolicyUtils::GetInstance();
116 ASSERT_TRUE(audioPolicyUtilsTest_ != nullptr);
117
118 int32_t descriptorType = 0;
119 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>(descriptorType);;
120 desc->networkId_ = "";
121 desc->deviceRole_ = DeviceRole::OUTPUT_DEVICE;
122 int32_t sessionId = 0;
123 std::string test_result = "_out";
124
125 std::string ret = audioPolicyUtilsTest_->GetSinkName(desc, sessionId);
126 EXPECT_EQ(ret, test_result);
127 }
128
129 /**
130 * @tc.name : Test GetSourcePortName API
131 * @tc.type : FUNC
132 * @tc.number: AudioPolicyUtilsUnitTest_006
133 * @tc.desc : Test GetSourcePortName
134 */
135 HWTEST(AudioPolicyUtilsUnitTest, AudioPolicyUtilsUnitTest_006, TestSize.Level1)
136 {
137 AudioPolicyUtils* audioPolicyUtilsTest_ = nullptr;
138 audioPolicyUtilsTest_ = &AudioPolicyUtils::GetInstance();
139 ASSERT_TRUE(audioPolicyUtilsTest_ != nullptr);
140
141 DeviceType deviceType = DeviceType::DEVICE_TYPE_BLUETOOTH_A2DP_IN;
142
143 std::string ret = audioPolicyUtilsTest_->GetSourcePortName(deviceType);
144 EXPECT_EQ(ret, BLUETOOTH_MIC);
145 }
146
147 /**
148 * @tc.name : Test GetSourcePortName API
149 * @tc.type : FUNC
150 * @tc.number: AudioPolicyUtilsUnitTest_007
151 * @tc.desc : Test GetSourcePortName
152 */
153 HWTEST(AudioPolicyUtilsUnitTest, AudioPolicyUtilsUnitTest_007, TestSize.Level1)
154 {
155 AudioPolicyUtils* audioPolicyUtilsTest_ = nullptr;
156 audioPolicyUtilsTest_ = &AudioPolicyUtils::GetInstance();
157 ASSERT_TRUE(audioPolicyUtilsTest_ != nullptr);
158
159 DeviceType deviceType = DeviceType::DEVICE_TYPE_ACCESSORY;
160
161 std::string ret = audioPolicyUtilsTest_->GetSourcePortName(deviceType);
162 EXPECT_EQ(ret, ACCESSORY_SOURCE);
163 }
164
165 /**
166 * @tc.name : Test GetOutputDeviceClassBySinkPortName API
167 * @tc.type : FUNC
168 * @tc.number: AudioPolicyUtilsUnitTest_008
169 * @tc.desc : Test GetOutputDeviceClassBySinkPortName
170 */
171 HWTEST(AudioPolicyUtilsUnitTest, AudioPolicyUtilsUnitTest_008, TestSize.Level1)
172 {
173 AudioPolicyUtils* audioPolicyUtilsTest_ = nullptr;
174 audioPolicyUtilsTest_ = &AudioPolicyUtils::GetInstance();
175 ASSERT_TRUE(audioPolicyUtilsTest_ != nullptr);
176
177 std::string sinkPortName = BLUETOOTH_SPEAKER;
178
179 std::string ret = audioPolicyUtilsTest_->GetOutputDeviceClassBySinkPortName(sinkPortName);
180 EXPECT_EQ(ret, A2DP_CLASS);
181 }
182
183 /**
184 * @tc.name : Test GetInputDeviceClassBySourcePortName API
185 * @tc.type : FUNC
186 * @tc.number: AudioPolicyUtilsUnitTest_009
187 * @tc.desc : Test GetInputDeviceClassBySourcePortName
188 */
189 HWTEST(AudioPolicyUtilsUnitTest, AudioPolicyUtilsUnitTest_009, TestSize.Level1)
190 {
191 AudioPolicyUtils* audioPolicyUtilsTest_ = nullptr;
192 audioPolicyUtilsTest_ = &AudioPolicyUtils::GetInstance();
193 ASSERT_TRUE(audioPolicyUtilsTest_ != nullptr);
194
195 std::string sourcePortName = BLUETOOTH_MIC;
196
197 std::string ret = audioPolicyUtilsTest_->GetInputDeviceClassBySourcePortName(sourcePortName);
198 EXPECT_EQ(ret, A2DP_CLASS);
199 }
200
201 /**
202 * @tc.name : Test GetInputDeviceClassBySourcePortName API
203 * @tc.type : FUNC
204 * @tc.number: AudioPolicyUtilsUnitTest_010
205 * @tc.desc : Test GetInputDeviceClassBySourcePortName
206 */
207 HWTEST(AudioPolicyUtilsUnitTest, AudioPolicyUtilsUnitTest_010, TestSize.Level1)
208 {
209 AudioPolicyUtils* audioPolicyUtilsTest_ = nullptr;
210 audioPolicyUtilsTest_ = &AudioPolicyUtils::GetInstance();
211 ASSERT_TRUE(audioPolicyUtilsTest_ != nullptr);
212
213 std::string sourcePortName = "test";
214
215 std::string ret = audioPolicyUtilsTest_->GetInputDeviceClassBySourcePortName(sourcePortName);
216 EXPECT_EQ(ret, INVALID_CLASS);
217 }
218
219 /**
220 * @tc.name : Test GetDeviceType API
221 * @tc.type : FUNC
222 * @tc.number: AudioPolicyUtilsUnitTest_011
223 * @tc.desc : Test GetDeviceType
224 */
225 HWTEST(AudioPolicyUtilsUnitTest, AudioPolicyUtilsUnitTest_011, TestSize.Level1)
226 {
227 AudioPolicyUtils* audioPolicyUtilsTest_ = nullptr;
228 audioPolicyUtilsTest_ = &AudioPolicyUtils::GetInstance();
229 ASSERT_TRUE(audioPolicyUtilsTest_ != nullptr);
230
231 std::string deviceName = "Built_in_wakeup";
232
233 DeviceType ret = audioPolicyUtilsTest_->GetDeviceType(deviceName);
234 EXPECT_EQ(ret, DEVICE_TYPE_WAKEUP);
235 }
236
237 /**
238 * @tc.name : Test GetDeviceType API
239 * @tc.type : FUNC
240 * @tc.number: AudioPolicyUtilsUnitTest_012
241 * @tc.desc : Test GetDeviceType
242 */
243 HWTEST(AudioPolicyUtilsUnitTest, AudioPolicyUtilsUnitTest_012, TestSize.Level1)
244 {
245 AudioPolicyUtils* audioPolicyUtilsTest_ = nullptr;
246 audioPolicyUtilsTest_ = &AudioPolicyUtils::GetInstance();
247 ASSERT_TRUE(audioPolicyUtilsTest_ != nullptr);
248
249 std::string deviceName = "fifo_output";
250
251 DeviceType ret = audioPolicyUtilsTest_->GetDeviceType(deviceName);
252 EXPECT_EQ(ret, DEVICE_TYPE_BLUETOOTH_SCO);
253 }
254
255 /**
256 * @tc.name : Test GetDeviceType API
257 * @tc.type : FUNC
258 * @tc.number: AudioPolicyUtilsUnitTest_013
259 * @tc.desc : Test GetDeviceType
260 */
261 HWTEST(AudioPolicyUtilsUnitTest, AudioPolicyUtilsUnitTest_013, TestSize.Level1)
262 {
263 AudioPolicyUtils* audioPolicyUtilsTest_ = nullptr;
264 audioPolicyUtilsTest_ = &AudioPolicyUtils::GetInstance();
265 ASSERT_TRUE(audioPolicyUtilsTest_ != nullptr);
266
267 std::string deviceName = "fifo_input";
268
269 DeviceType ret = audioPolicyUtilsTest_->GetDeviceType(deviceName);
270 EXPECT_EQ(ret, DEVICE_TYPE_BLUETOOTH_SCO);
271 }
272
273 /**
274 * @tc.name : Test GetDeviceType API
275 * @tc.type : FUNC
276 * @tc.number: AudioPolicyUtilsUnitTest_014
277 * @tc.desc : Test GetDeviceType
278 */
279 HWTEST(AudioPolicyUtilsUnitTest, AudioPolicyUtilsUnitTest_014, TestSize.Level1)
280 {
281 AudioPolicyUtils* audioPolicyUtilsTest_ = nullptr;
282 audioPolicyUtilsTest_ = &AudioPolicyUtils::GetInstance();
283 ASSERT_TRUE(audioPolicyUtilsTest_ != nullptr);
284
285 std::string deviceName = "file_sink";
286
287 DeviceType ret = audioPolicyUtilsTest_->GetDeviceType(deviceName);
288 EXPECT_EQ(ret, DEVICE_TYPE_FILE_SINK);
289 }
290
291 /**
292 * @tc.name : Test GetDeviceType API
293 * @tc.type : FUNC
294 * @tc.number: AudioPolicyUtilsUnitTest_015
295 * @tc.desc : Test GetDeviceType
296 */
297 HWTEST(AudioPolicyUtilsUnitTest, AudioPolicyUtilsUnitTest_015, TestSize.Level1)
298 {
299 AudioPolicyUtils* audioPolicyUtilsTest_ = nullptr;
300 audioPolicyUtilsTest_ = &AudioPolicyUtils::GetInstance();
301 ASSERT_TRUE(audioPolicyUtilsTest_ != nullptr);
302
303 std::string deviceName = "test";
304
305 DeviceType ret = audioPolicyUtilsTest_->GetDeviceType(deviceName);
306 EXPECT_EQ(ret, DEVICE_TYPE_NONE);
307 }
308
309 /**
310 * @tc.name : Test UnexcludeOutputDevices API
311 * @tc.type : FUNC
312 * @tc.number: AudioPolicyUtilsUnitTest_016
313 * @tc.desc : Test UnexcludeOutputDevices
314 */
315 HWTEST(AudioPolicyUtilsUnitTest, AudioPolicyUtilsUnitTest_016, TestSize.Level1)
316 {
317 AudioPolicyUtils* audioPolicyUtilsTest_ = nullptr;
318 audioPolicyUtilsTest_ = &AudioPolicyUtils::GetInstance();
319 ASSERT_TRUE(audioPolicyUtilsTest_ != nullptr);
320
321 std::vector<std::shared_ptr<AudioDeviceDescriptor>> descs;
322 audioPolicyUtilsTest_->isBTReconnecting_ = true;
323
324 int32_t ret = audioPolicyUtilsTest_->UnexcludeOutputDevices(descs);
325 EXPECT_EQ(ret, SUCCESS);
326 }
327
328 } // namespace AudioStandard
329 } // namespace OHOS
330