1 /*
2 * Copyright (c) 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 "audio_policy_utils.h"
16 #include "audio_pipe_selector_unit_test.h"
17 #include "audio_stream_descriptor.h"
18 #include "audio_stream_descriptor.h"
19 #include "audio_stream_enum.h"
20
21 using namespace testing::ext;
22
23 namespace OHOS {
24 namespace AudioStandard {
25
SetUpTestCase(void)26 void AudioPipeSelectorUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)27 void AudioPipeSelectorUnitTest::TearDownTestCase(void) {}
SetUp(void)28 void AudioPipeSelectorUnitTest::SetUp(void) {}
TearDown(void)29 void AudioPipeSelectorUnitTest::TearDown(void) {}
30
31 /**
32 * @tc.name: GetPipeType_001
33 * @tc.desc: Test GetPipeType when audioMode is AUDIO_MODE_PLAYBACK and flag contains
34 * AUDIO_OUTPUT_FLAG_FAST and AUDIO_OUTPUT_FLAG_VOIP.
35 * @tc.type: FUNC
36 * @tc.require: #I5Y4MZ
37 */
38 HWTEST_F(AudioPipeSelectorUnitTest, GetPipeType_001, TestSize.Level1)
39 {
40 uint32_t flag = AUDIO_OUTPUT_FLAG_FAST | AUDIO_OUTPUT_FLAG_VOIP;
41 AudioMode audioMode = AUDIO_MODE_PLAYBACK;
42 AudioPipeType result = AudioPipeSelector::GetPipeSelector()->GetPipeType(flag, audioMode);
43 EXPECT_EQ(result, PIPE_TYPE_CALL_OUT);
44 }
45
46 /**
47 * @tc.name: GetPipeType_002
48 * @tc.desc: Test GetPipeType when audioMode is AUDIO_MODE_PLAYBACK and flag contains AUDIO_OUTPUT_FLAG_FAST.
49 * @tc.type: FUNC
50 * @tc.require: #I5Y4MZ
51 */
52 HWTEST_F(AudioPipeSelectorUnitTest, GetPipeType_002, TestSize.Level1)
53 {
54 uint32_t flag = AUDIO_OUTPUT_FLAG_FAST;
55 AudioMode audioMode = AUDIO_MODE_PLAYBACK;
56 AudioPipeType result = AudioPipeSelector::GetPipeSelector()->GetPipeType(flag, audioMode);
57 EXPECT_EQ(result, PIPE_TYPE_LOWLATENCY_OUT);
58 }
59
60 /**
61 * @tc.name: GetPipeType_003
62 * @tc.desc: Test GetPipeType when audioMode is AUDIO_MODE_PLAYBACK and flag contains
63 * AUDIO_OUTPUT_FLAG_DIRECT and AUDIO_OUTPUT_FLAG_VOIP.
64 * @tc.type: FUNC
65 * @tc.require: #I5Y4MZ
66 */
67 HWTEST_F(AudioPipeSelectorUnitTest, GetPipeType_003, TestSize.Level1)
68 {
69 uint32_t flag = AUDIO_OUTPUT_FLAG_DIRECT | AUDIO_OUTPUT_FLAG_VOIP;
70 AudioMode audioMode = AUDIO_MODE_PLAYBACK;
71 AudioPipeType result = AudioPipeSelector::GetPipeSelector()->GetPipeType(flag, audioMode);
72 EXPECT_EQ(result, PIPE_TYPE_CALL_OUT);
73 }
74
75 /**
76 * @tc.name: GetPipeType_004
77 * @tc.desc: Test GetPipeType when audioMode is AUDIO_MODE_PLAYBACK and flag contains AUDIO_OUTPUT_FLAG_DIRECT.
78 * @tc.type: FUNC
79 * @tc.require: #I5Y4MZ
80 */
81 HWTEST_F(AudioPipeSelectorUnitTest, GetPipeType_004, TestSize.Level1)
82 {
83 uint32_t flag = AUDIO_OUTPUT_FLAG_DIRECT;
84 AudioMode audioMode = AUDIO_MODE_PLAYBACK;
85 AudioPipeType result = AudioPipeSelector::GetPipeSelector()->GetPipeType(flag, audioMode);
86 EXPECT_EQ(result, PIPE_TYPE_DIRECT_OUT);
87 }
88
89 /**
90 * @tc.name: GetPipeType_005
91 * @tc.desc: Test GetPipeType when audioMode is AUDIO_MODE_PLAYBACK and flag contains
92 * AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD.
93 * @tc.type: FUNC
94 * @tc.require: #I5Y4MZ
95 */
96 HWTEST_F(AudioPipeSelectorUnitTest, GetPipeType_005, TestSize.Level1)
97 {
98 uint32_t flag = AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD;
99 AudioMode audioMode = AUDIO_MODE_PLAYBACK;
100 AudioPipeType result = AudioPipeSelector::GetPipeSelector()->GetPipeType(flag, audioMode);
101 EXPECT_EQ(result, PIPE_TYPE_OFFLOAD);
102 }
103
104 /**
105 * @tc.name: GetPipeType_006
106 * @tc.desc: Test GetPipeType when audioMode is AUDIO_MODE_PLAYBACK and flag contains AUDIO_OUTPUT_FLAG_MULTICHANNEL.
107 * @tc.type: FUNC
108 * @tc.require: #I5Y4MZ
109 */
110 HWTEST_F(AudioPipeSelectorUnitTest, GetPipeType_006, TestSize.Level1)
111 {
112 uint32_t flag = AUDIO_OUTPUT_FLAG_MULTICHANNEL;
113 AudioMode audioMode = AUDIO_MODE_PLAYBACK;
114 AudioPipeType result = AudioPipeSelector::GetPipeSelector()->GetPipeType(flag, audioMode);
115 EXPECT_EQ(result, PIPE_TYPE_MULTICHANNEL);
116 }
117
118 /**
119 * @tc.name: GetPipeType_007
120 * @tc.desc: Test GetPipeType when audioMode is AUDIO_MODE_PLAYBACK and flag does not contain any specific flags.
121 * @tc.type: FUNC
122 * @tc.require: #I5Y4MZ
123 */
124 HWTEST_F(AudioPipeSelectorUnitTest, GetPipeType_007, TestSize.Level1)
125 {
126 uint32_t flag = AUDIO_OUTPUT_FLAG_NORMAL;
127 AudioMode audioMode = AUDIO_MODE_PLAYBACK;
128 AudioPipeType result = AudioPipeSelector::GetPipeSelector()->GetPipeType(flag, audioMode);
129 EXPECT_EQ(result, PIPE_TYPE_NORMAL_OUT);
130 }
131
132 /**
133 * @tc.name: GetPipeType_008
134 * @tc.desc: Test GetPipeType when audioMode is AUDIO_MODE_RECORD and flag contains
135 * AUDIO_INPUT_FLAG_FAST and AUDIO_INPUT_FLAG_VOIP.
136 * @tc.type: FUNC
137 * @tc.require: #I5Y4MZ
138 */
139 HWTEST_F(AudioPipeSelectorUnitTest, GetPipeType_008, TestSize.Level1)
140 {
141 uint32_t flag = AUDIO_INPUT_FLAG_FAST | AUDIO_INPUT_FLAG_VOIP;
142 AudioMode audioMode = AUDIO_MODE_RECORD;
143 AudioPipeType result = AudioPipeSelector::GetPipeSelector()->GetPipeType(flag, audioMode);
144 EXPECT_EQ(result, PIPE_TYPE_CALL_IN);
145 }
146
147 /**
148 * @tc.name: GetPipeType_009
149 * @tc.desc: Test GetPipeType when audioMode is AUDIO_MODE_RECORD and flag contains AUDIO_INPUT_FLAG_FAST.
150 * @tc.type: FUNC
151 * @tc.require: #I5Y4MZ
152 */
153 HWTEST_F(AudioPipeSelectorUnitTest, GetPipeType_009, TestSize.Level1)
154 {
155 uint32_t flag = AUDIO_INPUT_FLAG_FAST;
156 AudioMode audioMode = AUDIO_MODE_RECORD;
157 AudioPipeType result = AudioPipeSelector::GetPipeSelector()->GetPipeType(flag, audioMode);
158 EXPECT_EQ(result, PIPE_TYPE_LOWLATENCY_IN);
159 }
160
161 /**
162 * @tc.name: GetPipeType_010
163 * @tc.desc: Test GetPipeType when audioMode is AUDIO_MODE_RECORD and flag does not contain any specific flags.
164 * @tc.type: FUNC
165 * @tc.require: #I5Y4MZ
166 */
167 HWTEST_F(AudioPipeSelectorUnitTest, GetPipeType_010, TestSize.Level1)
168 {
169 uint32_t flag = AUDIO_INPUT_FLAG_NORMAL;
170 AudioMode audioMode = AUDIO_MODE_RECORD;
171 AudioPipeType result = AudioPipeSelector::GetPipeSelector()->GetPipeType(flag, audioMode);
172 EXPECT_EQ(result, PIPE_TYPE_NORMAL_IN);
173 }
174
175 /**
176 * @tc.name: GetAdapterNameByStreamDesc_001
177 * @tc.desc: Test GetAdapterNameByStreamDesc when streamDesc is not nullptr and pipeInfoPtr
178 * and adapterInfoPtr are not nullptr.
179 * @tc.type: FUNC
180 * @tc.require: #I5Y4MZ
181 */
182 HWTEST_F(AudioPipeSelectorUnitTest, GetAdapterNameByStreamDesc_001, TestSize.Level1)
183 {
184 std::shared_ptr<AudioStreamDescriptor> streamDesc = std::make_shared<AudioStreamDescriptor>();
185 streamDesc->newDeviceDescs_.push_back(std::make_shared<AudioDeviceDescriptor>());
186 streamDesc->newDeviceDescs_.front()->deviceType_ = DEVICE_TYPE_SPEAKER;
187 streamDesc->newDeviceDescs_.front()->networkId_ = "0";
188 streamDesc->streamInfo_.format = AudioSampleFormat::SAMPLE_S16LE;
189 streamDesc->streamInfo_.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
190 streamDesc->streamInfo_.channels = AudioChannel::STEREO;
191
192 auto audioPipeSelector = AudioPipeSelector::GetPipeSelector();
193 std::string result = audioPipeSelector->GetAdapterNameByStreamDesc(streamDesc);
194 EXPECT_EQ(result, "");
195 }
196
197 /**
198 * @tc.name: ConvertStreamDescToPipeInfo_001
199 * @tc.desc: Test ConvertStreamDescToPipeInfo when pipeInfoPtr and adapterInfoPtr are not nullptr.
200 * @tc.type: FUNC
201 * @tc.require: #I5Y4MZ
202 */
203 HWTEST_F(AudioPipeSelectorUnitTest, ConvertStreamDescToPipeInfo_001, TestSize.Level1)
204 {
205 std::shared_ptr<AudioStreamDescriptor> streamDesc = std::make_shared<AudioStreamDescriptor>();
206 streamDesc->routeFlag_ = 1;
207 streamDesc->sessionId_ = 100;
208 streamDesc->newDeviceDescs_.push_back(std::make_shared<AudioDeviceDescriptor>());
209 streamDesc->newDeviceDescs_.front()->deviceType_ = DEVICE_TYPE_SPEAKER;
210 streamDesc->newDeviceDescs_.front()->networkId_ = "0";
211 streamDesc->capturerInfo_.sourceType = SourceType::SOURCE_TYPE_MIC;
212
213 std::shared_ptr<PipeStreamPropInfo> streamPropInfo = std::make_shared<PipeStreamPropInfo>();
214 streamPropInfo->format_ = AudioSampleFormat::SAMPLE_S16LE;
215 streamPropInfo->sampleRate_ = 44100;
216 streamPropInfo->channelLayout_ = AudioChannelLayout::CH_LAYOUT_STEREO;
217 streamPropInfo->bufferSize_ = 1024;
218
219 std::shared_ptr<AdapterPipeInfo> pipeInfoPtr = std::make_shared<AdapterPipeInfo>();
220 pipeInfoPtr->paProp_.lib_ = "test_lib";
221 pipeInfoPtr->paProp_.role_ = "test_role";
222 pipeInfoPtr->paProp_.moduleName_ = "test_module";
223 pipeInfoPtr->name_ = "test_name";
224 pipeInfoPtr->role_ = PIPE_ROLE_OUTPUT;
225
226 std::shared_ptr<PolicyAdapterInfo> adapterInfoPtr = std::make_shared<PolicyAdapterInfo>();
227 adapterInfoPtr->adapterName = "test_adapter";
228
229 pipeInfoPtr->adapterInfo_ = adapterInfoPtr;
230 streamPropInfo->pipeInfo_ = pipeInfoPtr;
231
232 AudioPipeInfo info;
233 auto audioPipeSelector = AudioPipeSelector::GetPipeSelector();
234 audioPipeSelector->ConvertStreamDescToPipeInfo(streamDesc, streamPropInfo, info);
235 EXPECT_EQ(info.pipeRole_, PIPE_ROLE_OUTPUT);
236
237 pipeInfoPtr->name_ = "multichannel_output";
238 audioPipeSelector->ConvertStreamDescToPipeInfo(streamDesc, streamPropInfo, info);
239 EXPECT_EQ(info.pipeRole_, PIPE_ROLE_OUTPUT);
240 pipeInfoPtr->name_ = "offload_output";
241 audioPipeSelector->ConvertStreamDescToPipeInfo(streamDesc, streamPropInfo, info);
242 EXPECT_EQ(info.pipeRole_, PIPE_ROLE_OUTPUT);
243 pipeInfoPtr->name_ = "offload_distributed_output";
244 audioPipeSelector->ConvertStreamDescToPipeInfo(streamDesc, streamPropInfo, info);
245 EXPECT_EQ(info.pipeRole_, PIPE_ROLE_OUTPUT);
246 }
247
248 /**
249 * @tc.name: JudgeStreamAction_001
250 * @tc.desc: Test JudgeStreamAction when newPipe and oldPipe have the same adapterName and routeFlag.
251 * @tc.type: FUNC
252 * @tc.require: #I5Y4MZ
253 */
254 HWTEST_F(AudioPipeSelectorUnitTest, JudgeStreamAction_001, TestSize.Level1)
255 {
256 std::shared_ptr<AudioPipeInfo> newPipe = std::make_shared<AudioPipeInfo>();
257 newPipe->adapterName_ = "test_adapter";
258 newPipe->routeFlag_ = 1;
259
260 std::shared_ptr<AudioPipeInfo> oldPipe = std::make_shared<AudioPipeInfo>();
261 oldPipe->adapterName_ = "test_adapter";
262 oldPipe->routeFlag_ = 1;
263 auto audioPipeSelector = AudioPipeSelector::GetPipeSelector();
264 AudioStreamAction result = audioPipeSelector->JudgeStreamAction(newPipe, oldPipe);
265 EXPECT_EQ(result, AUDIO_STREAM_ACTION_DEFAULT);
266 }
267
268 /**
269 * @tc.name: JudgeStreamAction_002
270 * @tc.desc: Test JudgeStreamAction when newPipe and oldPipe have different adapterName and
271 * routeFlag, and neither is FAST or DIRECT.
272 * @tc.type: FUNC
273 * @tc.require: #I5Y4MZ
274 */
275 HWTEST_F(AudioPipeSelectorUnitTest, JudgeStreamAction_002, TestSize.Level1)
276 {
277 std::shared_ptr<AudioPipeInfo> newPipe = std::make_shared<AudioPipeInfo>();
278 newPipe->adapterName_ = "new_adapter";
279 newPipe->routeFlag_ = 0x1234;
280
281 std::shared_ptr<AudioPipeInfo> oldPipe = std::make_shared<AudioPipeInfo>();
282 oldPipe->adapterName_ = "old_adapter";
283 oldPipe->routeFlag_ = 0x123456;
284
285 auto audioPipeSelector = AudioPipeSelector::GetPipeSelector();
286 AudioStreamAction result = audioPipeSelector->JudgeStreamAction(newPipe, oldPipe);
287 EXPECT_EQ(result, AUDIO_STREAM_ACTION_RECREATE);
288 }
289
290 /**
291 * @tc.name: JudgeStreamAction_003
292 * @tc.desc: Test JudgeStreamAction when oldPipe's routeFlag is AUDIO_OUTPUT_FLAG_FAST.
293 * @tc.type: FUNC
294 * @tc.require: #I5Y4MZ
295 */
296 HWTEST_F(AudioPipeSelectorUnitTest, JudgeStreamAction_003, TestSize.Level1)
297 {
298 std::shared_ptr<AudioPipeInfo> newPipe = std::make_shared<AudioPipeInfo>();
299 newPipe->adapterName_ = "new_adapter";
300 newPipe->routeFlag_ = 0x1234;
301
302 std::shared_ptr<AudioPipeInfo> oldPipe = std::make_shared<AudioPipeInfo>();
303 oldPipe->adapterName_ = "old_adapter";
304 oldPipe->routeFlag_ = AUDIO_OUTPUT_FLAG_FAST;
305
306 auto audioPipeSelector = AudioPipeSelector::GetPipeSelector();
307 AudioStreamAction result = audioPipeSelector->JudgeStreamAction(newPipe, oldPipe);
308 EXPECT_EQ(result, AUDIO_STREAM_ACTION_RECREATE);
309 }
310
311 /**
312 * @tc.name: JudgeStreamAction_004
313 * @tc.desc: Test JudgeStreamAction when newPipe's routeFlag is AUDIO_OUTPUT_FLAG_FAST.
314 * @tc.type: FUNC
315 * @tc.require: #I5Y4MZ
316 */
317 HWTEST_F(AudioPipeSelectorUnitTest, JudgeStreamAction_004, TestSize.Level1)
318 {
319 std::shared_ptr<AudioPipeInfo> newPipe = std::make_shared<AudioPipeInfo>();
320 newPipe->adapterName_ = "new_adapter";
321 newPipe->routeFlag_ = AUDIO_OUTPUT_FLAG_FAST;
322
323 std::shared_ptr<AudioPipeInfo> oldPipe = std::make_shared<AudioPipeInfo>();
324 oldPipe->adapterName_ = "old_adapter";
325 oldPipe->routeFlag_ = 0x123456;
326
327 auto audioPipeSelector = AudioPipeSelector::GetPipeSelector();
328 AudioStreamAction result = audioPipeSelector->JudgeStreamAction(newPipe, oldPipe);
329 EXPECT_EQ(result, AUDIO_STREAM_ACTION_RECREATE);
330 }
331
332 /**
333 * @tc.name: JudgeStreamAction_005
334 * @tc.desc: Test JudgeStreamAction when oldPipe's routeFlag is AUDIO_OUTPUT_FLAG_DIRECT.
335 * @tc.type: FUNC
336 * @tc.require: #I5Y4MZ
337 */
338 HWTEST_F(AudioPipeSelectorUnitTest, JudgeStreamAction_005, TestSize.Level1)
339 {
340 std::shared_ptr<AudioPipeInfo> newPipe = std::make_shared<AudioPipeInfo>();
341 newPipe->adapterName_ = "new_adapter";
342 newPipe->routeFlag_ = 0x1234;
343 std::shared_ptr<AudioPipeInfo> oldPipe = std::make_shared<AudioPipeInfo>();
344 oldPipe->adapterName_ = "old_adapter";
345 oldPipe->routeFlag_ = AUDIO_OUTPUT_FLAG_DIRECT;
346
347 auto audioPipeSelector = AudioPipeSelector::GetPipeSelector();
348 AudioStreamAction result = audioPipeSelector->JudgeStreamAction(newPipe, oldPipe);
349 EXPECT_EQ(result, AUDIO_STREAM_ACTION_RECREATE);
350 }
351
352 /**
353 * @tc.name: JudgeStreamAction_006
354 * @tc.desc: Test JudgeStreamAction when newPipe's routeFlag is AUDIO_OUTPUT_FLAG_DIRECT.
355 * @tc.type: FUNC
356 * @tc.require: #I5Y4MZ
357 */
358 HWTEST_F(AudioPipeSelectorUnitTest, JudgeStreamAction_006, TestSize.Level1)
359 {
360 std::shared_ptr<AudioPipeInfo> newPipe = std::make_shared<AudioPipeInfo>();
361 newPipe->adapterName_ = "new_adapter";
362 newPipe->routeFlag_ = AUDIO_OUTPUT_FLAG_DIRECT;
363
364 std::shared_ptr<AudioPipeInfo> oldPipe = std::make_shared<AudioPipeInfo>();
365 oldPipe->adapterName_ = "old_adapter";
366 oldPipe->routeFlag_ = 0x123456;
367 auto audioPipeSelector = AudioPipeSelector::GetPipeSelector();
368 AudioStreamAction result = audioPipeSelector->JudgeStreamAction(newPipe, oldPipe);
369 EXPECT_EQ(result, AUDIO_STREAM_ACTION_RECREATE);
370 }
371
372 /**
373 * @tc.name: FetchPipeAndExecute_001
374 * @tc.desc: Test FetchPipeAndExecute when streamDesc->routeFlag_ == AUDIO_FLAG_NONE and enter the first if branch,
375 * then enter the first for loop's if branch, do not enter the second if branch, finally enter the second
376 * for loop's second if branch.
377 * @tc.type: FUNC
378 * @tc.require: #I5Y4MZ
379 */
380 HWTEST_F(AudioPipeSelectorUnitTest, FetchPipeAndExecute_001, TestSize.Level1)
381 {
382 std::shared_ptr<AudioStreamDescriptor> streamDesc = std::make_shared<AudioStreamDescriptor>();
383 streamDesc->routeFlag_ = AUDIO_FLAG_NONE;
384 streamDesc->audioMode_ = AUDIO_MODE_PLAYBACK;
385 streamDesc->newDeviceDescs_.push_back(std::make_shared<AudioDeviceDescriptor>());
386 streamDesc->newDeviceDescs_.front()->deviceType_ = DEVICE_TYPE_SPEAKER;
387 streamDesc->newDeviceDescs_.front()->networkId_ = "0";
388 streamDesc->streamInfo_.format = AudioSampleFormat::SAMPLE_S16LE;
389 streamDesc->streamInfo_.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
390 streamDesc->streamInfo_.channels = AudioChannel::STEREO;
391
392 std::vector<std::shared_ptr<AudioPipeInfo>> pipeInfoList;
393 std::shared_ptr<AudioPipeInfo> pipeInfo = std::make_shared<AudioPipeInfo>();
394 pipeInfo->pipeRole_ = PIPE_ROLE_OUTPUT;
395 pipeInfo->adapterName_ = "test_adapter";
396 pipeInfo->routeFlag_ = 1;
397 pipeInfoList.push_back(pipeInfo);
398 AudioPipeManager::GetPipeManager()->curPipeList_ = pipeInfoList;
399
400 auto audioPipeSelector = AudioPipeSelector::GetPipeSelector();
401 std::vector<std::shared_ptr<AudioPipeInfo>> result = audioPipeSelector->FetchPipeAndExecute(streamDesc);
402 EXPECT_FALSE(result.empty());
403 EXPECT_EQ(result[0]->pipeAction_, PIPE_ACTION_DEFAULT);
404 }
405
406 /**
407 * @tc.name: UpdataDeviceStreamInfo_001
408 * @tc.desc: Test UpdataDeviceStreamInfo
409 * @tc.type: FUNC
410 * @tc.require: #I5Y4MZ
411 */
412 HWTEST_F(AudioPipeSelectorUnitTest, UpdataDeviceStreamInfo_001, TestSize.Level1)
413 {
414 std::shared_ptr<AudioStreamDescriptor> streamDesc = std::make_shared<AudioStreamDescriptor>();
415
416 streamDesc->newDeviceDescs_ = {};
417 std::shared_ptr<PipeStreamPropInfo> streamPropInfo = nullptr;
418
419 auto audioPipeSelector = AudioPipeSelector::GetPipeSelector();
420 // test empty
421 audioPipeSelector->UpdataDeviceStreamInfo(streamDesc, streamPropInfo);
422
423 std::shared_ptr<AudioDeviceDescriptor> temp = nullptr;
424 streamDesc->newDeviceDescs_.push_back(temp);
425 audioPipeSelector->UpdataDeviceStreamInfo(streamDesc, streamPropInfo);
426
427 streamPropInfo = std::make_shared<PipeStreamPropInfo>();
428 audioPipeSelector->UpdataDeviceStreamInfo(streamDesc, streamPropInfo);
429
430 streamDesc->newDeviceDescs_.front() = std::make_shared<AudioDeviceDescriptor>();
431 audioPipeSelector->UpdataDeviceStreamInfo(streamDesc, streamPropInfo);
432
433 // test nullptr
434 streamPropInfo->format_ = AudioSampleFormat::SAMPLE_S16LE;
435 streamPropInfo->sampleRate_ = static_cast<uint32_t>(AudioSamplingRate::SAMPLE_RATE_48000);
436 streamPropInfo->channels_ = AudioChannel::STEREO;
437
438 audioPipeSelector->UpdataDeviceStreamInfo(streamDesc, streamPropInfo);
439
440 EXPECT_EQ(streamDesc->newDeviceDescs_.front()->audioStreamInfo_.front().format, streamPropInfo->format_);
441 EXPECT_EQ(*(streamDesc->newDeviceDescs_.front()->audioStreamInfo_.front().samplingRate.rbegin()),
442 AudioSamplingRate::SAMPLE_RATE_48000);
443 }
444
445 /**
446 * @tc.name: FetchPipesAndExecute_001
447 * @tc.desc: Test FetchPipesAndExecute when streamDescs is empty.
448 * @tc.type: FUNC
449 * @tc.require: #I5Y4MZ
450 */
451 HWTEST_F(AudioPipeSelectorUnitTest, FetchPipesAndExecute_001, TestSize.Level1)
452 {
453 std::vector<std::shared_ptr<AudioStreamDescriptor>> streamDescs;
454 auto audioPipeSelector = AudioPipeSelector::GetPipeSelector();
455 std::vector<std::shared_ptr<AudioPipeInfo>> result = audioPipeSelector->FetchPipesAndExecute(streamDescs);
456 EXPECT_TRUE(result.empty());
457 }
458
459 /**
460 * @tc.name: FetchPipeAndExecute_002
461 * @tc.desc: Test FetchPipeAndExecute streamDesc->routeFlag_ != AUDIO_FLAG_NONE.
462 * @tc.type: FUNC
463 * @tc.require: #I5Y4MZ
464 */
465 HWTEST_F(AudioPipeSelectorUnitTest, FetchPipeAndExecute_002, TestSize.Level4)
466 {
467 std::shared_ptr<AudioStreamDescriptor> streamDesc = std::make_shared<AudioStreamDescriptor>();
468 streamDesc->audioMode_ = AUDIO_MODE_PLAYBACK;
469 streamDesc->newDeviceDescs_.push_back(std::make_shared<AudioDeviceDescriptor>());
470 streamDesc->newDeviceDescs_.front()->deviceType_ = DEVICE_TYPE_SPEAKER;
471 streamDesc->newDeviceDescs_.front()->networkId_ = "0";
472 streamDesc->streamInfo_.format = AudioSampleFormat::SAMPLE_S16LE;
473 streamDesc->streamInfo_.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
474 streamDesc->streamInfo_.channels = AudioChannel::STEREO;
475 streamDesc->routeFlag_ = AUDIO_OUTPUT_FLAG_NORMAL;
476 AudioPipeManager::GetPipeManager()->curPipeList_.clear();
477 auto audioPipeSelector = AudioPipeSelector::GetPipeSelector();
478 std::vector<std::shared_ptr<AudioPipeInfo>> result = audioPipeSelector->FetchPipeAndExecute(streamDesc);
479 EXPECT_TRUE(result.empty());
480 }
481
482 /**
483 * @tc.name: FetchPipesAndExecute_002
484 * @tc.desc: Test FetchPipesAndExecute streamDescs.size() != 0.
485 * @tc.type: FUNC
486 * @tc.require: #I5Y4MZ
487 */
488 HWTEST_F(AudioPipeSelectorUnitTest, FetchPipesAndExecute_002, TestSize.Level4)
489 {
490 std::shared_ptr<AudioStreamDescriptor> streamDesc1 = std::make_shared<AudioStreamDescriptor>();
491 streamDesc1->audioMode_ = AUDIO_MODE_PLAYBACK;
492 streamDesc1->newDeviceDescs_.push_back(std::make_shared<AudioDeviceDescriptor>());
493 std::shared_ptr<AudioStreamDescriptor> streamDesc2 = std::make_shared<AudioStreamDescriptor>();
494 streamDesc2->audioMode_ = AUDIO_MODE_RECORD;
495 streamDesc2->newDeviceDescs_.push_back(std::make_shared<AudioDeviceDescriptor>());
496 std::vector<std::shared_ptr<AudioStreamDescriptor>> streamDescs = { streamDesc1, streamDesc2 };
497
498 std::shared_ptr<AudioPipeInfo> pipeInfo1 = std::make_shared<AudioPipeInfo>();
499 pipeInfo1->pipeRole_ = PIPE_ROLE_OUTPUT;
500 pipeInfo1->streamDescriptors_.push_back(std::make_shared<AudioStreamDescriptor>());
501 AudioPipeManager::GetPipeManager()->AddAudioPipeInfo(pipeInfo1);
502 std::shared_ptr<AudioPipeInfo> pipeInfo2 = std::make_shared<AudioPipeInfo>();
503 pipeInfo2->pipeRole_ = PIPE_ROLE_INPUT;
504 AudioPipeManager::GetPipeManager()->AddAudioPipeInfo(pipeInfo2);
505
506 auto audioPipeSelector = AudioPipeSelector::GetPipeSelector();
507 std::vector<std::shared_ptr<AudioPipeInfo>> result = audioPipeSelector->FetchPipesAndExecute(streamDescs);
508 EXPECT_FALSE(result.empty());
509 }
510
511 /**
512 * @tc.name: IncomingConcurrency_001
513 * @tc.desc: Test IncomingConcurrency cmpStream->audioMode_ == AUDIO_MODE_RECORD
514 * && stream->audioMode_ == AUDIO_MODE_RECORD.
515 * @tc.type: FUNC
516 * @tc.require: #I5Y4MZ
517 */
518 HWTEST_F(AudioPipeSelectorUnitTest, IncomingConcurrency_001, TestSize.Level4)
519 {
520 std::shared_ptr<AudioStreamDescriptor> stream = std::make_shared<AudioStreamDescriptor>();
521 std::shared_ptr<AudioStreamDescriptor> cmpStream = std::make_shared<AudioStreamDescriptor>();
522 auto audioPipeSelector = AudioPipeSelector::GetPipeSelector();
523 audioPipeSelector->IncomingConcurrency(stream, cmpStream);
524
525 cmpStream->audioMode_ = AUDIO_MODE_RECORD;
526 stream->audioMode_ = AUDIO_MODE_PLAYBACK;
527 audioPipeSelector->IncomingConcurrency(stream, cmpStream);
528 cmpStream->audioMode_ = AUDIO_MODE_PLAYBACK;
529 stream->audioMode_ = AUDIO_MODE_RECORD;
530 audioPipeSelector->IncomingConcurrency(stream, cmpStream);
531
532 cmpStream->audioMode_ = AUDIO_MODE_RECORD;
533 stream->audioMode_ = AUDIO_MODE_RECORD;
534 audioPipeSelector->IncomingConcurrency(stream, cmpStream);
535 EXPECT_EQ(cmpStream->routeFlag_, AUDIO_INPUT_FLAG_NORMAL);
536 }
537
538 /**
539 * @tc.name: ProcessConcurrency_001
540 * @tc.desc: Test ProcessConcurrency switch (action).
541 * @tc.type: FUNC
542 * @tc.require: #I5Y4MZ
543 */
544 HWTEST_F(AudioPipeSelectorUnitTest, ProcessConcurrency_001, TestSize.Level4)
545 {
546 std::map<std::pair<AudioPipeType, AudioPipeType>, ConcurrencyAction> ruleMap = {
547 {{PIPE_TYPE_LOWLATENCY_OUT, PIPE_TYPE_LOWLATENCY_OUT}, PLAY_BOTH},
548 {{PIPE_TYPE_LOWLATENCY_OUT, PIPE_TYPE_NORMAL_IN}, CONCEDE_INCOMING},
549 {{PIPE_TYPE_NORMAL_IN, PIPE_TYPE_NORMAL_IN}, CONCEDE_EXISTING}
550 };
551 AudioStreamCollector::GetAudioStreamCollector().audioConcurrencyService_->concurrencyCfgMap_ = ruleMap;
552 AudioPipeManager::GetPipeManager()->curPipeList_.clear();
553 std::shared_ptr<AudioPipeInfo> pipeInfo = std::make_shared<AudioPipeInfo>();
554 pipeInfo->adapterName_ = "test_adapterName";
555 auto descriptor = std::make_shared<AudioStreamDescriptor>();
556 descriptor->sessionId_ = 1;
557 pipeInfo->streamDescriptors_.push_back(descriptor);
558 AudioPipeManager::GetPipeManager()->AddAudioPipeInfo(pipeInfo);
559
560 std::shared_ptr<AudioStreamDescriptor> stream = std::make_shared<AudioStreamDescriptor>();
561 std::shared_ptr<AudioStreamDescriptor> cmpStream = std::make_shared<AudioStreamDescriptor>();
562 stream->routeFlag_ = AUDIO_OUTPUT_FLAG_FAST;
563 stream->audioMode_ = AUDIO_MODE_PLAYBACK;
564 stream->streamAction_ = AUDIO_STREAM_ACTION_NEW;
565 stream->sessionId_ = 1;
566 cmpStream->routeFlag_ = AUDIO_OUTPUT_FLAG_FAST;
567 cmpStream->audioMode_ = AUDIO_MODE_PLAYBACK;
568 cmpStream->sessionId_ = 1;
569
570 auto audioPipeSelector = AudioPipeSelector::GetPipeSelector();
571 bool ret = audioPipeSelector->ProcessConcurrency(stream, cmpStream);
572 EXPECT_EQ(stream->streamAction_, AUDIO_STREAM_ACTION_DEFAULT);
573 EXPECT_FALSE(ret);
574
575 cmpStream->audioMode_ = AUDIO_MODE_RECORD;
576 ret = audioPipeSelector->ProcessConcurrency(stream, cmpStream);
577 EXPECT_EQ(cmpStream->routeFlag_, AUDIO_INPUT_FLAG_NORMAL);
578
579 stream->audioMode_ = AUDIO_MODE_RECORD;
580 ret = audioPipeSelector->ProcessConcurrency(stream, cmpStream);
581 EXPECT_TRUE(ret);
582 }
583
584 /**
585 * @tc.name: ConvertStreamDescToPipeInfo_002
586 * @tc.desc: Test ConvertStreamDescToPipeInfo pipeInfoPtr->name_ == "dp_multichannel_output".
587 * @tc.type: FUNC
588 * @tc.require: #I5Y4MZ
589 */
590 HWTEST_F(AudioPipeSelectorUnitTest, ConvertStreamDescToPipeInfo_002, TestSize.Level4)
591 {
592 auto audioPipeSelector = AudioPipeSelector::GetPipeSelector();
593 std::shared_ptr<AudioStreamDescriptor> streamDesc = std::make_shared<AudioStreamDescriptor>();
594 streamDesc->routeFlag_ = 1;
595 streamDesc->sessionId_ = 100;
596 streamDesc->newDeviceDescs_.push_back(std::make_shared<AudioDeviceDescriptor>());
597 streamDesc->newDeviceDescs_.front()->deviceType_ = DEVICE_TYPE_SPEAKER;
598 streamDesc->newDeviceDescs_.front()->networkId_ = "0";
599 streamDesc->capturerInfo_.sourceType = SourceType::SOURCE_TYPE_MIC;
600 std::shared_ptr<PipeStreamPropInfo> streamPropInfo = std::make_shared<PipeStreamPropInfo>();
601 streamPropInfo->format_ = AudioSampleFormat::SAMPLE_S16LE;
602 streamPropInfo->sampleRate_ = 44100;
603 streamPropInfo->channelLayout_ = AudioChannelLayout::CH_LAYOUT_STEREO;
604 streamPropInfo->bufferSize_ = 1024;
605 AudioPipeInfo info;
606
607 std::shared_ptr<AdapterPipeInfo> pipeInfo = std::make_shared<AdapterPipeInfo>();
608 pipeInfo->paProp_.lib_ = "test_lib";
609 pipeInfo->paProp_.role_ = "test_role";
610 pipeInfo->paProp_.moduleName_ = "test_module";
611 pipeInfo->role_ = PIPE_ROLE_OUTPUT;
612 std::shared_ptr<PolicyAdapterInfo> adapterInfo = std::make_shared<PolicyAdapterInfo>();
613 adapterInfo->adapterName = "test_adapter";
614 pipeInfo->adapterInfo_ = adapterInfo;
615 pipeInfo->name_ = "dp_multichannel_output";
616 streamPropInfo->pipeInfo_ = pipeInfo;
617 audioPipeSelector->ConvertStreamDescToPipeInfo(streamDesc, streamPropInfo, info);
618 EXPECT_EQ(info.moduleInfo_.className, "dp_multichannel");
619 }
620
621 /**
622 * @tc.name: ConvertStreamDescToPipeInfo_003
623 * @tc.desc: Test ConvertStreamDescToPipeInfo pipeInfoPtr == nullptr and adapterInfoPtr == nullptr.
624 * @tc.type: FUNC
625 * @tc.require: #I5Y4MZ
626 */
627 HWTEST_F(AudioPipeSelectorUnitTest, ConvertStreamDescToPipeInfo_003, TestSize.Level4)
628 {
629 auto audioPipeSelector = AudioPipeSelector::GetPipeSelector();
630 std::shared_ptr<AudioStreamDescriptor> streamDesc = std::make_shared<AudioStreamDescriptor>();
631 std::shared_ptr<PipeStreamPropInfo> streamPropInfo = std::make_shared<PipeStreamPropInfo>();
632 streamPropInfo->sampleRate_ = 44100;
633 streamPropInfo->pipeInfo_.reset();
634 AudioPipeInfo info;
635 audioPipeSelector->ConvertStreamDescToPipeInfo(streamDesc, streamPropInfo, info);
636 EXPECT_EQ(info.moduleInfo_.rate, "");
637
638 std::shared_ptr<AdapterPipeInfo> pipeInfo = std::make_shared<AdapterPipeInfo>();
639 pipeInfo->adapterInfo_.reset();
640 streamPropInfo->pipeInfo_ = pipeInfo;
641 audioPipeSelector->ConvertStreamDescToPipeInfo(streamDesc, streamPropInfo, info);
642 EXPECT_EQ(info.moduleInfo_.rate, "");
643 }
644
645 /**
646 * @tc.name: JudgeStreamAction_007
647 * @tc.desc: Test JudgeStreamAction when return AUDIO_STREAM_ACTION_MOVE.
648 * @tc.type: FUNC
649 * @tc.require: #I5Y4MZ
650 */
651 HWTEST_F(AudioPipeSelectorUnitTest, JudgeStreamAction_007, TestSize.Level4)
652 {
653 std::shared_ptr<AudioPipeInfo> newPipe = std::make_shared<AudioPipeInfo>();
654 newPipe->adapterName_ = "new_adapter";
655 newPipe->routeFlag_ = AUDIO_OUTPUT_FLAG_NORMAL;
656 std::shared_ptr<AudioPipeInfo> oldPipe = std::make_shared<AudioPipeInfo>();
657 oldPipe->adapterName_ = "old_adapter";
658 oldPipe->routeFlag_ = AUDIO_OUTPUT_FLAG_DIRECT;
659
660 auto audioPipeSelector = AudioPipeSelector::GetPipeSelector();
661 AudioStreamAction result = audioPipeSelector->JudgeStreamAction(newPipe, oldPipe);
662 EXPECT_EQ(result, AUDIO_STREAM_ACTION_RECREATE);
663
664 newPipe->routeFlag_ = AUDIO_OUTPUT_FLAG_DIRECT;
665 oldPipe->routeFlag_ = AUDIO_OUTPUT_FLAG_NORMAL;
666 result = audioPipeSelector->JudgeStreamAction(newPipe, oldPipe);
667 EXPECT_EQ(result, AUDIO_STREAM_ACTION_RECREATE);
668
669 newPipe->routeFlag_ = AUDIO_OUTPUT_FLAG_NORMAL;
670 oldPipe->routeFlag_ = AUDIO_OUTPUT_FLAG_NORMAL;
671 result = audioPipeSelector->JudgeStreamAction(newPipe, oldPipe);
672 EXPECT_EQ(result, AUDIO_STREAM_ACTION_MOVE);
673 }
674
675 /**
676 * @tc.name: DecideFinalRouteFlag_001
677 * @tc.desc: Test DecideFinalRouteFlag when streamDescs.size() == 0 || streamDescs.size() == 1.
678 * @tc.type: FUNC
679 */
680 HWTEST_F(AudioPipeSelectorUnitTest, DecideFinalRouteFlag_001, TestSize.Level1)
681 {
682 std::vector<std::shared_ptr<AudioStreamDescriptor>> streamDescs;
683 auto audioPipeSelector = AudioPipeSelector::GetPipeSelector();
684 audioPipeSelector->DecideFinalRouteFlag(streamDescs);
685
686 std::shared_ptr<AudioStreamDescriptor> streamDesc1 = std::make_shared<AudioStreamDescriptor>();
687 streamDesc1->routeFlag_ = AUDIO_FLAG_MAX;
688 streamDesc1->audioMode_ = AUDIO_MODE_PLAYBACK;
689 streamDesc1->streamAction_ = AUDIO_STREAM_ACTION_NEW;
690 streamDesc1->sessionId_ = 100001;
691 streamDesc1->newDeviceDescs_.push_back(std::make_shared<AudioDeviceDescriptor>());
692 streamDescs.push_back(streamDesc1);
693 audioPipeSelector->DecideFinalRouteFlag(streamDescs);
694 EXPECT_EQ(streamDescs[0]->routeFlag_, AUDIO_FLAG_NONE);
695 }
696
697 /**
698 * @tc.name: DecideFinalRouteFlag_002
699 * @tc.desc: Test DecideFinalRouteFlag when streamDescs.size() > 1.
700 * @tc.type: FUNC
701 */
702 HWTEST_F(AudioPipeSelectorUnitTest, DecideFinalRouteFlag_002, TestSize.Level1)
703 {
704 auto audioPipeSelector = AudioPipeSelector::GetPipeSelector();
705 std::vector<std::shared_ptr<AudioStreamDescriptor>> streamDescs;
706 std::shared_ptr<AudioStreamDescriptor> streamDesc1 = std::make_shared<AudioStreamDescriptor>();
707 streamDesc1->routeFlag_ = AUDIO_OUTPUT_FLAG_FAST;
708 streamDesc1->audioMode_ = AUDIO_MODE_PLAYBACK;
709 streamDesc1->streamAction_ = AUDIO_STREAM_ACTION_NEW;
710 streamDesc1->sessionId_ = 100001;
711 streamDesc1->newDeviceDescs_.push_back(std::make_shared<AudioDeviceDescriptor>());
712 streamDesc1->createTimeStamp_ = 1;
713 streamDescs.push_back(streamDesc1);
714
715 std::shared_ptr<AudioStreamDescriptor> streamDesc2 = std::make_shared<AudioStreamDescriptor>();
716 streamDesc2->routeFlag_ = AUDIO_OUTPUT_FLAG_FAST;
717 streamDesc2->audioMode_ = AUDIO_MODE_PLAYBACK;
718 streamDesc2->streamAction_ = AUDIO_STREAM_ACTION_NEW;
719 streamDesc2->sessionId_ = 100002;
720 streamDesc2->newDeviceDescs_.push_back(std::make_shared<AudioDeviceDescriptor>());
721 streamDesc2->createTimeStamp_ = 2;
722 streamDescs.push_back(streamDesc2);
723 audioPipeSelector->DecideFinalRouteFlag(streamDescs);
724 EXPECT_NE(streamDescs[1]->routeFlag_, AUDIO_OUTPUT_FLAG_FAST);
725 }
726
727 /**
728 * @tc.name: ProcessNewPipeList_001
729 * @tc.desc: Test ProcessNewPipeList when cannot find exist pipe.
730 * @tc.type: FUNC
731 */
732 HWTEST_F(AudioPipeSelectorUnitTest, ProcessNewPipeList_001, TestSize.Level1)
733 {
734 auto audioPipeSelector = AudioPipeSelector::GetPipeSelector();
735 std::vector<std::shared_ptr<AudioStreamDescriptor>> streamDescs;
736 std::shared_ptr<AudioStreamDescriptor> streamDesc1 = std::make_shared<AudioStreamDescriptor>();
737 streamDesc1->routeFlag_ = AUDIO_OUTPUT_FLAG_FAST;
738 streamDesc1->audioMode_ = AUDIO_MODE_PLAYBACK;
739 streamDesc1->streamAction_ = AUDIO_STREAM_ACTION_NEW;
740 streamDesc1->sessionId_ = 100001;
741 streamDesc1->newDeviceDescs_.push_back(std::make_shared<AudioDeviceDescriptor>());
742 streamDesc1->createTimeStamp_ = 1;
743 streamDescs.push_back(streamDesc1);
744
745 std::vector<std::shared_ptr<AudioPipeInfo>> newPipeInfoList{};
746
747 audioPipeSelector->ProcessNewPipeList(newPipeInfoList, streamDescs);
748 EXPECT_TRUE(newPipeInfoList.size() != 0);
749 }
750
751 /**
752 * @tc.name: ProcessNewPipeList_002
753 * @tc.desc: Test ProcessNewPipeList when pipe already exist.
754 * @tc.type: FUNC
755 */
756 HWTEST_F(AudioPipeSelectorUnitTest, ProcessNewPipeList_002, TestSize.Level1)
757 {
758 auto audioPipeSelector = AudioPipeSelector::GetPipeSelector();
759 std::vector<std::shared_ptr<AudioStreamDescriptor>> streamDescs;
760 std::shared_ptr<AudioStreamDescriptor> streamDesc1 = std::make_shared<AudioStreamDescriptor>();
761 streamDesc1->routeFlag_ = AUDIO_OUTPUT_FLAG_FAST;
762 streamDesc1->audioMode_ = AUDIO_MODE_PLAYBACK;
763 streamDesc1->streamAction_ = AUDIO_STREAM_ACTION_NEW;
764 streamDesc1->sessionId_ = 100001;
765 streamDesc1->newDeviceDescs_.push_back(std::make_shared<AudioDeviceDescriptor>());
766 streamDesc1->createTimeStamp_ = 1;
767 streamDescs.push_back(streamDesc1);
768
769 std::vector<std::shared_ptr<AudioPipeInfo>> newPipeInfoList{};
770 std::shared_ptr<AudioPipeInfo> pipe1 = std::make_shared<AudioPipeInfo>();
771 pipe1->adapterName_ = "primary";
772 pipe1->routeFlag_ = 1;
773 newPipeInfoList.push_back(pipe1);
774
775 std::shared_ptr<AudioPipeInfo> pipe2 = std::make_shared<AudioPipeInfo>();
776 pipe2->routeFlag_ = AUDIO_OUTPUT_FLAG_FAST;
777 newPipeInfoList.push_back(pipe2);
778
779 audioPipeSelector->ProcessNewPipeList(newPipeInfoList, streamDescs);
780 EXPECT_TRUE(newPipeInfoList.size() == 2);
781 }
782
783 /**
784 * @tc.name: DecidePipesAndStreamAction_001
785 * @tc.desc: Test DecidePipesAndStreamAction.
786 * @tc.type: FUNC
787 */
788 HWTEST_F(AudioPipeSelectorUnitTest, DecidePipesAndStreamAction_001, TestSize.Level1)
789 {
790 auto audioPipeSelector = AudioPipeSelector::GetPipeSelector();
791 std::shared_ptr<AudioStreamDescriptor> streamDesc1 = std::make_shared<AudioStreamDescriptor>();
792 streamDesc1->routeFlag_ = AUDIO_OUTPUT_FLAG_NORMAL;
793 streamDesc1->audioMode_ = AUDIO_MODE_PLAYBACK;
794 streamDesc1->streamAction_ = AUDIO_STREAM_ACTION_NEW;
795 streamDesc1->sessionId_ = 100001;
796 streamDesc1->newDeviceDescs_.push_back(std::make_shared<AudioDeviceDescriptor>());
797 streamDesc1->createTimeStamp_ = 1;
798
799 std::shared_ptr<AudioStreamDescriptor> streamDesc2 = std::make_shared<AudioStreamDescriptor>();
800 streamDesc2->routeFlag_ = AUDIO_OUTPUT_FLAG_NORMAL;
801 streamDesc2->audioMode_ = AUDIO_MODE_PLAYBACK;
802 streamDesc2->streamAction_ = AUDIO_STREAM_ACTION_NEW;
803 streamDesc2->sessionId_ = 100002;
804 streamDesc2->newDeviceDescs_.push_back(std::make_shared<AudioDeviceDescriptor>());
805 streamDesc2->createTimeStamp_ = 2;
806
807 std::vector<std::shared_ptr<AudioPipeInfo>> newPipeInfoList{};
808 std::shared_ptr<AudioPipeInfo> pipe1 = std::make_shared<AudioPipeInfo>();
809 pipe1->adapterName_ = "primary";
810 pipe1->routeFlag_ = 1;
811 pipe1->streamDescMap_[100001] = streamDesc1;
812 pipe1->streamDescriptors_.push_back(streamDesc1);
813 pipe1->pipeAction_ = PIPE_ACTION_NEW;
814 newPipeInfoList.push_back(pipe1);
815
816 std::shared_ptr<AudioPipeInfo> pipe2 = std::make_shared<AudioPipeInfo>();
817 pipe2->routeFlag_ = 1;
818 newPipeInfoList.push_back(pipe2);
819
820 std::shared_ptr<AudioPipeInfo> pipe3 = std::make_shared<AudioPipeInfo>();
821 pipe3->adapterName_ = "test_pipe";
822 pipe3->routeFlag_ = 1;
823 pipe3->streamDescMap_[100002] = streamDesc2;
824 pipe3->streamDescriptors_.push_back(streamDesc2);
825 newPipeInfoList.push_back(pipe3);
826
827 std::map<uint32_t, std::shared_ptr<AudioPipeInfo>> streamDescToOldPipeInfo{};
828 streamDescToOldPipeInfo[100001] = pipe1;
829 streamDescToOldPipeInfo[100002] = pipe2;
830
831 audioPipeSelector->DecidePipesAndStreamAction(newPipeInfoList, streamDescToOldPipeInfo);
832 EXPECT_TRUE(newPipeInfoList[0]->streamDescriptors_[0]->streamAction_ == AUDIO_STREAM_ACTION_DEFAULT);
833 }
834
835 } // namespace AudioStandard
836 } // namespace OHOS