1 /*
2 * Copyright (c) 2024 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_service_log.h"
18 #include "audio_info.h"
19 #include "audio_ring_cache.h"
20 #include "audio_process_config.h"
21 #include "linear_pos_time_model.h"
22 #include "oh_audio_buffer.h"
23 #include <gtest/gtest.h>
24 #include "audio_endpoint.h"
25 #include "sink/i_audio_render_sink.h"
26 #include "common/hdi_adapter_info.h"
27 #include "manager/hdi_adapter_manager.h"
28 #include "audio_process_in_server.h"
29 #include "audio_endpoint.h"
30 #include "audio_service.h"
31
32 using namespace testing::ext;
33 namespace OHOS {
34 namespace AudioStandard {
35 constexpr int32_t DEFAULT_STREAM_ID = 10;
36
InitProcessConfig()37 static AudioProcessConfig InitProcessConfig()
38 {
39 AudioProcessConfig config;
40 config.appInfo.appUid = DEFAULT_STREAM_ID;
41 config.appInfo.appPid = DEFAULT_STREAM_ID;
42 config.streamInfo.format = SAMPLE_S32LE;
43 config.streamInfo.samplingRate = SAMPLE_RATE_48000;
44 config.streamInfo.channels = STEREO;
45 config.streamInfo.channelLayout = AudioChannelLayout::CH_LAYOUT_STEREO;
46 config.audioMode = AudioMode::AUDIO_MODE_RECORD;
47 config.streamType = AudioStreamType::STREAM_MUSIC;
48 config.deviceType = DEVICE_TYPE_USB_HEADSET;
49 return config;
50 }
51
52 class AudioEndpointSeparateUnitTest : public testing::Test {
53 public:
54 static void SetUpTestCase(void);
55 static void TearDownTestCase(void);
56 void SetUp();
57 void TearDown();
58 };
59
SetUpTestCase(void)60 void AudioEndpointSeparateUnitTest::SetUpTestCase(void)
61 {
62 // input testsuit setup step，setup invoked before all testcases
63 }
64
TearDownTestCase(void)65 void AudioEndpointSeparateUnitTest::TearDownTestCase(void)
66 {
67 // input testsuit teardown step，teardown invoked after all testcases
68 }
69
SetUp(void)70 void AudioEndpointSeparateUnitTest::SetUp(void)
71 {
72 // input testcase setup step，setup invoked before each testcases
73 }
74
TearDown(void)75 void AudioEndpointSeparateUnitTest::TearDown(void)
76 {
77 // input testcase teardown step，teardown invoked after each testcases
78 }
79
80 /**
81 * @tc.name : Test AudioEndpointSeparate API
82 * @tc.type : FUNC
83 * @tc.number: AudioEndpointSeparate_001
84 * @tc.desc : Test AudioEndpointSeparate::SetVolume
85 */
86 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_001, TestSize.Level1)
87 {
88 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
89 uint64_t id = 0;
90 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
91 float volume = 0.0f;
92 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
93 ptr->fastRenderId_ = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_FAST,
94 "endpoint_sep_test", true);
95 auto ret = ptr->SetVolume(streamType, volume);
96 HdiAdapterManager::GetInstance().ReleaseId(ptr->fastRenderId_);
97 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
98 }
99
100 /**
101 * @tc.name : Test AudioEndpointSeparate API
102 * @tc.type : FUNC
103 * @tc.number: AudioEndpointSeparate_002
104 * @tc.desc : Test AudioEndpointSeparate::SetVolume
105 */
106 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_002, TestSize.Level1)
107 {
108 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
109 uint64_t id = 0;
110 AudioStreamType streamType = AudioStreamType::STREAM_VOICE_CALL;
111 float volume = 0.0f;
112 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
113 ptr->fastRenderId_ = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_FAST,
114 "endpoint_sep_test", true);
115 streamType = AudioStreamType::STREAM_VOICE_CALL;
116 ptr->streamType_ = STREAM_DEFAULT;
117 auto ret = ptr->SetVolume(streamType, volume);
118 EXPECT_EQ(ret, SUCCESS);
119 HdiAdapterManager::GetInstance().ReleaseId(ptr->fastRenderId_);
120 }
121
122 /**
123 * @tc.name : Test AudioEndpointSeparate API
124 * @tc.type : FUNC
125 * @tc.number: AudioEndpointSeparate_003
126 * @tc.desc : Test AudioEndpointSeparate::ResolveBuffer
127 */
128 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_003, TestSize.Level1)
129 {
130 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
131 uint64_t id = 0;
132 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
133 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
134 ptr->isInited_ = false;
135 std::shared_ptr<OHAudioBuffer> buffer;
136 auto ret = ptr->ResolveBuffer(buffer);
137 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
138 }
139
140 /**
141 * @tc.name : Test AudioEndpointSeparate API
142 * @tc.type : FUNC
143 * @tc.number: AudioEndpointSeparate_004
144 * @tc.desc : Test AudioEndpointSeparate::ResolveBuffer
145 */
146 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_004, TestSize.Level1)
147 {
148 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
149 uint64_t id = 0;
150 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
151 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
152 ptr->isInited_ = true;
153 std::shared_ptr<OHAudioBuffer> buffer;
154 auto ret = ptr->ResolveBuffer(buffer);
155 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
156 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_CLIENT;
157 uint32_t totalSizeInFrame = 0;
158 uint32_t spanSizeInFrame = 0;
159 uint32_t byteSizePerFrame = 0;
160 ptr->dstAudioBuffer_ = std::make_shared<OHAudioBuffer>(bufferHolder, totalSizeInFrame,
161 spanSizeInFrame, byteSizePerFrame);
162 ptr->isInited_ = true;
163 ret = ptr->ResolveBuffer(buffer);
164 EXPECT_EQ(ret, SUCCESS);
165 }
166
167 /**
168 * @tc.name : Test AudioEndpointSeparate API
169 * @tc.type : FUNC
170 * @tc.number: AudioEndpointSeparate_005
171 * @tc.desc : Test AudioEndpointSeparate::Release
172 */
173 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_005, TestSize.Level1)
174 {
175 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
176 uint64_t id = 0;
177 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
178 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
179 ptr->isInited_ = false;
180 ptr->Release();
181 }
182
183 /**
184 * @tc.name : Test AudioEndpointSeparate API
185 * @tc.type : FUNC
186 * @tc.number: AudioEndpointSeparate_006
187 * @tc.desc : Test AudioEndpointSeparate::Release
188 */
189 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_006, TestSize.Level1)
190 {
191 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
192 uint64_t id = 0;
193 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
194 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
195 ptr->isInited_ = true;
196 ptr->fastRenderId_ = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_FAST,
197 "endpoint_sep_test", true);
198 ptr->Release();
199 }
200
201 /**
202 * @tc.name : Test AudioEndpointSeparate API
203 * @tc.type : FUNC
204 * @tc.number: AudioEndpointSeparate_007
205 * @tc.desc : Test AudioEndpointSeparate::Release
206 */
207 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_007, TestSize.Level1)
208 {
209 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
210 uint64_t id = 0;
211 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
212 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
213 ptr->isInited_ = true;
214 ptr->fastRenderId_ = HDI_INVALID_ID;
215 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_CLIENT;
216 uint32_t totalSizeInFrame = 0;
217 uint32_t spanSizeInFrame = 0;
218 uint32_t byteSizePerFrame = 0;
219 ptr->dstAudioBuffer_ = std::make_shared<OHAudioBuffer>(bufferHolder, totalSizeInFrame,
220 spanSizeInFrame, byteSizePerFrame);
221 ptr->Release();
222 ptr->isInited_ = true;
223 ptr->fastRenderId_ = HDI_INVALID_ID;
224 ptr->dstAudioBuffer_ = nullptr;
225 ptr->Release();
226 }
227
228 /**
229 * @tc.name : Test AudioEndpointSeparate API
230 * @tc.type : FUNC
231 * @tc.number: AudioEndpointSeparate_008
232 * @tc.desc : Test AudioEndpointSeparate::~AudioEndpointSeparate
233 */
234 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_008, TestSize.Level1)
235 {
236 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
237 uint64_t id = 0;
238 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
239 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
240 ptr->isInited_ = true;
241 }
242
243 /**
244 * @tc.name : Test AudioEndpointSeparate API
245 * @tc.type : FUNC
246 * @tc.number: AudioEndpointSeparate_009
247 * @tc.desc : Test AudioEndpointSeparate::Config
248 */
249 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_009, TestSize.Level1)
250 {
251 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
252 uint64_t id = 0;
253 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
254 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
255 std::shared_ptr<AudioDeviceDescriptor> ptr2 =
256 std::make_shared<AudioDeviceDescriptor>(AudioDeviceDescriptor::DEVICE_INFO);
257 ptr2->deviceRole_ = INPUT_DEVICE;
258 ptr2->networkId_ = REMOTE_NETWORK_ID;
259 auto ret = ptr->Config(*ptr2);
260 EXPECT_EQ(ret, false);
261 ptr2->deviceRole_ = INPUT_DEVICE;
262 ptr2->networkId_ = LOCAL_NETWORK_ID;
263 ret = ptr->Config(*ptr2);
264 EXPECT_EQ(ret, false);
265 ptr2->deviceRole_ = OUTPUT_DEVICE;
266 ptr2->networkId_ = REMOTE_NETWORK_ID;
267 ret = ptr->Config(*ptr2);
268 EXPECT_EQ(ret, false);
269 }
270
271 /**
272 * @tc.name : Test AudioEndpointSeparate API
273 * @tc.type : FUNC
274 * @tc.number: AudioEndpointSeparate_010
275 * @tc.desc : Test AudioEndpointSeparate::GetAdapterBufferInfo
276 */
277 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_010, TestSize.Level1)
278 {
279 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
280 uint64_t id = 0;
281 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
282 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
283 std::shared_ptr<AudioDeviceDescriptor> ptr2 =
284 std::make_shared<AudioDeviceDescriptor>(AudioDeviceDescriptor::DEVICE_INFO);
285 auto ret = ptr->GetAdapterBufferInfo(*ptr2);
286 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
287 ptr->dstBufferFd_ = 0;
288 ptr->dstTotalSizeInframe_ = 1;
289 ptr->dstSpanSizeInframe_ = 1;
290 ptr->dstBufferFd_ = 1;
291 ptr->fastRenderId_ = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_FAST,
292 "endpoint_sep_test", true);
293 ret = ptr->GetAdapterBufferInfo(*ptr2);
294 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
295 HdiAdapterManager::GetInstance().ReleaseId(ptr->fastRenderId_);
296 }
297
298 /**
299 * @tc.name : Test AudioEndpointSeparate API
300 * @tc.type : FUNC
301 * @tc.number: AudioEndpointSeparate_011
302 * @tc.desc : Test AudioEndpointSeparate::GetAdapterBufferInfo
303 */
304 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_011, TestSize.Level1)
305 {
306 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
307 uint64_t id = 0;
308 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
309 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
310 std::shared_ptr<AudioDeviceDescriptor> ptr2 =
311 std::make_shared<AudioDeviceDescriptor>(AudioDeviceDescriptor::DEVICE_INFO);
312 ptr->fastRenderId_ = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_FAST,
313 "endpoint_sep_test", true);
314 ptr->dstBufferFd_ = -1;
315 ptr->dstTotalSizeInframe_ = 1;
316 ptr->dstSpanSizeInframe_ = 1;
317 ptr->dstBufferFd_ = 1;
318 auto ret = ptr->GetAdapterBufferInfo(*ptr2);
319 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
320 ptr->dstBufferFd_ = 0;
321 ptr->dstTotalSizeInframe_ = 0;
322 ptr->dstSpanSizeInframe_ = 1;
323 ptr->dstBufferFd_ = 1;
324 ret = ptr->GetAdapterBufferInfo(*ptr2);
325 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
326 ptr->dstBufferFd_ = 0;
327 ptr->dstTotalSizeInframe_ = 1;
328 ptr->dstSpanSizeInframe_ = 0;
329 ptr->dstBufferFd_ = 1;
330 ret = ptr->GetAdapterBufferInfo(*ptr2);
331 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
332 ptr->dstBufferFd_ = 0;
333 ptr->dstTotalSizeInframe_ = 1;
334 ptr->dstSpanSizeInframe_ = 1;
335 ptr->dstBufferFd_ = 0;
336 ret = ptr->GetAdapterBufferInfo(*ptr2);
337 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
338 HdiAdapterManager::GetInstance().ReleaseId(ptr->fastRenderId_);
339 }
340
341 /**
342 * @tc.name : Test AudioEndpointSeparate API
343 * @tc.type : FUNC
344 * @tc.number: AudioEndpointSeparate_012
345 * @tc.desc : Test AudioEndpointSeparate::PrepareDeviceBuffer
346 */
347 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_012, TestSize.Level1)
348 {
349 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
350 uint64_t id = 0;
351 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
352 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
353 std::shared_ptr<AudioDeviceDescriptor> ptr2 =
354 std::make_shared<AudioDeviceDescriptor>(AudioDeviceDescriptor::DEVICE_INFO);
355 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_CLIENT;
356 uint32_t totalSizeInFrame = 0;
357 uint32_t spanSizeInFrame = 0;
358 uint32_t byteSizePerFrame = 0;
359 ptr->dstAudioBuffer_ = std::make_shared<OHAudioBuffer>(bufferHolder, totalSizeInFrame,
360 spanSizeInFrame, byteSizePerFrame);
361 auto ret = ptr->PrepareDeviceBuffer(*ptr2);
362 EXPECT_EQ(ret, SUCCESS);
363 }
364
365 /**
366 * @tc.name : Test AudioEndpointSeparate API
367 * @tc.type : FUNC
368 * @tc.number: AudioEndpointSeparate_013
369 * @tc.desc : Test AudioEndpointSeparate::PrepareDeviceBuffer
370 */
371 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_013, TestSize.Level1)
372 {
373 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
374 uint64_t id = 0;
375 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
376 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
377 std::shared_ptr<AudioDeviceDescriptor> ptr2 =
378 std::make_shared<AudioDeviceDescriptor>(AudioDeviceDescriptor::DEVICE_INFO);
379 ptr->dstAudioBuffer_ = nullptr;
380 ptr->PrepareDeviceBuffer(*ptr2);
381 }
382
383 /**
384 * @tc.name : Test AudioEndpointSeparate API
385 * @tc.type : FUNC
386 * @tc.number: AudioEndpointSeparate_014
387 * @tc.desc : Test AudioEndpointSeparate::InitAudiobuffer
388 */
389 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_014, TestSize.Level1)
390 {
391 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
392 uint64_t id = 0;
393 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
394 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
395 bool resetReadWritePos = true;
396 ptr->InitAudiobuffer(resetReadWritePos);
397 resetReadWritePos = false;
398 ptr->InitAudiobuffer(resetReadWritePos);
399 ptr->deviceInfo_.deviceRole_ = INPUT_DEVICE;
400 ptr->InitAudiobuffer(resetReadWritePos);
401 ptr->deviceInfo_.deviceRole_ = OUTPUT_DEVICE;
402 ptr->InitAudiobuffer(resetReadWritePos);
403 }
404
405 /**
406 * @tc.name : Test AudioEndpointSeparate API
407 * @tc.type : FUNC
408 * @tc.number: AudioEndpointSeparate_015
409 * @tc.desc : Test AudioEndpointSeparate::IsAnyProcessRunning
410 */
411 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_015, TestSize.Level1)
412 {
413 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
414 uint64_t id = 0;
415 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
416 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
417 ptr->processBufferList_.clear();
418 auto ret = ptr->IsAnyProcessRunning();
419 EXPECT_EQ(ret, false);
420 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_CLIENT;
421 uint32_t totalSizeInFrame = 0;
422 uint32_t spanSizeInFrame = 0;
423 uint32_t byteSizePerFrame = 0;
424 std::shared_ptr<OHAudioBuffer> processBuffer = std::make_shared<OHAudioBuffer>(bufferHolder, totalSizeInFrame,
425 spanSizeInFrame, byteSizePerFrame);
426 ptr->processBufferList_.push_back(processBuffer);
427 ret = ptr->IsAnyProcessRunning();
428 EXPECT_EQ(ret, false);
429 }
430
431 /**
432 * @tc.name : Test AudioEndpointSeparate API
433 * @tc.type : FUNC
434 * @tc.number: AudioEndpointSeparate_016
435 * @tc.desc : Test AudioEndpointSeparate::ResyncPosition
436 */
437 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_016, TestSize.Level1)
438 {
439 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
440 uint64_t id = 0;
441 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
442 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
443 ptr->ResyncPosition();
444 }
445
446 /**
447 * @tc.name : Test AudioEndpointSeparate API
448 * @tc.type : FUNC
449 * @tc.number: AudioEndpointSeparate_017
450 * @tc.desc : Test AudioEndpointSeparate::StartDevice
451 */
452 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_017, TestSize.Level1)
453 {
454 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
455 uint64_t id = 0;
456 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
457 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
458 ptr->endpointStatus_.store(AudioEndpoint::EndpointStatus::INVALID);
459 auto ret = ptr->StartDevice();
460 EXPECT_EQ(ret, false);
461 }
462
463 /**
464 * @tc.name : Test AudioEndpointSeparate API
465 * @tc.type : FUNC
466 * @tc.number: AudioEndpointSeparate_018
467 * @tc.desc : Test AudioEndpointSeparate::StartDevice
468 */
469 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_018, TestSize.Level1)
470 {
471 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
472 uint64_t id = 0;
473 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
474 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
475 ptr->endpointStatus_.store(AudioEndpoint::EndpointStatus::IDEL);
476 ptr->fastRenderId_ = HDI_INVALID_ID;
477 auto ret = ptr->StartDevice();
478 EXPECT_EQ(ret, false);
479 }
480
481 /**
482 * @tc.name : Test AudioEndpointSeparate API
483 * @tc.type : FUNC
484 * @tc.number: AudioEndpointSeparate_019
485 * @tc.desc : Test AudioEndpointSeparate::StopDevice
486 */
487 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_019, TestSize.Level1)
488 {
489 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
490 uint64_t id = 0;
491 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
492 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
493 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_CLIENT;
494 uint32_t totalSizeInFrame = 0;
495 uint32_t spanSizeInFrame = 0;
496 uint32_t byteSizePerFrame = 0;
497 ptr->dstAudioBuffer_ = std::make_shared<OHAudioBuffer>(bufferHolder, totalSizeInFrame,
498 spanSizeInFrame, byteSizePerFrame);
499 ptr->StopDevice();
500 ptr->dstAudioBuffer_ = nullptr;
501 ptr->StopDevice();
502 }
503
504 /**
505 * @tc.name : Test AudioEndpointSeparate API
506 * @tc.type : FUNC
507 * @tc.number: AudioEndpointSeparate_020
508 * @tc.desc : Test AudioEndpointSeparate::OnStart
509 */
510 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_020, TestSize.Level1)
511 {
512 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
513 uint64_t id = 0;
514 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
515 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
516 IAudioProcessStream *processStream = nullptr;
517 ptr->endpointStatus_.store(AudioEndpoint::EndpointStatus::RUNNING);
518 auto ret = ptr->OnStart(processStream);
519 EXPECT_EQ(ret, SUCCESS);
520 ptr->endpointStatus_.store(AudioEndpoint::EndpointStatus::IDEL);
521 ptr->isDeviceRunningInIdel_ = false;
522 ret = ptr->OnStart(processStream);
523 EXPECT_EQ(ret, SUCCESS);
524 ptr->endpointStatus_.store(AudioEndpoint::EndpointStatus::IDEL);
525 ptr->isDeviceRunningInIdel_ = true;
526 ret = ptr->OnStart(processStream);
527 EXPECT_EQ(ret, SUCCESS);
528 ptr->endpointStatus_.store(AudioEndpoint::EndpointStatus::STOPPING);
529 ret = ptr->OnStart(processStream);
530 EXPECT_EQ(ret, SUCCESS);
531 }
532
533 /**
534 * @tc.name : Test AudioEndpointSeparate API
535 * @tc.type : FUNC
536 * @tc.number: AudioEndpointSeparate_021
537 * @tc.desc : Test AudioEndpointSeparate::OnPause
538 */
539 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_021, TestSize.Level1)
540 {
541 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
542 uint64_t id = 0;
543 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
544 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
545 IAudioProcessStream *processStream = nullptr;
546 ptr->endpointStatus_.store(AudioEndpoint::EndpointStatus::RUNNING);
547 auto ret = ptr->OnPause(processStream);
548 EXPECT_EQ(ret, SUCCESS);
549 ptr->endpointStatus_.store(AudioEndpoint::EndpointStatus::IDEL);
550 ptr->isDeviceRunningInIdel_ = false;
551 ret = ptr->OnPause(processStream);
552 EXPECT_EQ(ret, SUCCESS);
553 ptr->endpointStatus_.store(AudioEndpoint::EndpointStatus::IDEL);
554 ptr->isDeviceRunningInIdel_ = true;
555 ret = ptr->OnPause(processStream);
556 EXPECT_EQ(ret, SUCCESS);
557 ptr->endpointStatus_.store(AudioEndpoint::EndpointStatus::STOPPING);
558 ret = ptr->OnPause(processStream);
559 EXPECT_EQ(ret, SUCCESS);
560 }
561
562 /**
563 * @tc.name : Test AudioEndpointSeparate API
564 * @tc.type : FUNC
565 * @tc.number: AudioEndpointSeparate_022
566 * @tc.desc : Test AudioEndpointSeparate::OnUpdateHandleInfo
567 */
568 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_022, TestSize.Level1)
569 {
570 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
571 uint64_t id = 0;
572 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
573 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
574 IAudioProcessStream *processStream = nullptr;
575 ptr->OnUpdateHandleInfo(processStream);
576 }
577
578 /**
579 * @tc.name : Test AudioEndpointSeparate API
580 * @tc.type : FUNC
581 * @tc.number: AudioEndpointSeparate_023
582 * @tc.desc : Test AudioEndpointSeparate::ProcessData
583 */
584 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_023, TestSize.Level1)
585 {
586 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
587 uint64_t id = 0;
588 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
589 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
590 std::vector<AudioStreamData> srcDataList;
591 AudioStreamData dstData;
592 ptr->ProcessData(srcDataList, dstData);
593 }
594
595 /**
596 * @tc.name : Test AudioEndpointSeparate API
597 * @tc.type : FUNC
598 * @tc.number: AudioEndpointSeparate_024
599 * @tc.desc : Test AudioEndpointSeparate::GetDeviceHandleInfo
600 */
601 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_024, TestSize.Level1)
602 {
603 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
604 uint64_t id = 0;
605 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
606 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
607 uint64_t frames = 0;
608 int64_t nanoTime = 0;
609 ptr->fastRenderId_ = HDI_INVALID_ID;
610 auto ret = ptr->GetDeviceHandleInfo(frames, nanoTime);
611 EXPECT_EQ(ret, false);
612 ptr->GetDeviceHandleInfo(frames, nanoTime);
613 }
614
615 /**
616 * @tc.name : Test AudioEndpointSeparate API
617 * @tc.type : FUNC
618 * @tc.number: AudioEndpointSeparate_025
619 * @tc.desc : Test AudioEndpointSeparate::GetStatusStr
620 */
621 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_025, TestSize.Level1)
622 {
623 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
624 uint64_t id = 0;
625 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
626 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
627 enum AudioEndpoint::EndpointStatus status = AudioEndpoint::EndpointStatus::INVALID;
628 auto ret = ptr->GetStatusStr(status);
629 EXPECT_EQ(ret, "INVALID");
630 status = AudioEndpoint::EndpointStatus::UNLINKED;
631 ret = ptr->GetStatusStr(status);
632 EXPECT_EQ(ret, "UNLINKED");
633 status = AudioEndpoint::EndpointStatus::IDEL;
634 ret = ptr->GetStatusStr(status);
635 EXPECT_EQ(ret, "IDEL");
636 status = AudioEndpoint::EndpointStatus::STARTING;
637 ret = ptr->GetStatusStr(status);
638 EXPECT_EQ(ret, "STARTING");
639 status = AudioEndpoint::EndpointStatus::RUNNING;
640 ret = ptr->GetStatusStr(status);
641 EXPECT_EQ(ret, "RUNNING");
642 status = AudioEndpoint::EndpointStatus::STOPPING;
643 ret = ptr->GetStatusStr(status);
644 EXPECT_EQ(ret, "STOPPING");
645 status = AudioEndpoint::EndpointStatus::STOPPED;
646 ret = ptr->GetStatusStr(status);
647 EXPECT_EQ(ret, "STOPPED");
648 const int noSuchStatus = 7;
649 status = static_cast<AudioEndpoint::EndpointStatus>(noSuchStatus);
650 ret = ptr->GetStatusStr(status);
651 EXPECT_EQ(ret, "NO_SUCH_STATUS");
652 }
653
654 /**
655 * @tc.name : Test AudioEndpointSeparate API
656 * @tc.type : FUNC
657 * @tc.number: AudioEndpointSeparate_026
658 * @tc.desc : Test AudioEndpointSeparate::WriteToProcessBuffers
659 */
660 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_026, TestSize.Level1)
661 {
662 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
663 uint64_t id = 0;
664 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
665 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
666 struct BufferDesc readBuf;
667 ptr->WriteToProcessBuffers(readBuf);
668 }
669
670 /**
671 * @tc.name : Test AudioEndpointSeparate API
672 * @tc.type : FUNC
673 * @tc.number: AudioEndpointSeparate_027
674 * @tc.desc : Test static enum AudioSampleFormat ConvertToHdiAdapterFormat
675 */
676 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_027, TestSize.Level1)
677 {
678 AudioSampleFormat format = SAMPLE_U8;
679 auto ret = ConvertToHdiAdapterFormat(format);
680 EXPECT_EQ(ret, SAMPLE_U8);
681 format = SAMPLE_S16LE;
682 ret = ConvertToHdiAdapterFormat(format);
683 EXPECT_EQ(ret, SAMPLE_S16LE);
684 format = SAMPLE_S24LE;
685 ret = ConvertToHdiAdapterFormat(format);
686 EXPECT_EQ(ret, SAMPLE_S24LE);
687 format = SAMPLE_S32LE;
688 ret = ConvertToHdiAdapterFormat(format);
689 EXPECT_EQ(ret, SAMPLE_S32LE);
690 format = SAMPLE_F32LE;
691 ret = ConvertToHdiAdapterFormat(format);
692 EXPECT_EQ(ret, SAMPLE_F32LE);
693 format = INVALID_WIDTH;
694 ret = ConvertToHdiAdapterFormat(format);
695 EXPECT_EQ(ret, INVALID_WIDTH);
696 }
697
698 /**
699 * @tc.name : Test AudioEndpointSeparate API
700 * @tc.type : FUNC
701 * @tc.number: AudioEndpointSeparate_028
702 * @tc.desc : Test AudioEndpointSeparate::Config
703 */
704 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_028, TestSize.Level1)
705 {
706 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
707 uint64_t id = 0;
708 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
709 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
710
711 std::shared_ptr<AudioDeviceDescriptor> ptr2 =
712 std::make_shared<AudioDeviceDescriptor>(AudioDeviceDescriptor::DEVICE_INFO);
713 ptr2->deviceRole_ = OUTPUT_DEVICE;
714 ptr2->networkId_ = LOCAL_NETWORK_ID;
715 ptr->Config(*ptr2);
716 }
717
718 /**
719 * @tc.name : Test AudioEndpointSeparate API
720 * @tc.type : FUNC
721 * @tc.number: AudioEndpointSeparate_029
722 * @tc.desc : Test AudioEndpointSeparate::InitAudiobuffer
723 */
724 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_029, TestSize.Level1)
725 {
726 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
727 uint64_t id = 0;
728 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
729 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
730
731 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_CLIENT;
732 uint32_t totalSizeInFrame = 0;
733 uint32_t spanSizeInFrame = 0;
734 uint32_t byteSizePerFrame = 0;
735 ptr->dstAudioBuffer_ = std::make_shared<OHAudioBuffer>(bufferHolder, totalSizeInFrame,
736 spanSizeInFrame, byteSizePerFrame);
737
738 bool resetReadWritePos = true;
739 ptr->InitAudiobuffer(resetReadWritePos);
740 resetReadWritePos = false;
741 ptr->InitAudiobuffer(resetReadWritePos);
742 ptr->deviceInfo_.deviceRole_ = INPUT_DEVICE;
743 ptr->InitAudiobuffer(resetReadWritePos);
744 ptr->deviceInfo_.deviceRole_ = OUTPUT_DEVICE;
745 ptr->InitAudiobuffer(resetReadWritePos);
746 }
747
748 /**
749 * @tc.name : Test AudioEndpointSeparate API
750 * @tc.type : FUNC
751 * @tc.number: AudioEndpointSeparate_040
752 * @tc.desc : Test AudioEndpointSeparate::ProcessData
753 */
754 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_030, TestSize.Level1)
755 {
756 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
757 uint64_t id = 0;
758 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
759 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
760
761 AudioStreamInfo streamInfo;
762 streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
763 streamInfo.channels = AudioChannel::STEREO;
764 BufferDesc bufferDesc = {nullptr, 0, 0};
765 int32_t volumeStart = 0;
766 int32_t volumeEnd = 0;
767 std::unordered_map<int32_t, bool> isInnerCaped;
768
769 AudioStreamData tddData = {streamInfo, bufferDesc, volumeStart, volumeEnd, isInnerCaped};
770 std::vector<AudioStreamData> srcDataList;
771 srcDataList.push_back(tddData);
772
773 BufferDesc bufferDesc_2 = {nullptr, 0, 1};
774 AudioStreamData dstData = {streamInfo, bufferDesc_2, volumeStart, volumeEnd, isInnerCaped};
775
776 ptr->ProcessData(srcDataList, dstData);
777 }
778
779 /**
780 * @tc.name : Test AudioEndpointSeparate API
781 * @tc.type : FUNC
782 * @tc.number: AudioEndpointSeparate_031
783 * @tc.desc : Test AudioEndpointSeparate::StartDevice
784 */
785 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_031, TestSize.Level1)
786 {
787 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
788 uint64_t id = 0;
789 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
790 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
791
792 ptr->endpointStatus_.store(AudioEndpoint::EndpointStatus::IDEL);
793 ptr->fastRenderId_ = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_FAST,
794 "endpoint_sep_test", true);
795 auto ret = ptr->StartDevice();
796 EXPECT_EQ(ret, false);
797 HdiAdapterManager::GetInstance().ReleaseId(ptr->fastRenderId_);
798 }
799
800 /**
801 * @tc.name : Test AudioEndpointSeparate API
802 * @tc.type : FUNC
803 * @tc.number: AudioEndpointSeparate_032
804 * @tc.desc : Test AudioEndpointSeparate::ProcessData
805 */
806 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_032, TestSize.Level1)
807 {
808 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
809 uint64_t id = 0;
810 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
811 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
812
813 AudioStreamInfo streamInfo;
814 streamInfo.format = AudioSampleFormat::INVALID_WIDTH;
815 BufferDesc bufferDesc;
816 int32_t volumeStart = 0;
817 int32_t volumeEnd = 0;
818 std::unordered_map<int32_t, bool> isInnerCaped;
819
820 AudioStreamData tddData = {streamInfo, bufferDesc, volumeStart, volumeEnd, isInnerCaped};
821
822 std::vector<AudioStreamData> srcDataList;
823 srcDataList.push_back(tddData);
824 AudioStreamData dstData = tddData;
825
826 ptr->ProcessData(srcDataList, dstData);
827 }
828
829 /**
830 * @tc.name : Test AudioEndpointSeparate API
831 * @tc.type : FUNC
832 * @tc.number: AudioEndpointSeparate_033
833 * @tc.desc : Test AudioEndpointSeparate::ProcessData
834 */
835 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_033, TestSize.Level1)
836 {
837 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
838 uint64_t id = 0;
839 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
840 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
841
842 AudioStreamInfo streamInfo;
843 streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
844 streamInfo.channels = AudioChannel::STEREO;
845 BufferDesc bufferDesc;
846 int32_t volumeStart = 0;
847 int32_t volumeEnd = 0;
848 std::unordered_map<int32_t, bool> isInnerCaped;
849
850 AudioStreamData tddData = {streamInfo, bufferDesc, volumeStart, volumeEnd, isInnerCaped};
851 std::vector<AudioStreamData> srcDataList;
852 srcDataList.push_back(tddData);
853
854 AudioStreamInfo streamInfo_2;
855 streamInfo_2.format = AudioSampleFormat::SAMPLE_S16LE;
856 streamInfo_2.channels = AudioChannel::STEREO;
857 AudioStreamData dstData = {streamInfo_2, bufferDesc, volumeStart, volumeEnd, isInnerCaped};
858
859 ptr->ProcessData(srcDataList, dstData);
860 }
861
862 /**
863 * @tc.name : Test AudioEndpointSeparate API
864 * @tc.type : FUNC
865 * @tc.number: AudioEndpointSeparate_034
866 * @tc.desc : Test AudioEndpointSeparate::ProcessData
867 */
868 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_034, TestSize.Level1)
869 {
870 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
871 uint64_t id = 0;
872 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
873 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
874
875 AudioStreamInfo streamInfo;
876 streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
877 streamInfo.channels = AudioChannel::STEREO;
878 BufferDesc bufferDesc = {nullptr, 0, 0};
879 int32_t volumeStart = 0;
880 int32_t volumeEnd = 0;
881 std::unordered_map<int32_t, bool> isInnerCaped;
882
883 AudioStreamData tddData = {streamInfo, bufferDesc, volumeStart, volumeEnd, isInnerCaped};
884 std::vector<AudioStreamData> srcDataList;
885 srcDataList.push_back(tddData);
886
887 BufferDesc bufferDesc_2 = {nullptr, 1, 0};
888 AudioStreamData dstData = {streamInfo, bufferDesc_2, volumeStart, volumeEnd, isInnerCaped};
889
890 ptr->ProcessData(srcDataList, dstData);
891 }
892
893 /**
894 * @tc.name : Test AudioEndpointSeparate API
895 * @tc.type : FUNC
896 * @tc.number: AudioEndpointSeparate_035
897 * @tc.desc : Test AudioEndpointSeparate::ProcessData
898 */
899 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_035, TestSize.Level1)
900 {
901 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
902 uint64_t id = 0;
903 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
904 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
905
906 AudioStreamInfo streamInfo;
907 streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
908 streamInfo.channels = AudioChannel::MONO;
909 BufferDesc bufferDesc;
910 int32_t volumeStart = 0;
911 int32_t volumeEnd = 0;
912 std::unordered_map<int32_t, bool> isInnerCaped;
913
914 AudioStreamData tddData = {streamInfo, bufferDesc, volumeStart, volumeEnd, isInnerCaped};
915
916 std::vector<AudioStreamData> srcDataList;
917 srcDataList.push_back(tddData);
918 AudioStreamData dstData = tddData;
919
920 ptr->ProcessData(srcDataList, dstData);
921 }
922
923 /**
924 * @tc.name : Test AudioEndpointSeparate API
925 * @tc.type : FUNC
926 * @tc.number: AudioEndpointSeparate_036
927 * @tc.desc : Test AudioEndpointSeparate::ProcessData
928 */
929 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_036, TestSize.Level1)
930 {
931 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
932 uint64_t id = 0;
933 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
934 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
935
936 AudioStreamInfo streamInfo;
937 streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
938 streamInfo.channels = AudioChannel::STEREO;
939 BufferDesc bufferDesc;
940 int32_t volumeStart = 0;
941 int32_t volumeEnd = 0;
942 std::unordered_map<int32_t, bool> isInnerCaped;
943
944 AudioStreamData tddData = {streamInfo, bufferDesc, volumeStart, volumeEnd, isInnerCaped};
945 std::vector<AudioStreamData> srcDataList;
946 srcDataList.push_back(tddData);
947
948 AudioStreamInfo streamInfo_2;
949 streamInfo_2.format = AudioSampleFormat::INVALID_WIDTH;
950 AudioStreamData dstData = {streamInfo_2, bufferDesc, volumeStart, volumeEnd, isInnerCaped};
951
952 ptr->ProcessData(srcDataList, dstData);
953 }
954
955 /**
956 * @tc.name : Test AudioEndpointSeparate API
957 * @tc.type : FUNC
958 * @tc.number: AudioEndpointSeparate_037
959 * @tc.desc : Test AudioEndpointSeparate::ProcessData
960 */
961 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_037, TestSize.Level1)
962 {
963 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
964 uint64_t id = 0;
965 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
966 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
967
968 AudioStreamInfo streamInfo;
969 streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
970 streamInfo.channels = AudioChannel::STEREO;
971 BufferDesc bufferDesc;
972 int32_t volumeStart = 0;
973 int32_t volumeEnd = 0;
974 std::unordered_map<int32_t, bool> isInnerCaped;
975
976 AudioStreamData tddData = {streamInfo, bufferDesc, volumeStart, volumeEnd, isInnerCaped};
977 std::vector<AudioStreamData> srcDataList;
978 srcDataList.push_back(tddData);
979
980 AudioStreamInfo streamInfo_2;
981 streamInfo_2.format = AudioSampleFormat::SAMPLE_S16LE;
982 streamInfo_2.channels = AudioChannel::MONO;
983 AudioStreamData dstData = {streamInfo_2, bufferDesc, volumeStart, volumeEnd, isInnerCaped};
984
985 ptr->ProcessData(srcDataList, dstData);
986 }
987
988 /**
989 * @tc.name : Test AudioEndpointSeparate API
990 * @tc.type : FUNC
991 * @tc.number: AudioEndpointSeparate_038
992 * @tc.desc : Test AudioEndpointSeparate::IsAnyProcessRunning
993 */
994 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_038, TestSize.Level1)
995 {
996 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
997 uint64_t id = 0;
998 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
999 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
1000
1001 ptr->processBufferList_.clear();
1002 auto ret = ptr->IsAnyProcessRunning();
1003 EXPECT_EQ(ret, false);
1004
1005 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_CLIENT;
1006 uint32_t totalSizeInFrame = 0;
1007 uint32_t spanSizeInFrame = 0;
1008 uint32_t byteSizePerFrame = 0;
1009 std::shared_ptr<OHAudioBuffer> processBuffer = std::make_shared<OHAudioBuffer>(bufferHolder, totalSizeInFrame,
1010 spanSizeInFrame, byteSizePerFrame);
1011 processBuffer->basicBufferInfo_ = std::make_shared<BasicBufferInfo>().get();
1012 processBuffer->basicBufferInfo_->streamStatus.store(StreamStatus::STREAM_STARTING);
1013 ptr->processBufferList_.push_back(processBuffer);
1014 ret = ptr->IsAnyProcessRunning();
1015 EXPECT_EQ(ret, false);
1016
1017 ptr->processBufferList_.clear();
1018 processBuffer->basicBufferInfo_->streamStatus.store(StreamStatus::STREAM_RUNNING);
1019 ptr->processBufferList_.push_back(processBuffer);
1020 ret = ptr->IsAnyProcessRunning();
1021 EXPECT_EQ(ret, true);
1022 }
1023
1024 /**
1025 * @tc.name : Test AudioEndpointSeparate API
1026 * @tc.type : FUNC
1027 * @tc.number: AudioEndpointSeparate_039
1028 * @tc.desc : Test AudioEndpointSeparate::OnUpdateHandleInfo
1029 */
1030 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_039, TestSize.Level1)
1031 {
1032 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
1033 uint64_t id = 0;
1034 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
1035 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
1036
1037 AudioProcessConfig config = InitProcessConfig();
1038 AudioService *g_audioServicePtr = AudioService::GetInstance();
1039 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1040
1041 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_CLIENT;
1042 uint32_t totalSizeInFrame = 0;
1043 uint32_t spanSizeInFrame = 0;
1044 uint32_t byteSizePerFrame = 0;
1045
1046 processStream->isBufferConfiged_ = true;
1047 processStream->processBuffer_ = std::make_shared<OHAudioBuffer>(bufferHolder, totalSizeInFrame,
1048 spanSizeInFrame, byteSizePerFrame);
1049
1050 ptr->processList_.push_back(processStream);
1051 auto ret = ptr->OnUpdateHandleInfo(processStream);
1052 EXPECT_EQ(ret, SUCCESS);
1053 }
1054
1055 /**
1056 * @tc.name : Test AudioEndpointSeparate API
1057 * @tc.type : FUNC
1058 * @tc.number: AudioEndpointSeparate_040
1059 * @tc.desc : Test AudioEndpointSeparate::WriteToProcessBuffers
1060 */
1061 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_040, TestSize.Level1)
1062 {
1063 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
1064 uint64_t id = 0;
1065 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
1066 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
1067
1068 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_CLIENT;
1069 uint32_t totalSizeInFrame = 0;
1070 uint32_t spanSizeInFrame = 0;
1071 uint32_t byteSizePerFrame = 0;
1072 std::shared_ptr<OHAudioBuffer> processBuffer = std::make_shared<OHAudioBuffer>(bufferHolder, totalSizeInFrame,
1073 spanSizeInFrame, byteSizePerFrame);
1074 processBuffer->basicBufferInfo_ = std::make_shared<BasicBufferInfo>().get();
1075 processBuffer->basicBufferInfo_->streamStatus.store(StreamStatus::STREAM_RUNNING);
1076 ptr->processBufferList_.push_back(processBuffer);
1077
1078 struct BufferDesc readBuf;
1079 ptr->WriteToProcessBuffers(readBuf);
1080 }
1081
1082 /**
1083 * @tc.name : Test AudioEndpointSeparate API
1084 * @tc.type : FUNC
1085 * @tc.number: AudioEndpointSeparate_041
1086 * @tc.desc : Test AudioEndpointSeparate::WriteToProcessBuffers
1087 */
1088 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_041, TestSize.Level1)
1089 {
1090 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
1091 uint64_t id = 0;
1092 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
1093 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
1094
1095 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_CLIENT;
1096 uint32_t totalSizeInFrame = 0;
1097 uint32_t spanSizeInFrame = 0;
1098 uint32_t byteSizePerFrame = 0;
1099 std::shared_ptr<OHAudioBuffer> processBuffer = std::make_shared<OHAudioBuffer>(bufferHolder, totalSizeInFrame,
1100 spanSizeInFrame, byteSizePerFrame);
1101 processBuffer->basicBufferInfo_ = std::make_shared<BasicBufferInfo>().get();
1102 processBuffer->basicBufferInfo_->streamStatus.store(StreamStatus::STREAM_STARTING);
1103 ptr->processBufferList_.push_back(processBuffer);
1104
1105 struct BufferDesc readBuf;
1106 ptr->WriteToProcessBuffers(readBuf);
1107 }
1108
1109 /**
1110 * @tc.name : Test AudioEndpointSeparate API
1111 * @tc.type : FUNC
1112 * @tc.number: AudioEndpointSeparate_042
1113 * @tc.desc : Test AudioEndpointSeparate::WriteToProcessBuffers
1114 */
1115 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_042, TestSize.Level1)
1116 {
1117 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
1118 uint64_t id = 0;
1119 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
1120 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
1121
1122 std::shared_ptr<OHAudioBuffer> processBuffer = nullptr;
1123 ptr->processBufferList_.push_back(processBuffer);
1124
1125 struct BufferDesc readBuf;
1126 ptr->WriteToProcessBuffers(readBuf);
1127 }
1128
1129 /**
1130 * @tc.name : Test AudioEndpointSeparate API
1131 * @tc.type : FUNC
1132 * @tc.number: AudioEndpointSeparate_043
1133 * @tc.desc : Test AudioEndpointSeparate::WriteToProcessBuffers
1134 */
1135 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_043, TestSize.Level1)
1136 {
1137 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
1138 uint64_t id = 0;
1139 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
1140 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
1141
1142 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_CLIENT;
1143 uint32_t totalSizeInFrame = 0;
1144 uint32_t spanSizeInFrame = 0;
1145 uint32_t byteSizePerFrame = 0;
1146 std::shared_ptr<OHAudioBuffer> processBuffer = std::make_shared<OHAudioBuffer>(bufferHolder, totalSizeInFrame,
1147 spanSizeInFrame, byteSizePerFrame);
1148
1149 ptr->processBufferList_.push_back(processBuffer);
1150
1151 struct BufferDesc readBuf;
1152 ptr->WriteToProcessBuffers(readBuf);
1153 }
1154
1155 /**
1156 * @tc.name : Test AudioEndpointSeparate API
1157 * @tc.type : FUNC
1158 * @tc.number: AudioEndpointSeparate_044
1159 * @tc.desc : Test AudioEndpointSeparate::GetDeviceHandleInfo
1160 */
1161 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_044, TestSize.Level1)
1162 {
1163 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
1164 uint64_t id = 0;
1165 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
1166 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
1167 uint64_t frames = 0;
1168 int64_t nanoTime = 0;
1169 ptr->fastRenderId_ = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_FAST,
1170 "endpoint_sep_test", true);
1171 ptr->GetDeviceHandleInfo(frames, nanoTime);
1172 HdiAdapterManager::GetInstance().ReleaseId(ptr->fastRenderId_);
1173 }
1174
1175 /**
1176 * @tc.name : Test AudioEndpointSeparate API
1177 * @tc.type : FUNC
1178 * @tc.number: AudioEndpointSeparate_045
1179 * @tc.desc : Test AudioEndpointSeparate::ShouldInnerCap
1180 */
1181 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_045, TestSize.Level1)
1182 {
1183 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
1184 uint64_t id = 0;
1185 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
1186 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
1187 int32_t innerCapId = 0;
1188 bool ret = true;
1189
1190 ret = ptr->ShouldInnerCap(innerCapId);
1191 EXPECT_EQ(ret, false);
1192 }
1193
1194 /**
1195 * @tc.name : Test AudioEndpointSeparate API
1196 * @tc.type : FUNC
1197 * @tc.number: AudioEndpointSeparate_046
1198 * @tc.desc : Test AudioEndpointSeparate::EnableFastInnerCap
1199 */
1200 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_046, TestSize.Level1)
1201 {
1202 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
1203 uint64_t id = 0;
1204 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
1205 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
1206 int32_t innerCapId = 0;
1207 int32_t ret = 0;
1208
1209 ret = ptr->EnableFastInnerCap(innerCapId);
1210 EXPECT_EQ(ret, ERR_INVALID_OPERATION);
1211 }
1212
1213 /**
1214 * @tc.name : Test AudioEndpointSeparate API
1215 * @tc.type : FUNC
1216 * @tc.number: AudioEndpointSeparate_047
1217 * @tc.desc : Test AudioEndpointSeparate::GetBuffer
1218 */
1219 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_047, TestSize.Level1)
1220 {
1221 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
1222 uint64_t id = 0;
1223 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
1224 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
1225 std::shared_ptr<OHAudioBuffer> ret;
1226
1227 ret = ptr->GetBuffer();
1228 EXPECT_EQ(ret, nullptr);
1229 }
1230
1231 /**
1232 * @tc.name : Test AudioEndpointSeparate API
1233 * @tc.type : FUNC
1234 * @tc.number: AudioEndpointSeparate_048
1235 * @tc.desc : Test AudioEndpointSeparate::GetPreferBufferInfo
1236 */
1237 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_048, TestSize.Level1)
1238 {
1239 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
1240 uint64_t id = 0;
1241 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
1242 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
1243 uint32_t totalSizeInframe = 0;
1244 uint32_t spanSizeInframe = 0;
1245 int32_t ret = 0;
1246
1247 ret = ptr->GetPreferBufferInfo(totalSizeInframe, spanSizeInframe);
1248 EXPECT_EQ(ret, SUCCESS);
1249 }
1250
1251 /**
1252 * @tc.name : Test AudioEndpointSeparate API
1253 * @tc.type : FUNC
1254 * @tc.number: AudioEndpointSeparate_049
1255 * @tc.desc : Test AudioEndpointSeparate::GetMaxAmplitude
1256 */
1257 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_049, TestSize.Level1)
1258 {
1259 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
1260 uint64_t id = 0;
1261 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
1262 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
1263 float ret;
1264
1265 ret = ptr->GetMaxAmplitude();
1266 EXPECT_EQ(ret, 0);
1267 }
1268
1269 /**
1270 * @tc.name : Test AudioEndpointSeparate API
1271 * @tc.type : FUNC
1272 * @tc.number: AudioEndpointSeparate_050
1273 * @tc.desc : Test AudioEndpointSeparate::GetLinkedProcessCount
1274 */
1275 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_050, TestSize.Level1)
1276 {
1277 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
1278 uint64_t id = 0;
1279 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
1280 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
1281 uint32_t ret;
1282
1283 ret = ptr->GetLinkedProcessCount();
1284 EXPECT_EQ(ret, 0);
1285 }
1286
1287 /**
1288 * @tc.name : Test AudioEndpointSeparate API
1289 * @tc.type : FUNC
1290 * @tc.number: AudioEndpointSeparate_051
1291 * @tc.desc : Test AudioEndpointSeparate::GetAudioMode
1292 */
1293 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_051, TestSize.Level1)
1294 {
1295 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
1296 uint64_t id = 0;
1297 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
1298 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
1299 AudioMode ret;
1300
1301 ret = ptr->GetAudioMode();
1302 EXPECT_EQ(ret, AUDIO_MODE_PLAYBACK);
1303 }
1304
1305 /**
1306 * @tc.name : Test AudioEndpointSeparate API
1307 * @tc.type : FUNC
1308 * @tc.number: AudioEndpointSeparate_052
1309 * @tc.desc : Test AudioEndpointSeparate::GetProcLastWriteDoneInfo
1310 */
1311 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_052, TestSize.Level1)
1312 {
1313 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
1314 uint64_t id = 0;
1315 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
1316 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
1317 int32_t ret;
1318 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_SERVER_SHARED;
1319 uint32_t totalSizeInFrame = 96;
1320 uint32_t spanSizeInFrame = 16;
1321 uint32_t byteSizePerFrame = 4;
1322 std::shared_ptr<OHAudioBuffer> processBuffer = std::make_shared<OHAudioBuffer>(bufferHolder, totalSizeInFrame,
1323 spanSizeInFrame, byteSizePerFrame);
1324 uint64_t curWriteFrame = 0;
1325 uint64_t proHandleFrame = 0;
1326 int64_t proHandleTime = 0;
1327 int dataFd = INVALID_FD;
1328 int infoFd = AUDIO_SERVER_SHARED;
1329
1330 ret = processBuffer->Init(dataFd, infoFd);
1331 EXPECT_EQ(ret, SUCCESS);
1332
1333 ptr->dstSpanSizeInframe_ = 4;
1334 ret = ptr->GetProcLastWriteDoneInfo(processBuffer, curWriteFrame, proHandleFrame, proHandleTime);
1335 EXPECT_EQ(ret, SUCCESS);
1336
1337 curWriteFrame = 5;
1338 ret = ptr->GetProcLastWriteDoneInfo(processBuffer, curWriteFrame, proHandleFrame, proHandleTime);
1339 EXPECT_EQ(ret, SUCCESS);
1340 }
1341
1342 /**
1343 * @tc.name : Test AudioEndpointSeparate API
1344 * @tc.type : FUNC
1345 * @tc.number: AudioEndpointSeparate_053
1346 * @tc.desc : Test AudioEndpointSeparate::LinkProcessStream
1347 */
1348 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_053, TestSize.Level1)
1349 {
1350 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
1351 uint64_t id = 0;
1352 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
1353 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
1354
1355 AudioProcessConfig config = InitProcessConfig();
1356 AudioService *g_audioServicePtr = AudioService::GetInstance();
1357 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1358 bool startWhenLinking = false;
1359 int32_t ret = 0;
1360 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_CLIENT;
1361 uint32_t totalSizeInFrame = 0;
1362 uint32_t spanSizeInFrame = 0;
1363 uint32_t byteSizePerFrame = 0;
1364 std::shared_ptr<OHAudioBuffer> processBuffer = std::make_shared<OHAudioBuffer>(bufferHolder, totalSizeInFrame,
1365 spanSizeInFrame, byteSizePerFrame);
1366
1367 processBuffer->basicBufferInfo_ = std::make_shared<BasicBufferInfo>().get();
1368 processBuffer->basicBufferInfo_->streamStatus.store(StreamStatus::STREAM_STARTING);
1369 processStream->isBufferConfiged_ = true;
1370 processStream->processBuffer_ = processBuffer;
1371 ptr->processList_.push_back(processStream);
1372
1373 ptr->endpointStatus_ = AudioEndpoint::EndpointStatus::RUNNING;
1374 ret = ptr->LinkProcessStream(processStream, startWhenLinking);
1375 EXPECT_EQ(ret, SUCCESS);
1376
1377 ptr->endpointStatus_ = AudioEndpoint::EndpointStatus::UNLINKED;
1378 ret = ptr->LinkProcessStream(processStream, startWhenLinking);
1379 EXPECT_EQ(ret, SUCCESS);
1380
1381 processBuffer->basicBufferInfo_->streamStatus.store(StreamStatus::STREAM_RUNNING);
1382 ptr->isDeviceRunningInIdel_ = true;
1383 ptr->endpointStatus_ = AudioEndpoint::EndpointStatus::UNLINKED;
1384 ret = ptr->LinkProcessStream(processStream, startWhenLinking);
1385 EXPECT_EQ(ret, SUCCESS);
1386
1387 processBuffer->basicBufferInfo_->streamStatus.store(StreamStatus::STREAM_RUNNING);
1388 ptr->isDeviceRunningInIdel_ = false;
1389 ptr->endpointStatus_ = AudioEndpoint::EndpointStatus::UNLINKED;
1390 ret = ptr->LinkProcessStream(processStream, startWhenLinking);
1391 EXPECT_EQ(ret, SUCCESS);
1392
1393 processBuffer->basicBufferInfo_->streamStatus.store(StreamStatus::STREAM_RUNNING);
1394 ptr->isDeviceRunningInIdel_ = false;
1395 ptr->endpointStatus_ = AudioEndpoint::EndpointStatus::INVALID;
1396 ret = ptr->LinkProcessStream(processStream, startWhenLinking);
1397 EXPECT_EQ(ret, SUCCESS);
1398 }
1399
1400 /**
1401 * @tc.name : Test AudioEndpointSeparate API
1402 * @tc.type : FUNC
1403 * @tc.number: AudioEndpointSeparate_054
1404 * @tc.desc : Test AudioEndpointSeparate::UnlinkProcessStream
1405 */
1406 HWTEST(AudioEndpointSeparateUnitTest, AudioEndpointSeparate_054, TestSize.Level1)
1407 {
1408 AudioEndpoint::EndpointType type = AudioEndpoint::EndpointType::TYPE_MMAP;
1409 uint64_t id = 0;
1410 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
1411 std::shared_ptr<AudioEndpointSeparate> ptr = std::make_shared<AudioEndpointSeparate>(type, id, streamType);
1412
1413 AudioProcessConfig config = InitProcessConfig();
1414 AudioService *g_audioServicePtr = AudioService::GetInstance();
1415 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1416 int32_t ret = 0;
1417 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_CLIENT;
1418 uint32_t totalSizeInFrame = 0;
1419 uint32_t spanSizeInFrame = 0;
1420 uint32_t byteSizePerFrame = 0;
1421 std::shared_ptr<OHAudioBuffer> processBuffer = std::make_shared<OHAudioBuffer>(bufferHolder, totalSizeInFrame,
1422 spanSizeInFrame, byteSizePerFrame);
1423
1424 processBuffer->basicBufferInfo_ = std::make_shared<BasicBufferInfo>().get();
1425 processBuffer->basicBufferInfo_->streamStatus.store(StreamStatus::STREAM_STARTING);
1426 processStream->isBufferConfiged_ = true;
1427 processStream->processBuffer_ = processBuffer;
1428 ptr->processList_.push_back(processStream);
1429 ptr->processBufferList_.push_back(processBuffer);
1430
1431 ptr->endpointStatus_ = AudioEndpoint::EndpointStatus::RUNNING;
1432 ret = ptr->UnlinkProcessStream(processStream);
1433 EXPECT_EQ(ret, SUCCESS);
1434 }
1435 } // namespace AudioStandard
1436 } // namespace OHOS
1437