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 <gtest/gtest.h>
17
18 #include "audio_service_log.h"
19 #include "audio_service.h"
20 #include "audio_errors.h"
21 #include "audio_process_in_client.h"
22 #include "audio_process_in_client.cpp"
23 #include "fast_audio_stream.h"
24
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace AudioStandard {
29
30 class AudioProcessInClientUnitTest : public testing::Test {
31 public:
32 static void SetUpTestCase(void);
33 static void TearDownTestCase(void);
34 void SetUp();
35 void TearDown();
36 };
37
38 constexpr int32_t DEFAULT_STREAM_ID = 10;
39 constexpr size_t NUMBER1 = 1;
40 constexpr size_t NUMBER4 = 4;
41 constexpr size_t NUMBER6 = 6;
42
InitProcessConfig()43 static AudioProcessConfig InitProcessConfig()
44 {
45 AudioProcessConfig config;
46 config.appInfo.appUid = DEFAULT_STREAM_ID;
47 config.appInfo.appPid = DEFAULT_STREAM_ID;
48 config.streamInfo.format = SAMPLE_S32LE;
49 config.streamInfo.samplingRate = SAMPLE_RATE_48000;
50 config.streamInfo.channels = STEREO;
51 config.streamInfo.channelLayout = AudioChannelLayout::CH_LAYOUT_STEREO;
52 config.audioMode = AudioMode::AUDIO_MODE_RECORD;
53 config.streamType = AudioStreamType::STREAM_MUSIC;
54 config.deviceType = DEVICE_TYPE_USB_HEADSET;
55 return config;
56 }
57
58 /**
59 * @tc.name : Test AudioProcessInClientInner API
60 * @tc.type : FUNC
61 * @tc.number: AudioProcessInClientInner_001
62 * @tc.desc : Test AudioProcessInClientInner::SetPreferredFrameSize
63 */
64 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_001, TestSize.Level1)
65 {
66 AudioProcessConfig config = InitProcessConfig();
67 AudioService *g_audioServicePtr = AudioService::GetInstance();
68 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
69 bool isVoipMmap = true;
70 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
71
72 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
73
74 int32_t frameSize = 0;
75 ptrAudioProcessInClientInner->spanSizeInFrame_ = 10;
76 ptrAudioProcessInClientInner->clientByteSizePerFrame_ = 0;
77 ptrAudioProcessInClientInner->SetPreferredFrameSize(frameSize);
78 }
79
80 /**
81 * @tc.name : Test AudioProcessInClientInner API
82 * @tc.type : FUNC
83 * @tc.number: AudioProcessInClientInner_002
84 * @tc.desc : Test AudioProcessInClientInner::SetPreferredFrameSize
85 */
86 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_002, TestSize.Level1)
87 {
88 AudioProcessConfig config = InitProcessConfig();
89 AudioService *g_audioServicePtr = AudioService::GetInstance();
90 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
91 bool isVoipMmap = true;
92 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
93
94 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
95
96 int32_t frameSize = 10;
97 ptrAudioProcessInClientInner->spanSizeInFrame_ = 1;
98 ptrAudioProcessInClientInner->clientByteSizePerFrame_ = 10;
99 ptrAudioProcessInClientInner->SetPreferredFrameSize(frameSize);
100 }
101
102 /**
103 * @tc.name : Test AudioProcessInClientInner API
104 * @tc.type : FUNC
105 * @tc.number: AudioProcessInClientInner_003
106 * @tc.desc : Test AudioProcessInClientInner::SetPreferredFrameSize
107 */
108 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_003, TestSize.Level1)
109 {
110 AudioProcessConfig config = InitProcessConfig();
111 AudioService *g_audioServicePtr = AudioService::GetInstance();
112 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
113 bool isVoipMmap = true;
114 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
115
116 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
117
118 int32_t frameSize = 10;
119 ptrAudioProcessInClientInner->spanSizeInFrame_ = 5;
120 ptrAudioProcessInClientInner->clientByteSizePerFrame_ = 10;
121 ptrAudioProcessInClientInner->SetPreferredFrameSize(frameSize);
122 }
123
124 /**
125 * @tc.name : Test AudioProcessInClientInner API
126 * @tc.type : FUNC
127 * @tc.number: AudioProcessInClientInner_004
128 * @tc.desc : Test static GetFormatSize
129 */
130 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_004, TestSize.Level1)
131 {
132 AudioStreamInfo info;
133 info.format = AudioSampleFormat::SAMPLE_U8;
134 info.channels = AudioChannel::MONO;
135 auto ret = GetFormatSize(info);
136
137 EXPECT_EQ(ret, NUMBER1);
138 }
139
140 /**
141 * @tc.name : Test AudioProcessInClientInner API
142 * @tc.type : FUNC
143 * @tc.number: AudioProcessInClientInner_005
144 * @tc.desc : Test static GetFormatSize
145 */
146 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_005, TestSize.Level1)
147 {
148 AudioStreamInfo info;
149 info.format = AudioSampleFormat::SAMPLE_S16LE;
150 info.channels = AudioChannel::STEREO;
151 auto ret = GetFormatSize(info);
152
153 EXPECT_EQ(ret, NUMBER4);
154 }
155
156 /**
157 * @tc.name : Test AudioProcessInClientInner API
158 * @tc.type : FUNC
159 * @tc.number: AudioProcessInClientInner_006
160 * @tc.desc : Test static GetFormatSize
161 */
162 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_006, TestSize.Level1)
163 {
164 AudioStreamInfo info;
165 info.format = AudioSampleFormat::SAMPLE_S24LE;
166 info.channels = AudioChannel::CHANNEL_3;
167 auto ret = GetFormatSize(info);
168
169 EXPECT_EQ(ret, NUMBER6);
170 }
171
172 /**
173 * @tc.name : Test AudioProcessInClientInner API
174 * @tc.type : FUNC
175 * @tc.number: AudioProcessInClientInner_007
176 * @tc.desc : Test static GetFormatSize
177 */
178 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_007, TestSize.Level1)
179 {
180 AudioStreamInfo info;
181 info.format = AudioSampleFormat::SAMPLE_S32LE;
182 info.channels = AudioChannel::MONO;
183 auto ret = GetFormatSize(info);
184
185 EXPECT_EQ(ret, NUMBER4);
186 }
187
188 /**
189 * @tc.name : Test AudioProcessInClientInner API
190 * @tc.type : FUNC
191 * @tc.number: AudioProcessInClientInner_008
192 * @tc.desc : Test static GetFormatSize
193 */
194 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_008, TestSize.Level1)
195 {
196 AudioStreamInfo info;
197 info.format = AudioSampleFormat::SAMPLE_F32LE;
198 info.channels = AudioChannel::MONO;
199 auto ret = GetFormatSize(info);
200
201 EXPECT_EQ(ret, NUMBER4);
202 }
203
204 /**
205 * @tc.name : Test AudioProcessInClientInner API
206 * @tc.type : FUNC
207 * @tc.number: AudioProcessInClientInner_009
208 * @tc.desc : Test inline S32MonoToS16Stereo
209 */
210 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_009, TestSize.Level1)
211 {
212 BufferDesc srcDesc;
213 BufferDesc dstDesc;
214 srcDesc.bufLength = 1;
215 dstDesc.bufLength = 2;
216 auto ret = S32MonoToS16Stereo(srcDesc, dstDesc);
217
218 EXPECT_EQ(ret, false);
219 }
220
221 /**
222 * @tc.name : Test AudioProcessInClientInner API
223 * @tc.type : FUNC
224 * @tc.number: AudioProcessInClientInner_010
225 * @tc.desc : Test inline S32MonoToS16Stereo
226 */
227 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_010, TestSize.Level1)
228 {
229 BufferDesc srcDesc;
230 BufferDesc dstDesc;
231 srcDesc.bufLength = 1;
232 dstDesc.bufLength = 1;
233 srcDesc.buffer = nullptr;
234 auto ret = S32MonoToS16Stereo(srcDesc, dstDesc);
235
236 EXPECT_EQ(ret, false);
237 }
238
239 /**
240 * @tc.name : Test AudioProcessInClientInner API
241 * @tc.type : FUNC
242 * @tc.number: AudioProcessInClientInner_011
243 * @tc.desc : Test inline S32MonoToS16Stereo
244 */
245 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_011, TestSize.Level1)
246 {
247 BufferDesc srcDesc;
248 BufferDesc dstDesc;
249 srcDesc.bufLength = 1;
250 dstDesc.bufLength = 1;
251 uint8_t buffer = 0;
252 srcDesc.buffer = &buffer;
253 dstDesc.buffer = nullptr;
254 auto ret = S32MonoToS16Stereo(srcDesc, dstDesc);
255
256 EXPECT_EQ(ret, false);
257 }
258
259 /**
260 * @tc.name : Test AudioProcessInClientInner API
261 * @tc.type : FUNC
262 * @tc.number: AudioProcessInClientInner_012
263 * @tc.desc : Test inline S32MonoToS16Stereo
264 */
265 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_012, TestSize.Level1)
266 {
267 BufferDesc srcDesc;
268 BufferDesc dstDesc;
269 srcDesc.bufLength = 1;
270 dstDesc.bufLength = 1;
271 uint8_t buffer = 0;
272 srcDesc.buffer = &buffer;
273 dstDesc.buffer = &buffer;
274 auto ret = S32MonoToS16Stereo(srcDesc, dstDesc);
275
276 EXPECT_EQ(ret, false);
277 }
278
279 /**
280 * @tc.name : Test AudioProcessInClientInner API
281 * @tc.type : FUNC
282 * @tc.number: AudioProcessInClientInner_013
283 * @tc.desc : Test inline S32MonoToS16Stereo
284 */
285 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_013, TestSize.Level1)
286 {
287 BufferDesc srcDesc;
288 BufferDesc dstDesc;
289 srcDesc.bufLength = 4;
290 dstDesc.bufLength = 1;
291 uint8_t buffer = 0;
292 srcDesc.buffer = &buffer;
293 dstDesc.buffer = &buffer;
294 auto ret = S32MonoToS16Stereo(srcDesc, dstDesc);
295
296 EXPECT_EQ(ret, false);
297 }
298
299 /**
300 * @tc.name : Test AudioProcessInClientInner API
301 * @tc.type : FUNC
302 * @tc.number: AudioProcessInClientInner_014
303 * @tc.desc : Test inline S32StereoS16Stereo
304 */
305 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_014, TestSize.Level1)
306 {
307 BufferDesc srcDesc;
308 BufferDesc dstDesc;
309 srcDesc.bufLength = 4;
310 dstDesc.bufLength = 1;
311 uint8_t buffer = 0;
312 srcDesc.buffer = &buffer;
313 dstDesc.buffer = &buffer;
314 auto ret = S32StereoS16Stereo(srcDesc, dstDesc);
315
316 EXPECT_EQ(ret, false);
317 }
318
319 /**
320 * @tc.name : Test AudioProcessInClientInner API
321 * @tc.type : FUNC
322 * @tc.number: AudioProcessInClientInner_015
323 * @tc.desc : Test inline S32StereoS16Stereo
324 */
325 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_015, TestSize.Level1)
326 {
327 BufferDesc srcDesc;
328 BufferDesc dstDesc;
329 srcDesc.bufLength = 4;
330 dstDesc.bufLength = 2;
331 srcDesc.buffer = nullptr;
332 auto ret = S32StereoS16Stereo(srcDesc, dstDesc);
333
334 EXPECT_EQ(ret, false);
335 }
336
337 /**
338 * @tc.name : Test AudioProcessInClientInner API
339 * @tc.type : FUNC
340 * @tc.number: AudioProcessInClientInner_016
341 * @tc.desc : Test inline S32StereoS16Stereo
342 */
343 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_016, TestSize.Level1)
344 {
345 BufferDesc srcDesc;
346 BufferDesc dstDesc;
347 srcDesc.bufLength = 4;
348 dstDesc.bufLength = 2;
349 uint8_t buffer = 0;
350 srcDesc.buffer = &buffer;
351 dstDesc.buffer = nullptr;
352 auto ret = S32StereoS16Stereo(srcDesc, dstDesc);
353
354 EXPECT_EQ(ret, false);
355 }
356
357 /**
358 * @tc.name : Test AudioProcessInClientInner API
359 * @tc.type : FUNC
360 * @tc.number: AudioProcessInClientInner_017
361 * @tc.desc : Test inline S32StereoS16Stereo
362 */
363 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_017, TestSize.Level1)
364 {
365 BufferDesc srcDesc;
366 BufferDesc dstDesc;
367 srcDesc.bufLength = 4;
368 dstDesc.bufLength = 2;
369 uint8_t buffer = 0;
370 srcDesc.buffer = &buffer;
371 dstDesc.buffer = &buffer;
372 auto ret = S32StereoS16Stereo(srcDesc, dstDesc);
373
374 EXPECT_EQ(ret, true);
375 }
376
377 /**
378 * @tc.name : Test AudioProcessInClientInner API
379 * @tc.type : FUNC
380 * @tc.number: AudioProcessInClientInner_018
381 * @tc.desc : Test inline S32StereoS16Stereo
382 */
383 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_018, TestSize.Level1)
384 {
385 BufferDesc srcDesc;
386 BufferDesc dstDesc;
387 srcDesc.bufLength = 6;
388 dstDesc.bufLength = 3;
389 uint8_t buffer = 0;
390 srcDesc.buffer = &buffer;
391 dstDesc.buffer = &buffer;
392 auto ret = S32StereoS16Stereo(srcDesc, dstDesc);
393
394 EXPECT_EQ(ret, false);
395 }
396
397 /**
398 * @tc.name : Test AudioProcessInClientInner API
399 * @tc.type : FUNC
400 * @tc.number: AudioProcessInClientInner_019
401 * @tc.desc : Test AudioProcessInClientInner::GetStatusInfo
402 */
403 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_019, TestSize.Level1)
404 {
405 AudioProcessConfig config = InitProcessConfig();
406 AudioService *g_audioServicePtr = AudioService::GetInstance();
407 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
408 bool isVoipMmap = true;
409 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
410
411 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
412
413 StreamStatus status = StreamStatus::STREAM_IDEL;
414 auto ret = ptrAudioProcessInClientInner->GetStatusInfo(status);
415 EXPECT_EQ(ret, "STREAM_IDEL");
416 }
417
418 /**
419 * @tc.name : Test AudioProcessInClientInner API
420 * @tc.type : FUNC
421 * @tc.number: AudioProcessInClientInner_020
422 * @tc.desc : Test AudioProcessInClientInner::GetStatusInfo
423 */
424 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_020, TestSize.Level1)
425 {
426 AudioProcessConfig config = InitProcessConfig();
427 AudioService *g_audioServicePtr = AudioService::GetInstance();
428 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
429 bool isVoipMmap = true;
430 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
431
432 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
433
434 StreamStatus status = StreamStatus::STREAM_STARTING;
435 auto ret = ptrAudioProcessInClientInner->GetStatusInfo(status);
436 EXPECT_EQ(ret, "STREAM_STARTING");
437 }
438
439 /**
440 * @tc.name : Test AudioProcessInClientInner API
441 * @tc.type : FUNC
442 * @tc.number: AudioProcessInClientInner_021
443 * @tc.desc : Test AudioProcessInClientInner::GetStatusInfo
444 */
445 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_021, TestSize.Level1)
446 {
447 AudioProcessConfig config = InitProcessConfig();
448 AudioService *g_audioServicePtr = AudioService::GetInstance();
449 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
450 bool isVoipMmap = true;
451 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
452
453 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
454
455 StreamStatus status = StreamStatus::STREAM_RUNNING;
456 auto ret = ptrAudioProcessInClientInner->GetStatusInfo(status);
457 EXPECT_EQ(ret, "STREAM_RUNNING");
458 }
459
460 /**
461 * @tc.name : Test AudioProcessInClientInner API
462 * @tc.type : FUNC
463 * @tc.number: AudioProcessInClientInner_022
464 * @tc.desc : Test AudioProcessInClientInner::GetStatusInfo
465 */
466 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_022, TestSize.Level1)
467 {
468 AudioProcessConfig config = InitProcessConfig();
469 AudioService *g_audioServicePtr = AudioService::GetInstance();
470 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
471 bool isVoipMmap = true;
472 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
473
474 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
475
476 StreamStatus status = StreamStatus::STREAM_PAUSING;
477 auto ret = ptrAudioProcessInClientInner->GetStatusInfo(status);
478 EXPECT_EQ(ret, "STREAM_PAUSING");
479 }
480
481 /**
482 * @tc.name : Test AudioProcessInClientInner API
483 * @tc.type : FUNC
484 * @tc.number: AudioProcessInClientInner_023
485 * @tc.desc : Test AudioProcessInClientInner::GetStatusInfo
486 */
487 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_023, TestSize.Level1)
488 {
489 AudioProcessConfig config = InitProcessConfig();
490 AudioService *g_audioServicePtr = AudioService::GetInstance();
491 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
492 bool isVoipMmap = true;
493 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
494
495 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
496
497 StreamStatus status = StreamStatus::STREAM_PAUSED;
498 auto ret = ptrAudioProcessInClientInner->GetStatusInfo(status);
499 EXPECT_EQ(ret, "STREAM_PAUSED");
500 }
501
502 /**
503 * @tc.name : Test AudioProcessInClientInner API
504 * @tc.type : FUNC
505 * @tc.number: AudioProcessInClientInner_024
506 * @tc.desc : Test AudioProcessInClientInner::GetStatusInfo
507 */
508 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_024, TestSize.Level1)
509 {
510 AudioProcessConfig config = InitProcessConfig();
511 AudioService *g_audioServicePtr = AudioService::GetInstance();
512 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
513 bool isVoipMmap = true;
514 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
515
516 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
517
518 StreamStatus status = StreamStatus::STREAM_STOPPING;
519 auto ret = ptrAudioProcessInClientInner->GetStatusInfo(status);
520 EXPECT_EQ(ret, "STREAM_STOPPING");
521 }
522
523 /**
524 * @tc.name : Test AudioProcessInClientInner API
525 * @tc.type : FUNC
526 * @tc.number: AudioProcessInClientInner_025
527 * @tc.desc : Test AudioProcessInClientInner::GetStatusInfo
528 */
529 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_025, TestSize.Level1)
530 {
531 AudioProcessConfig config = InitProcessConfig();
532 AudioService *g_audioServicePtr = AudioService::GetInstance();
533 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
534 bool isVoipMmap = true;
535 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
536
537 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
538
539 StreamStatus status = StreamStatus::STREAM_STOPPED;
540 auto ret = ptrAudioProcessInClientInner->GetStatusInfo(status);
541 EXPECT_EQ(ret, "STREAM_STOPPED");
542 }
543
544 /**
545 * @tc.name : Test AudioProcessInClientInner API
546 * @tc.type : FUNC
547 * @tc.number: AudioProcessInClientInner_026
548 * @tc.desc : Test AudioProcessInClientInner::GetStatusInfo
549 */
550 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_026, TestSize.Level1)
551 {
552 AudioProcessConfig config = InitProcessConfig();
553 AudioService *g_audioServicePtr = AudioService::GetInstance();
554 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
555 bool isVoipMmap = true;
556 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
557
558 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
559
560 StreamStatus status = StreamStatus::STREAM_RELEASED;
561 auto ret = ptrAudioProcessInClientInner->GetStatusInfo(status);
562 EXPECT_EQ(ret, "STREAM_RELEASED");
563 }
564
565 /**
566 * @tc.name : Test AudioProcessInClientInner API
567 * @tc.type : FUNC
568 * @tc.number: AudioProcessInClientInner_027
569 * @tc.desc : Test AudioProcessInClientInner::GetStatusInfo
570 */
571 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_027, TestSize.Level1)
572 {
573 AudioProcessConfig config = InitProcessConfig();
574 AudioService *g_audioServicePtr = AudioService::GetInstance();
575 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
576 bool isVoipMmap = true;
577 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
578
579 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
580
581 StreamStatus status = StreamStatus::STREAM_INVALID;
582 auto ret = ptrAudioProcessInClientInner->GetStatusInfo(status);
583 EXPECT_EQ(ret, "STREAM_INVALID");
584 }
585
586 /**
587 * @tc.name : Test AudioProcessInClientInner API
588 * @tc.type : FUNC
589 * @tc.number: AudioProcessInClientInner_028
590 * @tc.desc : Test AudioProcessInClientInner::GetStatusInfo
591 */
592 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_028, TestSize.Level1)
593 {
594 AudioProcessConfig config = InitProcessConfig();
595 AudioService *g_audioServicePtr = AudioService::GetInstance();
596 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
597 bool isVoipMmap = true;
598 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
599
600 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
601
602 StreamStatus status = StreamStatus::STREAM_STAND_BY;
603 auto ret = ptrAudioProcessInClientInner->GetStatusInfo(status);
604 EXPECT_EQ(ret, "NO_SUCH_STATUS");
605 }
606
607 /**
608 * @tc.name : Test AudioProcessInClientInner API
609 * @tc.type : FUNC
610 * @tc.number: AudioProcessInClientInner_029
611 * @tc.desc : Test AudioProcessInClientInner::KeepLoopRunning
612 */
613 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_029, TestSize.Level1)
614 {
615 AudioProcessConfig config = InitProcessConfig();
616 AudioService *g_audioServicePtr = AudioService::GetInstance();
617 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
618 bool isVoipMmap = true;
619 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
620
621 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
622
623 std::atomic<StreamStatus> streamStatus;
624 streamStatus.store(StreamStatus::STREAM_RUNNING);
625 ptrAudioProcessInClientInner->streamStatus_ = &streamStatus;
626 auto ret = ptrAudioProcessInClientInner->KeepLoopRunning();
627 EXPECT_EQ(ret, true);
628 }
629
630 /**
631 * @tc.name : Test AudioProcessInClientInner API
632 * @tc.type : FUNC
633 * @tc.number: AudioProcessInClientInner_030
634 * @tc.desc : Test AudioProcessInClientInner::KeepLoopRunning
635 */
636 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_030, TestSize.Level1)
637 {
638 AudioProcessConfig config = InitProcessConfig();
639 AudioService *g_audioServicePtr = AudioService::GetInstance();
640 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
641 bool isVoipMmap = true;
642 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
643
644 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
645
646 std::atomic<StreamStatus> streamStatus;
647 streamStatus.store(StreamStatus::STREAM_STAND_BY);
648 ptrAudioProcessInClientInner->streamStatus_ = &streamStatus;
649 auto ret = ptrAudioProcessInClientInner->KeepLoopRunning();
650 EXPECT_EQ(ret, true);
651 }
652
653 /**
654 * @tc.name : Test AudioProcessInClientInner API
655 * @tc.type : FUNC
656 * @tc.number: AudioProcessInClientInner_033
657 * @tc.desc : Test AudioProcessInClientInner::KeepLoopRunning
658 */
659 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_033, TestSize.Level1)
660 {
661 AudioProcessConfig config = InitProcessConfig();
662 AudioService *g_audioServicePtr = AudioService::GetInstance();
663 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
664 bool isVoipMmap = true;
665 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
666
667 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
668
669 std::atomic<StreamStatus> streamStatus;
670 streamStatus.store(StreamStatus::STREAM_PAUSING);
671 ptrAudioProcessInClientInner->streamStatus_ = &streamStatus;
672 ptrAudioProcessInClientInner->startFadeout_.store(true);
673 auto ret = ptrAudioProcessInClientInner->KeepLoopRunning();
674 EXPECT_EQ(ret, true);
675 }
676
677 /**
678 * @tc.name : Test AudioProcessInClientInner API
679 * @tc.type : FUNC
680 * @tc.number: AudioProcessInClientInner_035
681 * @tc.desc : Test AudioProcessInClientInner::KeepLoopRunning
682 */
683 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_035, TestSize.Level1)
684 {
685 AudioProcessConfig config = InitProcessConfig();
686 AudioService *g_audioServicePtr = AudioService::GetInstance();
687 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
688 bool isVoipMmap = true;
689 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
690
691 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
692
693 std::atomic<StreamStatus> streamStatus;
694 streamStatus.store(StreamStatus::STREAM_STOPPING);
695 ptrAudioProcessInClientInner->streamStatus_ = &streamStatus;
696 ptrAudioProcessInClientInner->startFadeout_.store(true);
697 auto ret = ptrAudioProcessInClientInner->KeepLoopRunning();
698 EXPECT_EQ(ret, true);
699 }
700
701 /**
702 * @tc.name : Test AudioProcessInClientInner API
703 * @tc.type : FUNC
704 * @tc.number: AudioProcessInClientInner_036
705 * @tc.desc : Test AudioProcessInClientInner::KeepLoopRunning
706 */
707 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_036, TestSize.Level1)
708 {
709 AudioProcessConfig config = InitProcessConfig();
710 AudioService *g_audioServicePtr = AudioService::GetInstance();
711 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
712 bool isVoipMmap = true;
713 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
714
715 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
716
717 std::atomic<StreamStatus> streamStatus;
718 streamStatus.store(StreamStatus::STREAM_STOPPED);
719 ptrAudioProcessInClientInner->streamStatus_ = &streamStatus;
720 ptrAudioProcessInClientInner->startFadeout_.store(true);
721 auto ret = ptrAudioProcessInClientInner->KeepLoopRunning();
722 EXPECT_EQ(ret, true);
723 }
724
725 /**
726 * @tc.name : Test AudioProcessInClientInner API
727 * @tc.type : FUNC
728 * @tc.number: AudioProcessInClientInner_038
729 * @tc.desc : Test AudioProcessInClientInner::DoFadeInOut
730 */
731 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_038, TestSize.Level1)
732 {
733 AudioProcessConfig config = InitProcessConfig();
734 AudioService *g_audioServicePtr = AudioService::GetInstance();
735 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
736 bool isVoipMmap = true;
737 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
738
739 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
740
741 uint64_t curWritePos = 0;
742 ptrAudioProcessInClientInner->startFadein_.store(true);
743 ptrAudioProcessInClientInner->startFadeout_.store(true);
744
745 ptrAudioProcessInClientInner->DoFadeInOut(curWritePos);
746 }
747
748 /**
749 * @tc.name : Test AudioProcessInClientInner API
750 * @tc.type : FUNC
751 * @tc.number: AudioProcessInClientInner_039
752 * @tc.desc : Test AudioProcessInClientInner::DoFadeInOut
753 */
754 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_039, TestSize.Level1)
755 {
756 AudioProcessConfig config = InitProcessConfig();
757 AudioService *g_audioServicePtr = AudioService::GetInstance();
758 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
759 bool isVoipMmap = true;
760 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
761
762 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
763
764 uint64_t curWritePos = 0;
765 ptrAudioProcessInClientInner->startFadein_.store(false);
766 ptrAudioProcessInClientInner->startFadeout_.store(true);
767
768 ptrAudioProcessInClientInner->DoFadeInOut(curWritePos);
769 }
770
771 /**
772 * @tc.name : Test AudioProcessInClientInner API
773 * @tc.type : FUNC
774 * @tc.number: AudioProcessInClientInner_040
775 * @tc.desc : Test AudioProcessInClientInner::DoFadeInOut
776 */
777 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_040, TestSize.Level1)
778 {
779 AudioProcessConfig config = InitProcessConfig();
780 AudioService *g_audioServicePtr = AudioService::GetInstance();
781 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
782 bool isVoipMmap = true;
783 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
784
785 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
786
787 uint64_t curWritePos = 0;
788 ptrAudioProcessInClientInner->startFadein_.store(false);
789 ptrAudioProcessInClientInner->startFadeout_.store(false);
790
791 ptrAudioProcessInClientInner->DoFadeInOut(curWritePos);
792 }
793
794 /**
795 * @tc.name : Test AudioProcessInClientInner API
796 * @tc.type : FUNC
797 * @tc.number: AudioProcessInClientInner_044
798 * @tc.desc : Test AudioProcessInClientInner::CheckIfWakeUpTooLate
799 */
800 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_044, TestSize.Level1)
801 {
802 AudioProcessConfig config = InitProcessConfig();
803 AudioService *g_audioServicePtr = AudioService::GetInstance();
804 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
805 bool isVoipMmap = true;
806 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
807
808 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
809
810 int64_t curTime = 1000100;
811 int64_t wakeUpTime = 0;
812
813 ptrAudioProcessInClientInner->CheckIfWakeUpTooLate(curTime, wakeUpTime);
814 }
815
816 /**
817 * @tc.name : Test AudioProcessInClientInner API
818 * @tc.type : FUNC
819 * @tc.number: AudioProcessInClientInner_045
820 * @tc.desc : Test AudioProcessInClientInner::CheckIfWakeUpTooLate
821 */
822 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_045, TestSize.Level1)
823 {
824 AudioProcessConfig config = InitProcessConfig();
825 AudioService *g_audioServicePtr = AudioService::GetInstance();
826 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
827 bool isVoipMmap = true;
828 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
829
830 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
831
832 int64_t curTime = 1000;
833 int64_t wakeUpTime = 0;
834
835 ptrAudioProcessInClientInner->CheckIfWakeUpTooLate(curTime, wakeUpTime);
836 }
837
838 /**
839 * @tc.name : Test AudioProcessInClientInner API
840 * @tc.type : FUNC
841 * @tc.number: AudioProcessInClientInner_046
842 * @tc.desc : Test AudioProcessInClientInner::CheckIfWakeUpTooLate
843 */
844 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_046, TestSize.Level1)
845 {
846 AudioProcessConfig config = InitProcessConfig();
847 AudioService *g_audioServicePtr = AudioService::GetInstance();
848 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
849 bool isVoipMmap = true;
850 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
851
852 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
853
854 int64_t curTime = 1000100;
855 int64_t wakeUpTime = 0;
856 int64_t clientWriteCost = 0;
857
858 ptrAudioProcessInClientInner->CheckIfWakeUpTooLate(curTime, wakeUpTime, clientWriteCost);
859 }
860
861 /**
862 * @tc.name : Test AudioProcessInClientInner API
863 * @tc.type : FUNC
864 * @tc.number: AudioProcessInClientInner_047
865 * @tc.desc : Test AudioProcessInClientInner::CheckIfWakeUpTooLate
866 */
867 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_047, TestSize.Level1)
868 {
869 AudioProcessConfig config = InitProcessConfig();
870 AudioService *g_audioServicePtr = AudioService::GetInstance();
871 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
872 bool isVoipMmap = true;
873 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
874
875 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
876
877 int64_t curTime = 100;
878 int64_t wakeUpTime = 0;
879 int64_t clientWriteCost = 1000100;
880
881 ptrAudioProcessInClientInner->CheckIfWakeUpTooLate(curTime, wakeUpTime, clientWriteCost);
882 }
883
884 /**
885 * @tc.name : Test AudioProcessInClientInner API
886 * @tc.type : FUNC
887 * @tc.number: AudioProcessInClientInner_048
888 * @tc.desc : Test CheckIfSupport
889 */
890 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_048, TestSize.Level1)
891 {
892 AudioProcessConfig config = InitProcessConfig();
893 AudioService *g_audioServicePtr = AudioService::GetInstance();
894 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
895 bool isVoipMmap = true;
896 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
897
898 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
899 std::atomic<StreamStatus> streamStatus;
900 streamStatus.store(StreamStatus::STREAM_RUNNING);
901 ptrAudioProcessInClientInner->streamStatus_ = &streamStatus;
902 EXPECT_EQ(true, ptrAudioProcessInClientInner->KeepLoopRunningIndependent());
903 }
904
905 /**
906 * @tc.name : Test AudioProcessInClientInner API
907 * @tc.type : FUNC
908 * @tc.number: AudioProcessInClientInner_049
909 * @tc.desc : Test CheckIfSupport
910 */
911 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_049, TestSize.Level1)
912 {
913 AudioProcessConfig config = InitProcessConfig();
914 AudioService *g_audioServicePtr = AudioService::GetInstance();
915 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
916 bool isVoipMmap = true;
917 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
918
919 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
920 std::atomic<StreamStatus> streamStatus;
921 streamStatus.store(StreamStatus::STREAM_IDEL);
922 ptrAudioProcessInClientInner->streamStatus_ = &streamStatus;
923 EXPECT_EQ(true, ptrAudioProcessInClientInner->KeepLoopRunningIndependent());
924 }
925
926 /**
927 * @tc.name : Test AudioProcessInClientInner API
928 * @tc.type : FUNC
929 * @tc.number: AudioProcessInClientInner_050
930 * @tc.desc : Test CheckIfSupport
931 */
932 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_050, TestSize.Level1)
933 {
934 AudioProcessConfig config = InitProcessConfig();
935 AudioService *g_audioServicePtr = AudioService::GetInstance();
936 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
937 bool isVoipMmap = true;
938 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
939
940 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
941 std::atomic<StreamStatus> streamStatus;
942 streamStatus.store(StreamStatus::STREAM_PAUSED);
943 ptrAudioProcessInClientInner->streamStatus_ = &streamStatus;
944 EXPECT_EQ(true, ptrAudioProcessInClientInner->KeepLoopRunningIndependent());
945 }
946
947 /**
948 * @tc.name : Test AudioProcessInClientInner API
949 * @tc.type : FUNC
950 * @tc.number: AudioProcessInClientInner_051
951 * @tc.desc : Test CheckIfSupport
952 */
953 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_051, TestSize.Level1)
954 {
955 AudioProcessConfig config = InitProcessConfig();
956 AudioService *g_audioServicePtr = AudioService::GetInstance();
957 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
958 bool isVoipMmap = true;
959 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
960
961 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
962 std::atomic<StreamStatus> streamStatus;
963 streamStatus.store(StreamStatus::STREAM_INVALID);
964 ptrAudioProcessInClientInner->streamStatus_ = &streamStatus;
965 EXPECT_EQ(false, ptrAudioProcessInClientInner->KeepLoopRunningIndependent());
966 }
967
968 /**
969 * @tc.name : Test AudioProcessInClientInner API
970 * @tc.type : FUNC
971 * @tc.number: AudioProcessInClientInner_052
972 * @tc.desc : Test inline S16MonoToS16Stereo
973 */
974 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_052, TestSize.Level1)
975 {
976 BufferDesc srcDesc;
977 BufferDesc dstDesc;
978 srcDesc.bufLength = 1;
979 dstDesc.bufLength = 2;
980 auto ret = S16MonoToS16Stereo(srcDesc, dstDesc);
981
982 EXPECT_EQ(ret, false);
983 }
984
985 /**
986 * @tc.name : Test AudioProcessInClientInner API
987 * @tc.type : FUNC
988 * @tc.number: AudioProcessInClientInner_053
989 * @tc.desc : Test inline S16MonoToS16Stereo
990 */
991 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_053, TestSize.Level1)
992 {
993 BufferDesc srcDesc;
994 BufferDesc dstDesc;
995 srcDesc.bufLength = 1;
996 dstDesc.bufLength = 1;
997 srcDesc.buffer = nullptr;
998 auto ret = S16MonoToS16Stereo(srcDesc, dstDesc);
999
1000 EXPECT_EQ(ret, false);
1001 }
1002
1003 /**
1004 * @tc.name : Test AudioProcessInClientInner API
1005 * @tc.type : FUNC
1006 * @tc.number: AudioProcessInClientInner_054
1007 * @tc.desc : Test inline S16MonoToS16Stereo
1008 */
1009 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_054, TestSize.Level1)
1010 {
1011 BufferDesc srcDesc;
1012 BufferDesc dstDesc;
1013 srcDesc.bufLength = 1;
1014 dstDesc.bufLength = 1;
1015 uint8_t buffer = 0;
1016 srcDesc.buffer = &buffer;
1017 dstDesc.buffer = nullptr;
1018 auto ret = S16MonoToS16Stereo(srcDesc, dstDesc);
1019
1020 EXPECT_EQ(ret, false);
1021 }
1022
1023 /**
1024 * @tc.name : Test AudioProcessInClientInner API
1025 * @tc.type : FUNC
1026 * @tc.number: AudioProcessInClientInner_055
1027 * @tc.desc : Test inline S16MonoToS16Stereo
1028 */
1029 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_055, TestSize.Level1)
1030 {
1031 BufferDesc srcDesc;
1032 BufferDesc dstDesc;
1033 srcDesc.bufLength = 1;
1034 dstDesc.bufLength = 1;
1035 uint8_t buffer = 0;
1036 srcDesc.buffer = &buffer;
1037 dstDesc.buffer = &buffer;
1038 auto ret = S16MonoToS16Stereo(srcDesc, dstDesc);
1039
1040 EXPECT_EQ(ret, false);
1041 }
1042
1043 /**
1044 * @tc.name : Test AudioProcessInClientInner API
1045 * @tc.type : FUNC
1046 * @tc.number: AudioProcessInClientInner_056
1047 * @tc.desc : Test inline S16MonoToS16Stereo
1048 */
1049 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_056, TestSize.Level1)
1050 {
1051 BufferDesc srcDesc;
1052 BufferDesc dstDesc;
1053 srcDesc.bufLength = 4;
1054 dstDesc.bufLength = 1;
1055 uint8_t buffer = 0;
1056 srcDesc.buffer = &buffer;
1057 dstDesc.buffer = &buffer;
1058 auto ret = S16MonoToS16Stereo(srcDesc, dstDesc);
1059
1060 EXPECT_EQ(ret, false);
1061 }
1062
1063 /**
1064 * @tc.name : Test AudioProcessInClientInner API
1065 * @tc.type : FUNC
1066 * @tc.number: AudioProcessInClientInner_057
1067 * @tc.desc : Test CheckIfSupport
1068 */
1069 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_057, TestSize.Level1)
1070 {
1071 AudioProcessConfig config = InitProcessConfig();
1072 AudioService *g_audioServicePtr = AudioService::GetInstance();
1073 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1074 bool isVoipMmap = true;
1075 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
1076
1077 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
1078 AudioProcessConfig audioProcConfig = {0};
1079 audioProcConfig.rendererInfo.streamUsage = STREAM_USAGE_VOICE_COMMUNICATION;
1080 EXPECT_EQ(true, ptrAudioProcessInClientInner->CheckIfSupport(audioProcConfig));
1081 }
1082
1083 /**
1084 * @tc.name : Test AudioProcessInClientInner API
1085 * @tc.type : FUNC
1086 * @tc.number: AudioProcessInClientInner_058
1087 * @tc.desc : Test CheckIfSupport
1088 */
1089 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_058, TestSize.Level1)
1090 {
1091 AudioProcessConfig config = InitProcessConfig();
1092 AudioService *g_audioServicePtr = AudioService::GetInstance();
1093 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1094 bool isVoipMmap = true;
1095 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
1096
1097 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
1098 AudioProcessConfig audioProcConfig = {0};
1099 audioProcConfig.capturerInfo.sourceType = SOURCE_TYPE_VOICE_COMMUNICATION;
1100 EXPECT_EQ(true, ptrAudioProcessInClientInner->CheckIfSupport(audioProcConfig));
1101 }
1102
1103 /**
1104 * @tc.name : Test AudioProcessInClientInner API
1105 * @tc.type : FUNC
1106 * @tc.number: AudioProcessInClientInner_059
1107 * @tc.desc : Test CheckIfSupport
1108 */
1109 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_059, TestSize.Level1)
1110 {
1111 AudioProcessConfig config = InitProcessConfig();
1112 AudioService *g_audioServicePtr = AudioService::GetInstance();
1113 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1114 bool isVoipMmap = true;
1115 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
1116
1117 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
1118 AudioProcessConfig audioProcConfig = {0};
1119 audioProcConfig.streamInfo.samplingRate = SAMPLE_RATE_8000;
1120 EXPECT_EQ(false, ptrAudioProcessInClientInner->CheckIfSupport(audioProcConfig));
1121 }
1122
1123 /**
1124 * @tc.name : Test AudioProcessInClientInner API
1125 * @tc.type : FUNC
1126 * @tc.number: AudioProcessInClientInner_060
1127 * @tc.desc : Test CheckIfSupport
1128 */
1129 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_060, TestSize.Level1)
1130 {
1131 AudioProcessConfig config = InitProcessConfig();
1132 AudioService *g_audioServicePtr = AudioService::GetInstance();
1133 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1134 bool isVoipMmap = true;
1135 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
1136
1137 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
1138 AudioProcessConfig audioProcConfig = {0};
1139 audioProcConfig.streamInfo.encoding = ENCODING_AUDIOVIVID;
1140 EXPECT_EQ(false, ptrAudioProcessInClientInner->CheckIfSupport(audioProcConfig));
1141 }
1142
1143 /**
1144 * @tc.name : Test AudioProcessInClientInner API
1145 * @tc.type : FUNC
1146 * @tc.number: AudioProcessInClientInner_061
1147 * @tc.desc : Test CheckIfSupport
1148 */
1149 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_061, TestSize.Level1)
1150 {
1151 AudioProcessConfig config = InitProcessConfig();
1152 AudioService *g_audioServicePtr = AudioService::GetInstance();
1153 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1154 bool isVoipMmap = true;
1155 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
1156
1157 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
1158 AudioProcessConfig audioProcConfig = {0};
1159 audioProcConfig.streamInfo.format = SAMPLE_S24LE;
1160 EXPECT_EQ(false, ptrAudioProcessInClientInner->CheckIfSupport(audioProcConfig));
1161 }
1162
1163 /**
1164 * @tc.name : Test AudioProcessInClientInner API
1165 * @tc.type : FUNC
1166 * @tc.number: AudioProcessInClientInner_062
1167 * @tc.desc : Test CheckIfSupport
1168 */
1169 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_062, TestSize.Level1)
1170 {
1171 AudioProcessConfig config = InitProcessConfig();
1172 AudioService *g_audioServicePtr = AudioService::GetInstance();
1173 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1174 bool isVoipMmap = true;
1175 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
1176
1177 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
1178 AudioProcessConfig audioProcConfig = {0};
1179 audioProcConfig.streamInfo.channels = CHANNEL_3;
1180 EXPECT_EQ(false, ptrAudioProcessInClientInner->CheckIfSupport(audioProcConfig));
1181 }
1182
1183 /**
1184 * @tc.name : Test AudioProcessInClientInner API
1185 * @tc.type : FUNC
1186 * @tc.number: AudioProcessInClientInner_063
1187 * @tc.desc : Test CheckIfSupport
1188 */
1189 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_063, TestSize.Level1)
1190 {
1191 AudioProcessConfig config = InitProcessConfig();
1192 AudioService *g_audioServicePtr = AudioService::GetInstance();
1193 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1194 bool isVoipMmap = true;
1195 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
1196
1197 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
1198 AudioProcessConfig audioProcConfig = {0};
1199 audioProcConfig.rendererInfo.streamUsage = STREAM_USAGE_MEDIA;
1200 audioProcConfig.capturerInfo.sourceType = SOURCE_TYPE_VOICE_CALL;
1201 audioProcConfig.streamInfo.samplingRate = SAMPLE_RATE_48000;
1202 audioProcConfig.streamInfo.encoding = ENCODING_PCM;
1203 audioProcConfig.streamInfo.format = SAMPLE_S16LE;
1204 audioProcConfig.streamInfo.channels = MONO;
1205 EXPECT_EQ(true, ptrAudioProcessInClientInner->CheckIfSupport(audioProcConfig));
1206 }
1207
1208 /**
1209 * @tc.name : Test AudioProcessInClientInner API
1210 * @tc.type : FUNC
1211 * @tc.number: AudioProcessInClientInner_064
1212 * @tc.desc : Test SetMute, SetDuckVolume, SetUnderflowCount, GetUnderflowCount, SetOverflowCount, GetOverflowCount
1213 */
1214 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_064, TestSize.Level1)
1215 {
1216 AudioProcessConfig config = InitProcessConfig();
1217 AudioService *g_audioServicePtr = AudioService::GetInstance();
1218 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1219 bool isVoipMmap = true;
1220 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
1221
1222 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
1223 int32_t ret = ptrAudioProcessInClientInner->SetMute(true);
1224 EXPECT_EQ(0, ret);
1225 ret = ptrAudioProcessInClientInner->SetDuckVolume(0.5f);
1226 EXPECT_EQ(0, ret);
1227 ptrAudioProcessInClientInner->underflowCount_ = 0;
1228 ptrAudioProcessInClientInner->SetUnderflowCount(1);
1229 uint32_t res = ptrAudioProcessInClientInner->GetUnderflowCount();
1230 EXPECT_EQ(1, res);
1231 ptrAudioProcessInClientInner->overflowCount_ = 0;
1232 ptrAudioProcessInClientInner->SetOverflowCount(1);
1233 res = ptrAudioProcessInClientInner->GetOverflowCount();
1234 EXPECT_EQ(1, res);
1235 }
1236
1237 /**
1238 * @tc.name : Test AudioProcessInClientInner API
1239 * @tc.type : FUNC
1240 * @tc.number: AudioProcessInClientInner_065
1241 * @tc.desc : Test GetFramesWritten, GetFramesRead, UpdateLatencyTimestamp
1242 */
1243 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_065, TestSize.Level1)
1244 {
1245 AudioProcessConfig config = InitProcessConfig();
1246 AudioService *g_audioServicePtr = AudioService::GetInstance();
1247 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1248 bool isVoipMmap = true;
1249 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
1250
1251 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
1252 ptrAudioProcessInClientInner->processConfig_.audioMode = AUDIO_MODE_PLAYBACK;
1253 int64_t res = 0;
1254 res = ptrAudioProcessInClientInner->GetFramesWritten();
1255 EXPECT_EQ(res, -1);
1256 ptrAudioProcessInClientInner->processConfig_.audioMode = AUDIO_MODE_RECORD;
1257 res = ptrAudioProcessInClientInner->GetFramesRead();
1258 EXPECT_EQ(res, -1);
1259 }
1260
1261 /**
1262 * @tc.name : Test AudioProcessInClientInner API
1263 * @tc.type : FUNC
1264 * @tc.number: AudioProcessInClientInner_066
1265 * @tc.desc : Test SaveUnderrunCallback
1266 */
1267 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_066, TestSize.Level1)
1268 {
1269 AudioProcessConfig config = InitProcessConfig();
1270 AudioService *g_audioServicePtr = AudioService::GetInstance();
1271 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1272 bool isVoipMmap = true;
1273 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
1274
1275 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
1276 std::shared_ptr<ClientUnderrunCallBack> underrunCallback = nullptr;
1277 ptrAudioProcessInClientInner->isInited_ = false;
1278 int32_t ret = ptrAudioProcessInClientInner->SaveUnderrunCallback(underrunCallback);
1279 EXPECT_EQ(ERR_ILLEGAL_STATE, ret);
1280 }
1281
1282 /**
1283 * @tc.name : Test AudioProcessInClientInner API
1284 * @tc.type : FUNC
1285 * @tc.number: AudioProcessInClientInner_067
1286 * @tc.desc : Test ChannelFormatConvert
1287 */
1288 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_067, TestSize.Level1)
1289 {
1290 AudioProcessConfig config = InitProcessConfig();
1291 AudioService *g_audioServicePtr = AudioService::GetInstance();
1292 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1293 bool isVoipMmap = true;
1294 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
1295
1296 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
1297 AudioStreamData srcData;
1298 AudioStreamData dstData;
1299 srcData.streamInfo.samplingRate = SAMPLE_RATE_16000;
1300 dstData.streamInfo.samplingRate = SAMPLE_RATE_48000;
1301 bool ret = ptrAudioProcessInClientInner->ChannelFormatConvert(srcData, dstData);
1302 EXPECT_EQ(false, ret);
1303 dstData.streamInfo.samplingRate = SAMPLE_RATE_16000;
1304 srcData.streamInfo.format = SAMPLE_S16LE;
1305 srcData.streamInfo.channels = STEREO;
1306 dstData.streamInfo.encoding = ENCODING_AUDIOVIVID;
1307 ret = ptrAudioProcessInClientInner->ChannelFormatConvert(srcData, dstData);
1308 EXPECT_EQ(false, ret);
1309 dstData.streamInfo.encoding = ENCODING_PCM;
1310 ret = ptrAudioProcessInClientInner->ChannelFormatConvert(srcData, dstData);
1311 EXPECT_EQ(true, ret);
1312 srcData.streamInfo.channels = MONO;
1313 ret = ptrAudioProcessInClientInner->ChannelFormatConvert(srcData, dstData);
1314 EXPECT_EQ(false, ret);
1315 srcData.streamInfo.channels = CHANNEL_3;
1316 ret = ptrAudioProcessInClientInner->ChannelFormatConvert(srcData, dstData);
1317 EXPECT_EQ(false, ret);
1318 srcData.streamInfo.format = SAMPLE_S32LE;
1319 srcData.streamInfo.channels = MONO;
1320 ret = ptrAudioProcessInClientInner->ChannelFormatConvert(srcData, dstData);
1321 EXPECT_EQ(false, ret);
1322 srcData.streamInfo.channels = CHANNEL_3;
1323 ret = ptrAudioProcessInClientInner->ChannelFormatConvert(srcData, dstData);
1324 EXPECT_EQ(false, ret);
1325 srcData.streamInfo.channels = STEREO;
1326 ret = ptrAudioProcessInClientInner->ChannelFormatConvert(srcData, dstData);
1327 EXPECT_EQ(false, ret);
1328 srcData.streamInfo.format = INVALID_WIDTH;
1329 ret = ptrAudioProcessInClientInner->ChannelFormatConvert(srcData, dstData);
1330 EXPECT_EQ(false, ret);
1331 srcData.streamInfo.format = SAMPLE_F32LE;
1332 srcData.streamInfo.channels = MONO;
1333 ret = ptrAudioProcessInClientInner->ChannelFormatConvert(srcData, dstData);
1334 EXPECT_EQ(true, ret);
1335 srcData.streamInfo.channels = STEREO;
1336 ret = ptrAudioProcessInClientInner->ChannelFormatConvert(srcData, dstData);
1337 EXPECT_EQ(true, ret);
1338 }
1339
1340 /**
1341 * @tc.name : Test AudioProcessInClientInner API
1342 * @tc.type : FUNC
1343 * @tc.number: AudioProcessInClientInner_068
1344 * @tc.desc : Test Pause, Resume
1345 */
1346 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_068, TestSize.Level1)
1347 {
1348 AudioProcessConfig config = InitProcessConfig();
1349 AudioService *g_audioServicePtr = AudioService::GetInstance();
1350 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1351 bool isVoipMmap = true;
1352 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
1353
1354 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
1355 int32_t ret = ptrAudioProcessInClientInner->Pause(true);
1356 EXPECT_EQ(ERR_ILLEGAL_STATE, ret);
1357 ret = ptrAudioProcessInClientInner->Pause(true);
1358 EXPECT_EQ(ERR_ILLEGAL_STATE, ret);
1359 ret = ptrAudioProcessInClientInner->Resume();
1360 EXPECT_EQ(ERR_ILLEGAL_STATE, ret);
1361 }
1362
1363 /**
1364 * @tc.name : Test AudioProcessInClientInner API
1365 * @tc.type : FUNC
1366 * @tc.number: AudioProcessInClientInner_069
1367 * @tc.desc : Test CheckIfSupport
1368 */
1369 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_069, TestSize.Level1)
1370 {
1371 AudioProcessConfig config = InitProcessConfig();
1372 AudioService *g_audioServicePtr = AudioService::GetInstance();
1373 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1374 bool isVoipMmap = true;
1375 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
1376
1377 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
1378 AudioProcessConfig audioProcConfig;
1379 audioProcConfig.rendererInfo.streamUsage = STREAM_USAGE_MEDIA;
1380 audioProcConfig.capturerInfo.sourceType = SOURCE_TYPE_VOICE_CALL;
1381 audioProcConfig.streamInfo.samplingRate = SAMPLE_RATE_48000;
1382 audioProcConfig.streamInfo.encoding = ENCODING_AUDIOVIVID;
1383 audioProcConfig.streamInfo.channels = MONO;
1384 EXPECT_EQ(false, ptrAudioProcessInClientInner->CheckIfSupport(audioProcConfig));
1385 audioProcConfig.streamInfo.encoding = ENCODING_PCM;
1386 audioProcConfig.streamInfo.format = SAMPLE_S24LE;
1387 EXPECT_EQ(false, ptrAudioProcessInClientInner->CheckIfSupport(audioProcConfig));
1388 audioProcConfig.streamInfo.format = SAMPLE_S32LE;
1389 EXPECT_EQ(true, ptrAudioProcessInClientInner->CheckIfSupport(audioProcConfig));
1390 }
1391
1392 /**
1393 * @tc.name : Test AudioProcessInClientInner API
1394 * @tc.type : FUNC
1395 * @tc.number: AudioProcessInClientInner_070
1396 * @tc.desc : Test CheckIfSupport
1397 */
1398 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_070, TestSize.Level1)
1399 {
1400 AudioProcessConfig config = InitProcessConfig();
1401 AudioService *g_audioServicePtr = AudioService::GetInstance();
1402 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1403 bool isVoipMmap = false;
1404 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap);
1405 auto ptrFastAudioStream = std::make_shared<FastAudioStream>(config.streamType,
1406 AUDIO_MODE_RECORD, config.appInfo.appUid);
1407 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
1408 bool ret = ptrAudioProcessInClientInner->Init(config, ptrFastAudioStream);
1409 EXPECT_EQ(ret, false);
1410 }
1411 } // namespace AudioStandard
1412 } // namespace OHOS