1 /*
2 * Copyright (c) 2022-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 #include <cstddef>
16 #include <cstdint>
17
18 #include <gtest/gtest.h>
19 #include "audio_adapter.h"
20 #include "avsession_errors.h"
21 #include "avsession_log.h"
22 #include "audio_info.h"
23 #include "audio_device_info.h"
24
25 using namespace testing::ext;
26 using namespace OHOS::AVSession;
27 using OHOS::AudioStandard::AudioRendererChangeInfo;
28 using OHOS::AudioStandard::RendererState;
29
30 class AudioAdapterTest : public testing::Test {
31 public:
32 static void SetUpTestCase(void);
33 static void TearDownTestCase(void);
34 void SetUp();
35 void TearDown();
36
37 static constexpr int32_t TEST_CLIENT_UID = 1;
38 static constexpr int32_t TEST_CLIENT_PID = 1;
39 static constexpr int32_t TEST_SESSION_ID = 2;
40 static constexpr int32_t TEST_SESSION_FAIL_ID = -1;
41 };
42
SetUpTestCase()43 void AudioAdapterTest::SetUpTestCase()
44 {}
45
TearDownTestCase()46 void AudioAdapterTest::TearDownTestCase()
47 {}
48
SetUp()49 void AudioAdapterTest::SetUp()
50 {}
51
TearDown()52 void AudioAdapterTest::TearDown()
53 {}
54
55 /**
56 * @tc.name: OnRendererStateChange001
57 * @tc.desc: verifying the renderer state listener
58 * @tc.type: FUNC
59 * @tc.require: AR000H31KJ
60 */
61 static HWTEST(AudioAdapterTest, OnRendererStateChange001, TestSize.Level1)
62 {
63 SLOGI("OnRendererStateChange001 begin!");
64 std::shared_ptr<AudioRendererChangeInfo> info = std::make_shared<AudioRendererChangeInfo>();
65 info->clientUID = AudioAdapterTest::TEST_CLIENT_UID;
66 info->sessionId = AudioAdapterTest::TEST_SESSION_ID;
67 info->rendererState = RendererState::RENDERER_RELEASED;
68 AudioRendererChangeInfos infosExpected;
69 infosExpected.push_back(std::move(info));
70 AudioRendererChangeInfos infosActual;
71
72 AudioAdapter::GetInstance().Init();
__anon06f70b8f0102(const AudioRendererChangeInfos& infos) 73 AudioAdapter::GetInstance().AddStreamRendererStateListener([&infosActual](const AudioRendererChangeInfos& infos) {
74 SLOGI("AddStreamRendererStateListener start!");
75 for (const auto& info : infos) {
76 std::shared_ptr<AudioRendererChangeInfo> infoActual = std::make_shared<AudioRendererChangeInfo>();
77 *infoActual = *info;
78 infosActual.push_back(std::move(infoActual));
79 }
80 SLOGI("AddStreamRendererStateListener end!");
81 });
82 AudioAdapter::GetInstance().OnRendererStateChange(infosExpected);
83
84 ASSERT_NE(infosActual.size(), 0);
85 const auto& infoExpected = infosExpected[0];
86 const auto& infoActual = infosActual[0];
87 EXPECT_EQ(infoExpected->clientUID, infoActual->clientUID);
88 EXPECT_EQ(infoExpected->sessionId, infoActual->sessionId);
89 EXPECT_EQ(infoExpected->rendererState, infoActual->rendererState);
90 SLOGI("OnRendererStateChange001 end!");
91 }
92
93 /**
94 * @tc.name: MuteAudioStream001
95 * @tc.desc: mute audio stream for valid uid TEST_CLIENT_UID
96 * @tc.type: FUNC
97 * @tc.require: AR000H31KJ
98 */
99 static HWTEST(AudioAdapterTest, MuteAudioStream001, TestSize.Level1)
100 {
101 SLOGI("MuteAudioStream001 begin!");
102 std::shared_ptr<AudioRendererChangeInfo> info = std::make_shared<AudioRendererChangeInfo>();
103 info->clientUID = AudioAdapterTest::TEST_CLIENT_UID;
104 info->clientPid = AudioAdapterTest::TEST_CLIENT_PID;
105 info->sessionId = AudioAdapterTest::TEST_SESSION_ID;
106 info->rendererState = RendererState::RENDERER_RELEASED;
107 AudioRendererChangeInfos infosExpected;
108 infosExpected.push_back(std::move(info));
109 AudioRendererChangeInfos infosActual;
110
111 AudioAdapter::GetInstance().Init();
__anon06f70b8f0202(const AudioRendererChangeInfos& infos) 112 AudioAdapter::GetInstance().AddStreamRendererStateListener([&infosActual](const AudioRendererChangeInfos& infos) {
113 SLOGI("AddStreamRendererStateListener start!");
114 for (const auto& info : infos) {
115 std::shared_ptr<AudioRendererChangeInfo> infoActual = std::make_shared<AudioRendererChangeInfo>();
116 *infoActual = *info;
117 infosActual.push_back(std::move(infoActual));
118 }
119 SLOGI("AddStreamRendererStateListener end!");
120 });
121 auto ret = AudioAdapter::GetInstance().MuteAudioStream(AudioAdapterTest::TEST_CLIENT_UID,
122 AudioAdapterTest::TEST_CLIENT_PID);
123 EXPECT_NE(ret, AVSESSION_ERROR_BASE);
124
125 ret = AudioAdapter::GetInstance().MuteAudioStream(AudioAdapterTest::TEST_SESSION_FAIL_ID,
126 AudioAdapterTest::TEST_SESSION_FAIL_ID);
127 EXPECT_NE(ret, AVSESSION_ERROR_BASE);
128 }
129
130 /**
131 * @tc.name: MuteAudioStream002
132 * @tc.desc: mute audio stream for valid uid TEST_CLIENT_UID
133 * @tc.type: FUNC
134 */
135 static HWTEST(AudioAdapterTest, MuteAudioStream002, TestSize.Level1)
136 {
137 SLOGI("MuteAudioStream002 begin!");
138 std::shared_ptr<AudioRendererChangeInfo> info = std::make_shared<AudioRendererChangeInfo>();
139 info->clientUID = AudioAdapterTest::TEST_CLIENT_UID;
140 info->clientPid = AudioAdapterTest::TEST_CLIENT_PID;
141 info->sessionId = AudioAdapterTest::TEST_SESSION_ID;
142 info->rendererState = RendererState::RENDERER_RELEASED;
143 AudioRendererChangeInfos infosExpected;
144 infosExpected.push_back(std::move(info));
145 AudioRendererChangeInfos infosActual;
146
147 AudioAdapter::GetInstance().Init();
__anon06f70b8f0302(const AudioRendererChangeInfos& infos) 148 AudioAdapter::GetInstance().AddStreamRendererStateListener([&infosActual](const AudioRendererChangeInfos& infos) {
149 SLOGI("AddStreamRendererStateListener start!");
150 for (const auto& info : infos) {
151 std::shared_ptr<AudioRendererChangeInfo> infoActual = std::make_shared<AudioRendererChangeInfo>();
152 *infoActual = *info;
153 infosActual.push_back(std::move(infoActual));
154 }
155 SLOGI("AddStreamRendererStateListener end!");
156 });
157 auto ret = AudioAdapter::GetInstance().MuteAudioStream(AudioAdapterTest::TEST_CLIENT_UID,
158 OHOS::AudioStandard::StreamUsage::STREAM_USAGE_INVALID);
159 EXPECT_EQ(ret, AVSESSION_ERROR);
160
161 ret = AudioAdapter::GetInstance().MuteAudioStream(AudioAdapterTest::TEST_CLIENT_UID,
162 OHOS::AudioStandard::StreamUsage::STREAM_USAGE_MUSIC);
163 EXPECT_EQ(ret, AVSESSION_SUCCESS);
164 }
165
166 /**
167 * @tc.name: MuteAudioStream003
168 * @tc.desc: mute audio stream for valid uid TEST_CLIENT_UID
169 * @tc.type: FUNC
170 * @tc.require: AR000H31KJ
171 */
172 static HWTEST(AudioAdapterTest, MuteAudioStream003, TestSize.Level1)
173 {
174 SLOGI("MuteAudioStream003 begin!");
175 std::shared_ptr<AudioRendererChangeInfo> info = std::make_shared<AudioRendererChangeInfo>();
176 info->clientUID = AudioAdapterTest::TEST_CLIENT_UID;
177 info->clientPid = AudioAdapterTest::TEST_CLIENT_PID;
178 info->sessionId = AudioAdapterTest::TEST_SESSION_ID;
179 info->rendererState = RendererState::RENDERER_RELEASED;
180 AudioRendererChangeInfos infosExpected;
181 infosExpected.push_back(std::move(info));
182 AudioRendererChangeInfos infosActual;
183
184 AudioAdapter::GetInstance().Init();
__anon06f70b8f0402(const AudioRendererChangeInfos& infos) 185 AudioAdapter::GetInstance().AddStreamRendererStateListener([&infosActual](const AudioRendererChangeInfos& infos) {
186 SLOGI("AddStreamRendererStateListener start!");
187 for (const auto& info : infos) {
188 std::shared_ptr<AudioRendererChangeInfo> infoActual = std::make_shared<AudioRendererChangeInfo>();
189 *infoActual = *info;
190 infosActual.push_back(std::move(infoActual));
191 }
192 SLOGI("AddStreamRendererStateListener end!");
193 });
194 auto& audioAdapter = AudioAdapter::GetInstance();
195 audioAdapter.is2in1_ = true;
196 auto ret = audioAdapter.MuteAudioStream(AudioAdapterTest::TEST_CLIENT_UID,
197 OHOS::AudioStandard::StreamUsage::STREAM_USAGE_INVALID);
198 EXPECT_EQ(ret, AVSESSION_ERROR);
199 }
200
201 /**
202 * @tc.name: MuteAudioStream004
203 * @tc.desc: mute audio stream for valid uid TEST_CLIENT_UID
204 * @tc.type: FUNC
205 * @tc.require: AR000H31KJ
206 */
207 static HWTEST(AudioAdapterTest, MuteAudioStream004, TestSize.Level1)
208 {
209 SLOGI("MuteAudioStream004 begin!");
210 std::shared_ptr<AudioRendererChangeInfo> info = std::make_shared<AudioRendererChangeInfo>();
211 info->clientUID = AudioAdapterTest::TEST_CLIENT_UID;
212 info->clientPid = AudioAdapterTest::TEST_CLIENT_PID;
213 info->sessionId = AudioAdapterTest::TEST_SESSION_ID;
214 info->rendererState = RendererState::RENDERER_RELEASED;
215 AudioRendererChangeInfos infosExpected;
216 infosExpected.push_back(std::move(info));
217 AudioRendererChangeInfos infosActual;
218
219 AudioAdapter::GetInstance().Init();
__anon06f70b8f0502(const AudioRendererChangeInfos& infos) 220 AudioAdapter::GetInstance().AddStreamRendererStateListener([&infosActual](const AudioRendererChangeInfos& infos) {
221 SLOGI("AddStreamRendererStateListener start!");
222 for (const auto& info : infos) {
223 std::shared_ptr<AudioRendererChangeInfo> infoActual = std::make_shared<AudioRendererChangeInfo>();
224 *infoActual = *info;
225 infosActual.push_back(std::move(infoActual));
226 }
227 SLOGI("AddStreamRendererStateListener end!");
228 });
229 auto& audioAdapter = AudioAdapter::GetInstance();
230 audioAdapter.is2in1_ = true;
231 auto ret = audioAdapter.MuteAudioStream(AudioAdapterTest::TEST_SESSION_FAIL_ID,
232 AudioAdapterTest::TEST_SESSION_FAIL_ID);
233 EXPECT_EQ(ret, AVSESSION_ERROR);
234 }
235
236 /**
237 * @tc.name: UnMuteAudioStream001
238 * @tc.desc: unmute audio stream for valid uid TEST_CLIENT_UID
239 * @tc.type: FUNC
240 * @tc.require: AR000H31KJ
241 */
242 static HWTEST(AudioAdapterTest, UnMuteAudioStream001, TestSize.Level1)
243 {
244 SLOGI("UnMuteAudioStream001 begin!");
245 std::shared_ptr<AudioRendererChangeInfo> info = std::make_shared<AudioRendererChangeInfo>();
246 info->clientUID = AudioAdapterTest::TEST_CLIENT_UID;
247 info->sessionId = AudioAdapterTest::TEST_SESSION_ID;
248 info->rendererState = RendererState::RENDERER_RELEASED;
249 AudioRendererChangeInfos infosExpected;
250 infosExpected.push_back(std::move(info));
251 AudioRendererChangeInfos infosActual;
252
253 AudioAdapter::GetInstance().Init();
__anon06f70b8f0602(const AudioRendererChangeInfos& infos) 254 AudioAdapter::GetInstance().AddStreamRendererStateListener([&infosActual](const AudioRendererChangeInfos& infos) {
255 SLOGI("AddStreamRendererStateListener start!");
256 for (const auto& info : infos) {
257 std::shared_ptr<AudioRendererChangeInfo> infoActual = std::make_shared<AudioRendererChangeInfo>();
258 *infoActual = *info;
259 infosActual.push_back(std::move(infoActual));
260 }
261 SLOGI("AddStreamRendererStateListener end!");
262 });
263 auto ret = AudioAdapter::GetInstance().UnMuteAudioStream(AudioAdapterTest::TEST_CLIENT_UID);
264 EXPECT_NE(ret, AVSESSION_ERROR_BASE);
265 }
266
267 /**
268 * @tc.name: UnMuteAudioStream002
269 * @tc.desc: unmute audio stream for valid uid TEST_CLIENT_UID
270 * @tc.type: FUNC
271 * @tc.require: AR000H31KJ
272 */
273 static HWTEST(AudioAdapterTest, UnMuteAudioStream002, TestSize.Level1)
274 {
275 SLOGI("UnMuteAudioStream002 begin!");
276 std::shared_ptr<AudioRendererChangeInfo> info = std::make_shared<AudioRendererChangeInfo>();
277 info->clientUID = AudioAdapterTest::TEST_CLIENT_UID;
278 info->sessionId = AudioAdapterTest::TEST_SESSION_ID;
279 info->rendererState = RendererState::RENDERER_RELEASED;
280 AudioRendererChangeInfos infosExpected;
281 infosExpected.push_back(std::move(info));
282 AudioRendererChangeInfos infosActual;
283
284 AudioAdapter::GetInstance().Init();
__anon06f70b8f0702(const AudioRendererChangeInfos& infos) 285 AudioAdapter::GetInstance().AddStreamRendererStateListener([&infosActual](const AudioRendererChangeInfos& infos) {
286 SLOGI("AddStreamRendererStateListener start!");
287 for (const auto& info : infos) {
288 std::shared_ptr<AudioRendererChangeInfo> infoActual = std::make_shared<AudioRendererChangeInfo>();
289 *infoActual = *info;
290 infosActual.push_back(std::move(infoActual));
291 }
292 SLOGI("AddStreamRendererStateListener end!");
293 });
294 auto& audioAdapter = AudioAdapter::GetInstance();
295 audioAdapter.is2in1_ = true;
296 auto ret = audioAdapter.UnMuteAudioStream(AudioAdapterTest::TEST_CLIENT_UID,
297 OHOS::AudioStandard::StreamUsage::STREAM_USAGE_INVALID);
298 EXPECT_EQ(ret, AVSESSION_ERROR);
299 }
300
301 /**
302 * @tc.name: UnMuteAudioStream003
303 * @tc.desc: unmute audio stream for valid uid TEST_CLIENT_UID
304 * @tc.type: FUNC
305 * @tc.require: AR000H31KJ
306 */
307 static HWTEST(AudioAdapterTest, UnMuteAudioStream003, TestSize.Level1)
308 {
309 SLOGI("UnMuteAudioStream003 begin!");
310 std::shared_ptr<AudioRendererChangeInfo> info = std::make_shared<AudioRendererChangeInfo>();
311 info->clientUID = AudioAdapterTest::TEST_CLIENT_UID;
312 info->sessionId = AudioAdapterTest::TEST_SESSION_ID;
313 info->rendererState = RendererState::RENDERER_RELEASED;
314 AudioRendererChangeInfos infosExpected;
315 infosExpected.push_back(std::move(info));
316 AudioRendererChangeInfos infosActual;
317
318 AudioAdapter::GetInstance().Init();
__anon06f70b8f0802(const AudioRendererChangeInfos& infos) 319 AudioAdapter::GetInstance().AddStreamRendererStateListener([&infosActual](const AudioRendererChangeInfos& infos) {
320 SLOGI("AddStreamRendererStateListener start!");
321 for (const auto& info : infos) {
322 std::shared_ptr<AudioRendererChangeInfo> infoActual = std::make_shared<AudioRendererChangeInfo>();
323 *infoActual = *info;
324 infosActual.push_back(std::move(infoActual));
325 }
326 SLOGI("AddStreamRendererStateListener end!");
327 });
328 auto& audioAdapter = AudioAdapter::GetInstance();
329 audioAdapter.is2in1_ = true;
330 auto ret = audioAdapter.UnMuteAudioStream(AudioAdapterTest::TEST_CLIENT_UID);
331 EXPECT_EQ(ret, AVSESSION_ERROR);
332 }
333
334 /**
335 * @tc.name: UnMuteAudioStream004
336 * @tc.desc: unmute audio stream for valid uid TEST_CLIENT_UID
337 * @tc.type: FUNC
338 * @tc.require: AR000H31KJ
339 */
340 static HWTEST(AudioAdapterTest, UnMuteAudioStream004, TestSize.Level1)
341 {
342 SLOGI("UnMuteAudioStream004 begin!");
343 std::shared_ptr<AudioRendererChangeInfo> info = std::make_shared<AudioRendererChangeInfo>();
344 info->clientUID = AudioAdapterTest::TEST_CLIENT_UID;
345 info->sessionId = AudioAdapterTest::TEST_SESSION_ID;
346 info->rendererState = RendererState::RENDERER_RELEASED;
347 AudioRendererChangeInfos infosExpected;
348 infosExpected.push_back(std::move(info));
349 AudioRendererChangeInfos infosActual;
350
351 AudioAdapter::GetInstance().Init();
__anon06f70b8f0902(const AudioRendererChangeInfos& infos) 352 AudioAdapter::GetInstance().AddStreamRendererStateListener([&infosActual](const AudioRendererChangeInfos& infos) {
353 SLOGI("AddStreamRendererStateListener start!");
354 for (const auto& info : infos) {
355 std::shared_ptr<AudioRendererChangeInfo> infoActual = std::make_shared<AudioRendererChangeInfo>();
356 *infoActual = *info;
357 infosActual.push_back(std::move(infoActual));
358 }
359 SLOGI("AddStreamRendererStateListener end!");
360 });
361 auto& audioAdapter = AudioAdapter::GetInstance();
362 auto ret = audioAdapter.UnMuteAudioStream(AudioAdapterTest::TEST_CLIENT_UID,
363 OHOS::AudioStandard::StreamUsage::STREAM_USAGE_INVALID);
364 EXPECT_EQ(ret, AVSESSION_SUCCESS);
365 }
366
367 /**
368 * @tc.name: GetRendererRunning001
369 * @tc.desc: Test GetRendererRunning
370 * @tc.type: FUNC
371 * @tc.require: AR000H31KJ
372 */
373 static HWTEST(AudioAdapterTest, GetRendererRunning001, TestSize.Level1)
374 {
375 SLOGI("GetRendererRunning001 begin!");
376 AudioAdapter::GetInstance().Init();
377 AudioAdapter::GetInstance().GetRendererRunning(AudioAdapterTest::TEST_CLIENT_UID);
378 SLOGI("GetRendererRunning001 end!");
379 }
380
381 /**
382 * @tc.name: GetRendererRunning002
383 * @tc.desc: Test GetRendererRunning
384 * @tc.type: FUNC
385 * @tc.require: AR000H31KJ
386 */
387 static HWTEST(AudioAdapterTest, GetRendererRunning002, TestSize.Level1)
388 {
389 SLOGI("GetRendererRunning002 begin!");
390 AudioAdapter::GetInstance().Init();
391 AudioAdapter::GetInstance().GetRendererRunning(AudioAdapterTest::TEST_SESSION_FAIL_ID);
392 SLOGI("GetRendererRunning002 end!");
393 }
394
395 /**
396 * @tc.name: PauseAudioStream001
397 * @tc.desc: Test GetRendererRunning
398 * @tc.type: FUNC
399 * @tc.require: AR000H31KJ
400 */
401 static HWTEST(AudioAdapterTest, PauseAudioStream001, TestSize.Level1)
402 {
403 SLOGD("PauseAudioStream001 begin!");
404 AudioAdapter::GetInstance().Init();
405 int32_t uid = 10001;
406 OHOS::AudioStandard::StreamUsage streamUsage {};
407 int32_t ret = AudioAdapter::GetInstance().PauseAudioStream(uid, streamUsage);
408 EXPECT_EQ(ret, AVSESSION_SUCCESS);
409 SLOGD("PauseAudioStream001 end!");
410 }
411
412 /**
413 * @tc.name: OnDeviceChange001
414 * @tc.desc: Test OnDeviceChange
415 * @tc.type: FUNC
416 */
417 static HWTEST(AudioAdapterTest, OnDeviceChange001, TestSize.Level1)
418 {
419 SLOGD("PauseAudioStream001 begin!");
420 bool ret = false;
421 AudioAdapter::GetInstance().AddDeviceChangeListener(
__anon06f70b8f0a02(const AudioDeviceDescriptorsWithSptr &desc) 422 [&ret] (const AudioDeviceDescriptorsWithSptr &desc) {
423 ret = desc.empty();
424 });
425 AudioAdapter::GetInstance().AddDeviceChangeListener(nullptr);
426
427 DeviceChangeAction action = {};
428 action.type = OHOS::AudioStandard::DeviceChangeType::CONNECT;
429 AudioAdapter::GetInstance().OnDeviceChange(action);
430 EXPECT_FALSE(ret);
431 }
432
433 /**
434 * @tc.name: OnPreferredOutputDeviceUpdated001
435 * @tc.desc: Notify registered listeners when the preferred audio output device is updated.
436 * This method iterates through all registered listeners and calls their callback functions
437 * with the updated device descriptor.
438 * @tc.type: FUNC
439 * @tc.require: AR000H31KJ
440 */
441 static HWTEST(AudioAdapterTest, OnPreferredOutputDeviceUpdated001, TestSize.Level1)
442 {
443 SLOGD("OnPreferredOutputDeviceUpdated001 begin!");
444 bool ret = false;
445 AudioAdapter::GetInstance().AddDeviceChangeListener(
__anon06f70b8f0b02(const AudioDeviceDescriptorsWithSptr &desc) 446 [&ret] (const AudioDeviceDescriptorsWithSptr &desc) {
447 ret = desc.empty();
448 });
449 AudioAdapter::GetInstance().Init();
450 auto& audioAdapter = AudioAdapter::GetInstance();
451 AudioDeviceDescriptorsWithSptr desc = audioAdapter.GetAvailableDevices();
452 audioAdapter.deviceChangeListeners_ =
453 std::vector<OHOS::AVSession::AudioAdapter::PreferOutputDeviceChangeListener>();
454 audioAdapter.OnPreferredOutputDeviceUpdated(desc);
455 EXPECT_FALSE(ret);
456 }
457
458 /**
459 * @tc.name: SelectOutputDevice001
460 * @tc.desc: Test SelectOutputDevice with a valid device descriptor that matches one available device.
461 * @tc.type: FUNC
462 * @tc.require: AR000H31KJ
463 */
464 static HWTEST(AudioAdapterTest, SelectOutputDevice001, TestSize.Level1)
465 {
466 SLOGD("SelectOutputDevice001 begin!");
467 AudioAdapter::GetInstance().Init();
468 auto& audioAdapter = AudioAdapter::GetInstance();
469 AudioDeviceDescriptorWithSptr desc {new OHOS::AudioStandard::AudioDeviceDescriptor()};
470 auto ret = audioAdapter.SelectOutputDevice(desc);
471 EXPECT_EQ(ret, AVSESSION_ERROR);
472 }
473
474 /**
475 * @tc.name: SelectOutputDevice002
476 * @tc.desc: Test SelectOutputDevice with a valid device descriptor that matches one available device.
477 * @tc.type: FUNC
478 * @tc.require: AR000H31KJ
479 */
480 static HWTEST(AudioAdapterTest, SelectOutputDevice002, TestSize.Level1)
481 {
482 SLOGD("SelectOutputDevice002 begin!");
483 AudioAdapter::GetInstance().Init();
484 auto& audioAdapter = AudioAdapter::GetInstance();
485 AudioDeviceDescriptorsWithSptr availableDevices = audioAdapter.GetAvailableDevices();
486
487 CHECK_AND_RETURN_LOG(availableDevices.size() > 0, "No available devices for testing");
488 auto testDevice = availableDevices[0];
489 AudioDeviceDescriptorWithSptr desc {new OHOS::AudioStandard::AudioDeviceDescriptor()};
490 desc->deviceCategory_ = testDevice->deviceCategory_;
491 desc->deviceType_ = testDevice->deviceType_;
492 int32_t ret = audioAdapter.SelectOutputDevice(desc);
493 EXPECT_EQ(ret, AVSESSION_SUCCESS);
494 }
495
496 /**
497 * @tc.name: SelectOutputDevice003
498 * @tc.desc: Test SelectOutputDevice with a valid device descriptor that matches one available device.
499 * @tc.type: FUNC
500 * @tc.require: AR000H31KJ
501 */
502 static HWTEST(AudioAdapterTest, SelectOutputDevice003, TestSize.Level1)
503 {
504 SLOGD("SelectOutputDevice003 begin!");
505 AudioAdapter::GetInstance().Init();
506 auto& audioAdapter = AudioAdapter::GetInstance();
507 AudioDeviceDescriptorsWithSptr availableDevices = audioAdapter.GetAvailableDevices();
508
509 CHECK_AND_RETURN_LOG(availableDevices.size() > 0, "No available devices for testing");
510 auto testDevice = availableDevices[0];
511 AudioDeviceDescriptorWithSptr desc {new OHOS::AudioStandard::AudioDeviceDescriptor()};
512 desc->deviceCategory_ = testDevice->deviceCategory_;
513 EXPECT_NE(desc->deviceType_, testDevice->deviceType_);
514 int32_t ret = audioAdapter.SelectOutputDevice(desc);
515 EXPECT_EQ(ret, AVSESSION_ERROR);
516 }
517
518 /**
519 * @tc.name: SelectOutputDevice004
520 * @tc.desc: Test SelectOutputDevice with a valid device descriptor that matches one available device.
521 * @tc.type: FUNC
522 * @tc.require: AR000H31KJ
523 */
524 static HWTEST(AudioAdapterTest, SelectOutputDevice004, TestSize.Level1)
525 {
526 SLOGD("SelectOutputDevice004 begin!");
527 AudioAdapter::GetInstance().Init();
528 auto& audioAdapter = AudioAdapter::GetInstance();
529 AudioDeviceDescriptorsWithSptr availableDevices = audioAdapter.GetAvailableDevices();
530
531 CHECK_AND_RETURN_LOG(availableDevices.size() > 0, "No available devices for testing");
532 auto testDevice = availableDevices[0];
533 AudioDeviceDescriptorWithSptr desc {new OHOS::AudioStandard::AudioDeviceDescriptor()};
534 desc->deviceType_ = testDevice->deviceType_;
535 desc->deviceCategory_ = OHOS::AudioStandard::BT_HEADPHONE;
536
537 EXPECT_NE(desc->deviceCategory_, testDevice->deviceCategory_);
538 int32_t ret = audioAdapter.SelectOutputDevice(desc);
539 EXPECT_EQ(ret, AVSESSION_SUCCESS);
540 }