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 #include <gmock/gmock.h>
18
19 #include "audio_service_log.h"
20 #include "audio_service.h"
21 #include "audio_errors.h"
22 #include "audio_process_in_client.h"
23 #include "audio_process_in_client.cpp"
24 #include "fast_audio_stream.h"
25
26 using namespace testing::ext;
27 using namespace testing;
28
29 namespace OHOS {
30 namespace AudioStandard {
31 class MockIAudioProcess : public IAudioProcess {
32 public:
33 MOCK_METHOD(int32_t, ResolveBufferBaseAndGetServerSpanSize,
34 (std::shared_ptr<OHAudioBufferBase> buffer, uint32_t &spanSizeInFrame), (override));
35
36 MOCK_METHOD(int32_t, GetSessionId, (uint32_t &sessionId), (override));
37 MOCK_METHOD(int32_t, Start, (), (override));
38 MOCK_METHOD(int32_t, Pause, (bool isFlush), (override));
39 MOCK_METHOD(int32_t, Resume, (), (override));
40
41 MOCK_METHOD(int32_t, Stop, (int32_t stage), (override));
42
43 MOCK_METHOD(int32_t, RequestHandleInfo, (), (override));
44
45 MOCK_METHOD(int32_t, RequestHandleInfoAsync, (), (override));
46
47 MOCK_METHOD(int32_t, Release, (bool isSwitchStream), (override));
48
49 MOCK_METHOD(int32_t, RegisterProcessCb, (const &sptr<object>), (override));
50
51 MOCK_METHOD(int32_t, RegisterThreadPriority,
52 (int32_t tid, const std::string &bundleName, uint32_t method), (override));
53
54 MOCK_METHOD(int32_t, SetDefaultOutputDevice, (int32_t defaultOutputDevice, bool skipForce), (override));
55 MOCK_METHOD(int32_t, SetSilentModeAndMixWithOthers, (bool on), (override));
56 MOCK_METHOD(int32_t, SetSourceDuration, (int64_t duration), (override));
57 MOCK_METHOD(int32_t, SetUnderrunCount, (uint32_t underrunCnt), (override));
58
59 MOCK_METHOD(int32_t, SaveAdjustStreamVolumeInfo,
60 (float volume, uint32_t sessionId, const std::string &adjustTime, uint32_t code), (override));
61
62 MOCK_METHOD(int32_t, SetAudioHapticsSyncId, (int32_t audioHapticsSyncId), (override));
63
64 MOCK_METHOD(sptr<IRemoteObject>, AsObject, (), (override));
65 };
66
67 class AudioProcessInClientUnitTest : public testing::Test {
68 public:
69 static void SetUpTestCase(void);
70 static void TearDownTestCase(void);
71 void SetUp();
72 void TearDown();
73 };
74
75 constexpr int32_t DEFAULT_STREAM_ID = 10;
76 constexpr size_t NUMBER1 = 1;
77 constexpr size_t NUMBER2 = 2;
78 constexpr size_t NUMBER4 = 4;
79 constexpr size_t NUMBER6 = 6;
80 constexpr size_t NUMBER8 = 8;
81
InitProcessConfig()82 static AudioProcessConfig InitProcessConfig()
83 {
84 AudioProcessConfig config;
85 config.appInfo.appUid = DEFAULT_STREAM_ID;
86 config.appInfo.appPid = DEFAULT_STREAM_ID;
87 config.streamInfo.format = SAMPLE_S32LE;
88 config.streamInfo.samplingRate = SAMPLE_RATE_48000;
89 config.streamInfo.channels = STEREO;
90 config.streamInfo.channelLayout = AudioChannelLayout::CH_LAYOUT_STEREO;
91 config.audioMode = AudioMode::AUDIO_MODE_RECORD;
92 config.streamType = AudioStreamType::STREAM_MUSIC;
93 config.deviceType = DEVICE_TYPE_USB_HEADSET;
94 return config;
95 }
96
97 class ClientUnderrunCallBackTest : public ClientUnderrunCallBack {
98 virtual ~ClientUnderrunCallBackTest() = default;
99
100 /**
101 * Callback function when underrun occurs.
102 *
103 * @param posInFrames Indicates the postion when client handle underrun in frames.
104 */
OnUnderrun(size_t posInFrames)105 virtual void OnUnderrun(size_t posInFrames) {}
106 };
107
108 class AudioDataCallbackTest : public AudioDataCallback {
109 public:
110 virtual ~AudioDataCallbackTest() = default;
111
112 /**
113 * Called when request handle data.
114 *
115 * @param length Indicates requested buffer length.
116 */
OnHandleData(size_t length)117 virtual void OnHandleData(size_t length) {}
118 };
119
120 /**
121 * @tc.name : Test AudioProcessInClientInner API
122 * @tc.type : FUNC
123 * @tc.number: AudioProcessInClientInner_001
124 * @tc.desc : Test AudioProcessInClientInner::SetPreferredFrameSize
125 */
126 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_001, TestSize.Level1)
127 {
128 AudioProcessConfig config = InitProcessConfig();
129 AudioService *g_audioServicePtr = AudioService::GetInstance();
130 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
131 bool isVoipMmap = true;
132 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
133 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
134
135 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
136
137 int32_t frameSize = 0;
138 ptrAudioProcessInClientInner->spanSizeInFrame_ = 10;
139 ptrAudioProcessInClientInner->clientByteSizePerFrame_ = 0;
140 ptrAudioProcessInClientInner->SetPreferredFrameSize(frameSize);
141 }
142
143 /**
144 * @tc.name : Test AudioProcessInClientInner API
145 * @tc.type : FUNC
146 * @tc.number: AudioProcessInClientInner_002
147 * @tc.desc : Test AudioProcessInClientInner::SetPreferredFrameSize
148 */
149 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_002, TestSize.Level1)
150 {
151 AudioProcessConfig config = InitProcessConfig();
152 AudioService *g_audioServicePtr = AudioService::GetInstance();
153 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
154 bool isVoipMmap = true;
155 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
156 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
157
158 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
159
160 int32_t frameSize = 10;
161 ptrAudioProcessInClientInner->spanSizeInFrame_ = 1;
162 ptrAudioProcessInClientInner->clientByteSizePerFrame_ = 10;
163 ptrAudioProcessInClientInner->SetPreferredFrameSize(frameSize);
164 }
165
166 /**
167 * @tc.name : Test AudioProcessInClientInner API
168 * @tc.type : FUNC
169 * @tc.number: AudioProcessInClientInner_003
170 * @tc.desc : Test AudioProcessInClientInner::SetPreferredFrameSize
171 */
172 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_003, TestSize.Level1)
173 {
174 AudioProcessConfig config = InitProcessConfig();
175 AudioService *g_audioServicePtr = AudioService::GetInstance();
176 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
177 bool isVoipMmap = true;
178 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
179 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
180
181 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
182
183 int32_t frameSize = 10;
184 ptrAudioProcessInClientInner->spanSizeInFrame_ = 5;
185 ptrAudioProcessInClientInner->clientByteSizePerFrame_ = 10;
186 ptrAudioProcessInClientInner->SetPreferredFrameSize(frameSize);
187 }
188
189 /**
190 * @tc.name : Test AudioProcessInClientInner API
191 * @tc.type : FUNC
192 * @tc.number: AudioProcessInClientInner_004
193 * @tc.desc : Test static GetFormatSize
194 */
195 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_004, TestSize.Level1)
196 {
197 AudioStreamInfo info;
198 info.format = AudioSampleFormat::SAMPLE_U8;
199 info.channels = AudioChannel::MONO;
200 auto ret = GetFormatSize(info);
201
202 EXPECT_EQ(ret, NUMBER1);
203 }
204
205 /**
206 * @tc.name : Test AudioProcessInClientInner API
207 * @tc.type : FUNC
208 * @tc.number: AudioProcessInClientInner_005
209 * @tc.desc : Test static GetFormatSize
210 */
211 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_005, TestSize.Level1)
212 {
213 AudioStreamInfo info;
214 info.format = AudioSampleFormat::SAMPLE_S16LE;
215 info.channels = AudioChannel::STEREO;
216 auto ret = GetFormatSize(info);
217
218 EXPECT_EQ(ret, NUMBER4);
219 }
220
221 /**
222 * @tc.name : Test AudioProcessInClientInner API
223 * @tc.type : FUNC
224 * @tc.number: AudioProcessInClientInner_006
225 * @tc.desc : Test static GetFormatSize
226 */
227 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_006, TestSize.Level1)
228 {
229 AudioStreamInfo info;
230 info.format = AudioSampleFormat::SAMPLE_S24LE;
231 info.channels = AudioChannel::CHANNEL_3;
232 auto ret = GetFormatSize(info);
233
234 EXPECT_EQ(ret, NUMBER6);
235 }
236
237 /**
238 * @tc.name : Test AudioProcessInClientInner API
239 * @tc.type : FUNC
240 * @tc.number: AudioProcessInClientInner_007
241 * @tc.desc : Test static GetFormatSize
242 */
243 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_007, TestSize.Level1)
244 {
245 AudioStreamInfo info;
246 info.format = AudioSampleFormat::SAMPLE_S32LE;
247 info.channels = AudioChannel::MONO;
248 auto ret = GetFormatSize(info);
249
250 EXPECT_EQ(ret, NUMBER4);
251 }
252
253 /**
254 * @tc.name : Test AudioProcessInClientInner API
255 * @tc.type : FUNC
256 * @tc.number: AudioProcessInClientInner_008
257 * @tc.desc : Test static GetFormatSize
258 */
259 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_008, TestSize.Level1)
260 {
261 AudioStreamInfo info;
262 info.format = AudioSampleFormat::SAMPLE_F32LE;
263 info.channels = AudioChannel::MONO;
264 auto ret = GetFormatSize(info);
265
266 EXPECT_EQ(ret, NUMBER4);
267 }
268
269 /**
270 * @tc.name : Test AudioProcessInClientInner API
271 * @tc.type : FUNC
272 * @tc.number: AudioProcessInClientInner_009
273 * @tc.desc : Test inline S32MonoToS16Stereo
274 */
275 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_009, TestSize.Level1)
276 {
277 BufferDesc srcDesc;
278 BufferDesc dstDesc;
279 srcDesc.bufLength = 1;
280 dstDesc.bufLength = 2;
281 auto ret = FormatConverter::S32MonoToS16Stereo(srcDesc, dstDesc) == 0;
282
283 EXPECT_EQ(ret, false);
284 }
285
286 /**
287 * @tc.name : Test AudioProcessInClientInner API
288 * @tc.type : FUNC
289 * @tc.number: AudioProcessInClientInner_010
290 * @tc.desc : Test inline S32MonoToS16Stereo
291 */
292 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_010, TestSize.Level1)
293 {
294 BufferDesc srcDesc;
295 BufferDesc dstDesc;
296 srcDesc.bufLength = 1;
297 dstDesc.bufLength = 1;
298 srcDesc.buffer = nullptr;
299 auto ret = FormatConverter::S32MonoToS16Stereo(srcDesc, dstDesc) == 0;
300
301 EXPECT_EQ(ret, false);
302 }
303
304 /**
305 * @tc.name : Test AudioProcessInClientInner API
306 * @tc.type : FUNC
307 * @tc.number: AudioProcessInClientInner_011
308 * @tc.desc : Test inline S32MonoToS16Stereo
309 */
310 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_011, TestSize.Level1)
311 {
312 BufferDesc srcDesc;
313 BufferDesc dstDesc;
314 srcDesc.bufLength = 1;
315 dstDesc.bufLength = 1;
316 uint8_t buffer = 0;
317 srcDesc.buffer = &buffer;
318 dstDesc.buffer = nullptr;
319 auto ret = FormatConverter::S32MonoToS16Stereo(srcDesc, dstDesc) == 0;
320
321 EXPECT_EQ(ret, false);
322 }
323
324 /**
325 * @tc.name : Test AudioProcessInClientInner API
326 * @tc.type : FUNC
327 * @tc.number: AudioProcessInClientInner_012
328 * @tc.desc : Test inline S32MonoToS16Stereo
329 */
330 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_012, TestSize.Level1)
331 {
332 BufferDesc srcDesc;
333 BufferDesc dstDesc;
334 srcDesc.bufLength = 1;
335 dstDesc.bufLength = 1;
336 uint8_t buffer = 0;
337 srcDesc.buffer = &buffer;
338 dstDesc.buffer = &buffer;
339 auto ret = FormatConverter::S32MonoToS16Stereo(srcDesc, dstDesc) == 0;
340
341 EXPECT_EQ(ret, false);
342 }
343
344 /**
345 * @tc.name : Test AudioProcessInClientInner API
346 * @tc.type : FUNC
347 * @tc.number: AudioProcessInClientInner_013
348 * @tc.desc : Test inline S32MonoToS16Stereo
349 */
350 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_013, TestSize.Level1)
351 {
352 BufferDesc srcDesc;
353 BufferDesc dstDesc;
354 srcDesc.bufLength = 4;
355 dstDesc.bufLength = 1;
356 uint8_t buffer = 0;
357 srcDesc.buffer = &buffer;
358 dstDesc.buffer = &buffer;
359 auto ret = FormatConverter::S32MonoToS16Stereo(srcDesc, dstDesc) == 0;
360
361 EXPECT_EQ(ret, false);
362 }
363
364 /**
365 * @tc.name : Test AudioProcessInClientInner API
366 * @tc.type : FUNC
367 * @tc.number: AudioProcessInClientInner_014
368 * @tc.desc : Test inline S32StereoS16Stereo
369 */
370 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_014, TestSize.Level1)
371 {
372 BufferDesc srcDesc;
373 BufferDesc dstDesc;
374 srcDesc.bufLength = 4;
375 dstDesc.bufLength = 1;
376 uint8_t buffer = 0;
377 srcDesc.buffer = &buffer;
378 dstDesc.buffer = &buffer;
379 auto ret = FormatConverter::S32StereoToS16Stereo(srcDesc, dstDesc) == 0;
380
381 EXPECT_EQ(ret, false);
382 }
383
384 /**
385 * @tc.name : Test AudioProcessInClientInner API
386 * @tc.type : FUNC
387 * @tc.number: AudioProcessInClientInner_015
388 * @tc.desc : Test inline S32StereoS16Stereo
389 */
390 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_015, TestSize.Level1)
391 {
392 BufferDesc srcDesc;
393 BufferDesc dstDesc;
394 srcDesc.bufLength = 4;
395 dstDesc.bufLength = 2;
396 srcDesc.buffer = nullptr;
397 auto ret = FormatConverter::S32StereoToS16Stereo(srcDesc, dstDesc) == 0;
398
399 EXPECT_EQ(ret, false);
400 }
401
402 /**
403 * @tc.name : Test AudioProcessInClientInner API
404 * @tc.type : FUNC
405 * @tc.number: AudioProcessInClientInner_016
406 * @tc.desc : Test inline S32StereoS16Stereo
407 */
408 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_016, TestSize.Level1)
409 {
410 BufferDesc srcDesc;
411 BufferDesc dstDesc;
412 srcDesc.bufLength = 4;
413 dstDesc.bufLength = 2;
414 uint8_t buffer = 0;
415 srcDesc.buffer = &buffer;
416 dstDesc.buffer = nullptr;
417 auto ret = FormatConverter::S32StereoToS16Stereo(srcDesc, dstDesc) == 0;
418
419 EXPECT_EQ(ret, false);
420 }
421
422 /**
423 * @tc.name : Test AudioProcessInClientInner API
424 * @tc.type : FUNC
425 * @tc.number: AudioProcessInClientInner_017
426 * @tc.desc : Test inline S32StereoS16Stereo
427 */
428 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_017, TestSize.Level1)
429 {
430 BufferDesc srcDesc;
431 BufferDesc dstDesc;
432 srcDesc.bufLength = 4;
433 dstDesc.bufLength = 2;
434 uint8_t buffer = 0;
435 srcDesc.buffer = &buffer;
436 dstDesc.buffer = &buffer;
437 auto ret = FormatConverter::S32StereoToS16Stereo(srcDesc, dstDesc) == 0;
438
439 EXPECT_EQ(ret, true);
440 }
441
442 /**
443 * @tc.name : Test AudioProcessInClientInner API
444 * @tc.type : FUNC
445 * @tc.number: AudioProcessInClientInner_018
446 * @tc.desc : Test inline S32StereoS16Stereo
447 */
448 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_018, TestSize.Level1)
449 {
450 BufferDesc srcDesc;
451 BufferDesc dstDesc;
452 srcDesc.bufLength = 6;
453 dstDesc.bufLength = 3;
454 uint8_t buffer = 0;
455 srcDesc.buffer = &buffer;
456 dstDesc.buffer = &buffer;
457 auto ret = FormatConverter::S32StereoToS16Stereo(srcDesc, dstDesc) == 0;
458
459 EXPECT_EQ(ret, false);
460 }
461
462 /**
463 * @tc.name : Test AudioProcessInClientInner API
464 * @tc.type : FUNC
465 * @tc.number: AudioProcessInClientInner_019
466 * @tc.desc : Test AudioProcessInClientInner::GetStatusInfo
467 */
468 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_019, TestSize.Level1)
469 {
470 AudioProcessConfig config = InitProcessConfig();
471 AudioService *g_audioServicePtr = AudioService::GetInstance();
472 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
473 bool isVoipMmap = true;
474 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
475 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
476
477 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
478
479 StreamStatus status = StreamStatus::STREAM_IDEL;
480 auto ret = ptrAudioProcessInClientInner->GetStatusInfo(status);
481 EXPECT_EQ(ret, "STREAM_IDEL");
482 }
483
484 /**
485 * @tc.name : Test AudioProcessInClientInner API
486 * @tc.type : FUNC
487 * @tc.number: AudioProcessInClientInner_020
488 * @tc.desc : Test AudioProcessInClientInner::GetStatusInfo
489 */
490 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_020, TestSize.Level1)
491 {
492 AudioProcessConfig config = InitProcessConfig();
493 AudioService *g_audioServicePtr = AudioService::GetInstance();
494 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
495 bool isVoipMmap = true;
496 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
497 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
498
499 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
500
501 StreamStatus status = StreamStatus::STREAM_STARTING;
502 auto ret = ptrAudioProcessInClientInner->GetStatusInfo(status);
503 EXPECT_EQ(ret, "STREAM_STARTING");
504 }
505
506 /**
507 * @tc.name : Test AudioProcessInClientInner API
508 * @tc.type : FUNC
509 * @tc.number: AudioProcessInClientInner_021
510 * @tc.desc : Test AudioProcessInClientInner::GetStatusInfo
511 */
512 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_021, TestSize.Level1)
513 {
514 AudioProcessConfig config = InitProcessConfig();
515 AudioService *g_audioServicePtr = AudioService::GetInstance();
516 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
517 bool isVoipMmap = true;
518 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
519 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
520
521 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
522
523 StreamStatus status = StreamStatus::STREAM_RUNNING;
524 auto ret = ptrAudioProcessInClientInner->GetStatusInfo(status);
525 EXPECT_EQ(ret, "STREAM_RUNNING");
526 }
527
528 /**
529 * @tc.name : Test AudioProcessInClientInner API
530 * @tc.type : FUNC
531 * @tc.number: AudioProcessInClientInner_022
532 * @tc.desc : Test AudioProcessInClientInner::GetStatusInfo
533 */
534 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_022, TestSize.Level1)
535 {
536 AudioProcessConfig config = InitProcessConfig();
537 AudioService *g_audioServicePtr = AudioService::GetInstance();
538 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
539 bool isVoipMmap = true;
540 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
541 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
542
543 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
544
545 StreamStatus status = StreamStatus::STREAM_PAUSING;
546 auto ret = ptrAudioProcessInClientInner->GetStatusInfo(status);
547 EXPECT_EQ(ret, "STREAM_PAUSING");
548 }
549
550 /**
551 * @tc.name : Test AudioProcessInClientInner API
552 * @tc.type : FUNC
553 * @tc.number: AudioProcessInClientInner_023
554 * @tc.desc : Test AudioProcessInClientInner::GetStatusInfo
555 */
556 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_023, TestSize.Level1)
557 {
558 AudioProcessConfig config = InitProcessConfig();
559 AudioService *g_audioServicePtr = AudioService::GetInstance();
560 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
561 bool isVoipMmap = true;
562 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
563 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
564
565 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
566
567 StreamStatus status = StreamStatus::STREAM_PAUSED;
568 auto ret = ptrAudioProcessInClientInner->GetStatusInfo(status);
569 EXPECT_EQ(ret, "STREAM_PAUSED");
570 }
571
572 /**
573 * @tc.name : Test AudioProcessInClientInner API
574 * @tc.type : FUNC
575 * @tc.number: AudioProcessInClientInner_024
576 * @tc.desc : Test AudioProcessInClientInner::GetStatusInfo
577 */
578 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_024, TestSize.Level1)
579 {
580 AudioProcessConfig config = InitProcessConfig();
581 AudioService *g_audioServicePtr = AudioService::GetInstance();
582 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
583 bool isVoipMmap = true;
584 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
585 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
586
587 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
588
589 StreamStatus status = StreamStatus::STREAM_STOPPING;
590 auto ret = ptrAudioProcessInClientInner->GetStatusInfo(status);
591 EXPECT_EQ(ret, "STREAM_STOPPING");
592 }
593
594 /**
595 * @tc.name : Test AudioProcessInClientInner API
596 * @tc.type : FUNC
597 * @tc.number: AudioProcessInClientInner_025
598 * @tc.desc : Test AudioProcessInClientInner::GetStatusInfo
599 */
600 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_025, TestSize.Level1)
601 {
602 AudioProcessConfig config = InitProcessConfig();
603 AudioService *g_audioServicePtr = AudioService::GetInstance();
604 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
605 bool isVoipMmap = true;
606 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
607 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
608
609 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
610
611 StreamStatus status = StreamStatus::STREAM_STOPPED;
612 auto ret = ptrAudioProcessInClientInner->GetStatusInfo(status);
613 EXPECT_EQ(ret, "STREAM_STOPPED");
614 }
615
616 /**
617 * @tc.name : Test AudioProcessInClientInner API
618 * @tc.type : FUNC
619 * @tc.number: AudioProcessInClientInner_026
620 * @tc.desc : Test AudioProcessInClientInner::GetStatusInfo
621 */
622 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_026, TestSize.Level1)
623 {
624 AudioProcessConfig config = InitProcessConfig();
625 AudioService *g_audioServicePtr = AudioService::GetInstance();
626 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
627 bool isVoipMmap = true;
628 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
629 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
630
631 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
632
633 StreamStatus status = StreamStatus::STREAM_RELEASED;
634 auto ret = ptrAudioProcessInClientInner->GetStatusInfo(status);
635 EXPECT_EQ(ret, "STREAM_RELEASED");
636 }
637
638 /**
639 * @tc.name : Test AudioProcessInClientInner API
640 * @tc.type : FUNC
641 * @tc.number: AudioProcessInClientInner_027
642 * @tc.desc : Test AudioProcessInClientInner::GetStatusInfo
643 */
644 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_027, TestSize.Level1)
645 {
646 AudioProcessConfig config = InitProcessConfig();
647 AudioService *g_audioServicePtr = AudioService::GetInstance();
648 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
649 bool isVoipMmap = true;
650 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
651 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
652
653 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
654
655 StreamStatus status = StreamStatus::STREAM_INVALID;
656 auto ret = ptrAudioProcessInClientInner->GetStatusInfo(status);
657 EXPECT_EQ(ret, "STREAM_INVALID");
658 }
659
660 /**
661 * @tc.name : Test AudioProcessInClientInner API
662 * @tc.type : FUNC
663 * @tc.number: AudioProcessInClientInner_028
664 * @tc.desc : Test AudioProcessInClientInner::GetStatusInfo
665 */
666 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_028, TestSize.Level1)
667 {
668 AudioProcessConfig config = InitProcessConfig();
669 AudioService *g_audioServicePtr = AudioService::GetInstance();
670 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
671 bool isVoipMmap = true;
672 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
673 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
674
675 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
676
677 StreamStatus status = StreamStatus::STREAM_STAND_BY;
678 auto ret = ptrAudioProcessInClientInner->GetStatusInfo(status);
679 EXPECT_EQ(ret, "NO_SUCH_STATUS");
680 }
681
682 /**
683 * @tc.name : Test AudioProcessInClientInner API
684 * @tc.type : FUNC
685 * @tc.number: AudioProcessInClientInner_029
686 * @tc.desc : Test AudioProcessInClientInner::KeepLoopRunning
687 */
688 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_029, TestSize.Level1)
689 {
690 AudioProcessConfig config = InitProcessConfig();
691 AudioService *g_audioServicePtr = AudioService::GetInstance();
692 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
693 bool isVoipMmap = true;
694 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
695 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
696
697 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
698
699 std::atomic<StreamStatus> streamStatus;
700 streamStatus.store(StreamStatus::STREAM_RUNNING);
701 ptrAudioProcessInClientInner->streamStatus_ = &streamStatus;
702 auto ret = ptrAudioProcessInClientInner->KeepLoopRunning();
703 EXPECT_EQ(ret, true);
704 }
705
706 /**
707 * @tc.name : Test AudioProcessInClientInner API
708 * @tc.type : FUNC
709 * @tc.number: AudioProcessInClientInner_030
710 * @tc.desc : Test AudioProcessInClientInner::KeepLoopRunning
711 */
712 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_030, TestSize.Level1)
713 {
714 AudioProcessConfig config = InitProcessConfig();
715 AudioService *g_audioServicePtr = AudioService::GetInstance();
716 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
717 bool isVoipMmap = true;
718 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
719 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
720
721 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
722
723 std::atomic<StreamStatus> streamStatus;
724 streamStatus.store(StreamStatus::STREAM_STAND_BY);
725 ptrAudioProcessInClientInner->streamStatus_ = &streamStatus;
726 auto ret = ptrAudioProcessInClientInner->KeepLoopRunning();
727 EXPECT_EQ(ret, true);
728 }
729
730 /**
731 * @tc.name : Test AudioProcessInClientInner API
732 * @tc.type : FUNC
733 * @tc.number: AudioProcessInClientInner_033
734 * @tc.desc : Test AudioProcessInClientInner::KeepLoopRunning
735 */
736 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_033, TestSize.Level1)
737 {
738 AudioProcessConfig config = InitProcessConfig();
739 AudioService *g_audioServicePtr = AudioService::GetInstance();
740 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
741 bool isVoipMmap = true;
742 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
743 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
744
745 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
746
747 std::atomic<StreamStatus> streamStatus;
748 streamStatus.store(StreamStatus::STREAM_PAUSING);
749 ptrAudioProcessInClientInner->streamStatus_ = &streamStatus;
750 ptrAudioProcessInClientInner->startFadeout_.store(true);
751 auto ret = ptrAudioProcessInClientInner->KeepLoopRunning();
752 EXPECT_EQ(ret, true);
753 }
754
755 /**
756 * @tc.name : Test AudioProcessInClientInner API
757 * @tc.type : FUNC
758 * @tc.number: AudioProcessInClientInner_035
759 * @tc.desc : Test AudioProcessInClientInner::KeepLoopRunning
760 */
761 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_035, TestSize.Level1)
762 {
763 AudioProcessConfig config = InitProcessConfig();
764 AudioService *g_audioServicePtr = AudioService::GetInstance();
765 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
766 bool isVoipMmap = true;
767 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
768 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
769
770 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
771
772 std::atomic<StreamStatus> streamStatus;
773 streamStatus.store(StreamStatus::STREAM_STOPPING);
774 ptrAudioProcessInClientInner->streamStatus_ = &streamStatus;
775 ptrAudioProcessInClientInner->startFadeout_.store(true);
776 auto ret = ptrAudioProcessInClientInner->KeepLoopRunning();
777 EXPECT_EQ(ret, true);
778 }
779
780 /**
781 * @tc.name : Test AudioProcessInClientInner API
782 * @tc.type : FUNC
783 * @tc.number: AudioProcessInClientInner_036
784 * @tc.desc : Test AudioProcessInClientInner::KeepLoopRunning
785 */
786 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_036, TestSize.Level1)
787 {
788 AudioProcessConfig config = InitProcessConfig();
789 AudioService *g_audioServicePtr = AudioService::GetInstance();
790 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
791 bool isVoipMmap = true;
792 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
793 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
794
795 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
796
797 std::atomic<StreamStatus> streamStatus;
798 streamStatus.store(StreamStatus::STREAM_STOPPED);
799 ptrAudioProcessInClientInner->streamStatus_ = &streamStatus;
800 ptrAudioProcessInClientInner->startFadeout_.store(true);
801 auto ret = ptrAudioProcessInClientInner->KeepLoopRunning();
802 EXPECT_EQ(ret, true);
803 }
804
805 /**
806 * @tc.name : Test AudioProcessInClientInner API
807 * @tc.type : FUNC
808 * @tc.number: AudioProcessInClientInner_038
809 * @tc.desc : Test AudioProcessInClientInner::DoFadeInOut
810 */
811 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_038, TestSize.Level1)
812 {
813 AudioProcessConfig config = InitProcessConfig();
814 AudioService *g_audioServicePtr = AudioService::GetInstance();
815 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
816 bool isVoipMmap = true;
817 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
818 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
819
820 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
821
822 uint64_t curWritePos = 0;
823 ptrAudioProcessInClientInner->startFadein_.store(true);
824 ptrAudioProcessInClientInner->startFadeout_.store(true);
825
826 ptrAudioProcessInClientInner->DoFadeInOut(curWritePos);
827 }
828
829 /**
830 * @tc.name : Test AudioProcessInClientInner API
831 * @tc.type : FUNC
832 * @tc.number: AudioProcessInClientInner_039
833 * @tc.desc : Test AudioProcessInClientInner::DoFadeInOut
834 */
835 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_039, TestSize.Level1)
836 {
837 AudioProcessConfig config = InitProcessConfig();
838 AudioService *g_audioServicePtr = AudioService::GetInstance();
839 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
840 bool isVoipMmap = true;
841 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
842 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
843
844 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
845
846 uint64_t curWritePos = 0;
847 ptrAudioProcessInClientInner->startFadein_.store(false);
848 ptrAudioProcessInClientInner->startFadeout_.store(true);
849
850 ptrAudioProcessInClientInner->DoFadeInOut(curWritePos);
851 }
852
853 /**
854 * @tc.name : Test AudioProcessInClientInner API
855 * @tc.type : FUNC
856 * @tc.number: AudioProcessInClientInner_040
857 * @tc.desc : Test AudioProcessInClientInner::DoFadeInOut
858 */
859 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_040, TestSize.Level1)
860 {
861 AudioProcessConfig config = InitProcessConfig();
862 AudioService *g_audioServicePtr = AudioService::GetInstance();
863 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
864 bool isVoipMmap = true;
865 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
866 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
867
868 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
869
870 uint64_t curWritePos = 0;
871 ptrAudioProcessInClientInner->startFadein_.store(false);
872 ptrAudioProcessInClientInner->startFadeout_.store(false);
873
874 ptrAudioProcessInClientInner->DoFadeInOut(curWritePos);
875 }
876
877 /**
878 * @tc.name : Test AudioProcessInClientInner API
879 * @tc.type : FUNC
880 * @tc.number: AudioProcessInClientInner_044
881 * @tc.desc : Test AudioProcessInClientInner::CheckIfWakeUpTooLate
882 */
883 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_044, TestSize.Level1)
884 {
885 AudioProcessConfig config = InitProcessConfig();
886 AudioService *g_audioServicePtr = AudioService::GetInstance();
887 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
888 bool isVoipMmap = true;
889 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
890 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
891
892 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
893
894 int64_t curTime = 1000100;
895 int64_t wakeUpTime = 0;
896
897 ptrAudioProcessInClientInner->CheckIfWakeUpTooLate(curTime, wakeUpTime);
898 }
899
900 /**
901 * @tc.name : Test AudioProcessInClientInner API
902 * @tc.type : FUNC
903 * @tc.number: AudioProcessInClientInner_045
904 * @tc.desc : Test AudioProcessInClientInner::CheckIfWakeUpTooLate
905 */
906 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_045, TestSize.Level1)
907 {
908 AudioProcessConfig config = InitProcessConfig();
909 AudioService *g_audioServicePtr = AudioService::GetInstance();
910 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
911 bool isVoipMmap = true;
912 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
913 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
914
915 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
916
917 int64_t curTime = 1000;
918 int64_t wakeUpTime = 0;
919
920 ptrAudioProcessInClientInner->CheckIfWakeUpTooLate(curTime, wakeUpTime);
921 }
922
923 /**
924 * @tc.name : Test AudioProcessInClientInner API
925 * @tc.type : FUNC
926 * @tc.number: AudioProcessInClientInner_046
927 * @tc.desc : Test AudioProcessInClientInner::CheckIfWakeUpTooLate
928 */
929 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_046, TestSize.Level1)
930 {
931 AudioProcessConfig config = InitProcessConfig();
932 AudioService *g_audioServicePtr = AudioService::GetInstance();
933 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
934 bool isVoipMmap = true;
935 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
936 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
937
938 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
939
940 int64_t curTime = 1000100;
941 int64_t wakeUpTime = 0;
942 int64_t clientWriteCost = 0;
943
944 ptrAudioProcessInClientInner->CheckIfWakeUpTooLate(curTime, wakeUpTime, clientWriteCost);
945 }
946
947 /**
948 * @tc.name : Test AudioProcessInClientInner API
949 * @tc.type : FUNC
950 * @tc.number: AudioProcessInClientInner_047
951 * @tc.desc : Test AudioProcessInClientInner::CheckIfWakeUpTooLate
952 */
953 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_047, 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 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
960 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
961
962 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
963
964 int64_t curTime = 100;
965 int64_t wakeUpTime = 0;
966 int64_t clientWriteCost = 1000100;
967
968 ptrAudioProcessInClientInner->CheckIfWakeUpTooLate(curTime, wakeUpTime, clientWriteCost);
969 }
970
971 /**
972 * @tc.name : Test AudioProcessInClientInner API
973 * @tc.type : FUNC
974 * @tc.number: AudioProcessInClientInner_048
975 * @tc.desc : Test CheckIfSupport
976 */
977 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_048, TestSize.Level1)
978 {
979 AudioProcessConfig config = InitProcessConfig();
980 AudioService *g_audioServicePtr = AudioService::GetInstance();
981 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
982 bool isVoipMmap = true;
983 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
984 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
985
986 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
987 std::atomic<StreamStatus> streamStatus;
988 streamStatus.store(StreamStatus::STREAM_RUNNING);
989 ptrAudioProcessInClientInner->streamStatus_ = &streamStatus;
990 EXPECT_EQ(true, ptrAudioProcessInClientInner->KeepLoopRunningIndependent());
991 }
992
993 /**
994 * @tc.name : Test AudioProcessInClientInner API
995 * @tc.type : FUNC
996 * @tc.number: AudioProcessInClientInner_049
997 * @tc.desc : Test CheckIfSupport
998 */
999 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_049, TestSize.Level1)
1000 {
1001 AudioProcessConfig config = InitProcessConfig();
1002 AudioService *g_audioServicePtr = AudioService::GetInstance();
1003 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1004 bool isVoipMmap = true;
1005 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
1006 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
1007
1008 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
1009 std::atomic<StreamStatus> streamStatus;
1010 streamStatus.store(StreamStatus::STREAM_IDEL);
1011 ptrAudioProcessInClientInner->streamStatus_ = &streamStatus;
1012 EXPECT_EQ(true, ptrAudioProcessInClientInner->KeepLoopRunningIndependent());
1013 }
1014
1015 /**
1016 * @tc.name : Test AudioProcessInClientInner API
1017 * @tc.type : FUNC
1018 * @tc.number: AudioProcessInClientInner_050
1019 * @tc.desc : Test CheckIfSupport
1020 */
1021 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_050, TestSize.Level1)
1022 {
1023 AudioProcessConfig config = InitProcessConfig();
1024 AudioService *g_audioServicePtr = AudioService::GetInstance();
1025 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1026 bool isVoipMmap = true;
1027 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
1028 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
1029
1030 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
1031 std::atomic<StreamStatus> streamStatus;
1032 streamStatus.store(StreamStatus::STREAM_PAUSED);
1033 ptrAudioProcessInClientInner->streamStatus_ = &streamStatus;
1034 EXPECT_EQ(true, ptrAudioProcessInClientInner->KeepLoopRunningIndependent());
1035 }
1036
1037 /**
1038 * @tc.name : Test AudioProcessInClientInner API
1039 * @tc.type : FUNC
1040 * @tc.number: AudioProcessInClientInner_051
1041 * @tc.desc : Test CheckIfSupport
1042 */
1043 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_051, TestSize.Level1)
1044 {
1045 AudioProcessConfig config = InitProcessConfig();
1046 AudioService *g_audioServicePtr = AudioService::GetInstance();
1047 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1048 bool isVoipMmap = true;
1049 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
1050 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
1051
1052 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
1053 std::atomic<StreamStatus> streamStatus;
1054 streamStatus.store(StreamStatus::STREAM_INVALID);
1055 ptrAudioProcessInClientInner->streamStatus_ = &streamStatus;
1056 EXPECT_EQ(false, ptrAudioProcessInClientInner->KeepLoopRunningIndependent());
1057 }
1058
1059 /**
1060 * @tc.name : Test AudioProcessInClientInner API
1061 * @tc.type : FUNC
1062 * @tc.number: AudioProcessInClientInner_052
1063 * @tc.desc : Test inline S16MonoToS16Stereo
1064 */
1065 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_052, TestSize.Level1)
1066 {
1067 BufferDesc srcDesc;
1068 BufferDesc dstDesc;
1069 srcDesc.bufLength = 1;
1070 dstDesc.bufLength = 2;
1071 auto ret = FormatConverter::S16MonoToS16Stereo(srcDesc, dstDesc) == 0;
1072
1073 EXPECT_EQ(ret, false);
1074 }
1075
1076 /**
1077 * @tc.name : Test AudioProcessInClientInner API
1078 * @tc.type : FUNC
1079 * @tc.number: AudioProcessInClientInner_053
1080 * @tc.desc : Test inline S16MonoToS16Stereo
1081 */
1082 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_053, TestSize.Level1)
1083 {
1084 BufferDesc srcDesc;
1085 BufferDesc dstDesc;
1086 srcDesc.bufLength = 1;
1087 dstDesc.bufLength = 1;
1088 srcDesc.buffer = nullptr;
1089 auto ret = FormatConverter::S16MonoToS16Stereo(srcDesc, dstDesc) == 0;
1090
1091 EXPECT_EQ(ret, false);
1092 }
1093
1094 /**
1095 * @tc.name : Test AudioProcessInClientInner API
1096 * @tc.type : FUNC
1097 * @tc.number: AudioProcessInClientInner_054
1098 * @tc.desc : Test inline S16MonoToS16Stereo
1099 */
1100 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_054, TestSize.Level1)
1101 {
1102 BufferDesc srcDesc;
1103 BufferDesc dstDesc;
1104 srcDesc.bufLength = 1;
1105 dstDesc.bufLength = 1;
1106 uint8_t buffer = 0;
1107 srcDesc.buffer = &buffer;
1108 dstDesc.buffer = nullptr;
1109 auto ret = FormatConverter::S16MonoToS16Stereo(srcDesc, dstDesc) == 0;
1110
1111 EXPECT_EQ(ret, false);
1112 }
1113
1114 /**
1115 * @tc.name : Test AudioProcessInClientInner API
1116 * @tc.type : FUNC
1117 * @tc.number: AudioProcessInClientInner_055
1118 * @tc.desc : Test inline S16MonoToS16Stereo
1119 */
1120 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_055, TestSize.Level1)
1121 {
1122 BufferDesc srcDesc;
1123 BufferDesc dstDesc;
1124 srcDesc.bufLength = 1;
1125 dstDesc.bufLength = 1;
1126 uint8_t buffer = 0;
1127 srcDesc.buffer = &buffer;
1128 dstDesc.buffer = &buffer;
1129 auto ret = FormatConverter::S16MonoToS16Stereo(srcDesc, dstDesc) == 0;
1130
1131 EXPECT_EQ(ret, false);
1132 }
1133
1134 /**
1135 * @tc.name : Test AudioProcessInClientInner API
1136 * @tc.type : FUNC
1137 * @tc.number: AudioProcessInClientInner_056
1138 * @tc.desc : Test inline S16MonoToS16Stereo
1139 */
1140 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_056, TestSize.Level1)
1141 {
1142 BufferDesc srcDesc;
1143 BufferDesc dstDesc;
1144 srcDesc.bufLength = 4;
1145 dstDesc.bufLength = 1;
1146 uint8_t buffer = 0;
1147 srcDesc.buffer = &buffer;
1148 dstDesc.buffer = &buffer;
1149 auto ret = FormatConverter::S16MonoToS16Stereo(srcDesc, dstDesc) == 0;
1150
1151 EXPECT_EQ(ret, false);
1152 }
1153
1154 /**
1155 * @tc.name : Test AudioProcessInClientInner API
1156 * @tc.type : FUNC
1157 * @tc.number: AudioProcessInClientInner_057
1158 * @tc.desc : Test CheckIfSupport
1159 */
1160 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_057, TestSize.Level1)
1161 {
1162 AudioProcessConfig config = InitProcessConfig();
1163 AudioService *g_audioServicePtr = AudioService::GetInstance();
1164 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1165 bool isVoipMmap = true;
1166 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
1167 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
1168
1169 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
1170 AudioProcessConfig audioProcConfig = {0};
1171 audioProcConfig.rendererInfo.streamUsage = STREAM_USAGE_VOICE_COMMUNICATION;
1172 EXPECT_EQ(true, ptrAudioProcessInClientInner->CheckIfSupport(audioProcConfig));
1173 audioProcConfig.rendererInfo.streamUsage = STREAM_USAGE_VIDEO_COMMUNICATION;
1174 EXPECT_EQ(true, ptrAudioProcessInClientInner->CheckIfSupport(audioProcConfig));
1175 }
1176
1177 /**
1178 * @tc.name : Test AudioProcessInClientInner API
1179 * @tc.type : FUNC
1180 * @tc.number: AudioProcessInClientInner_058
1181 * @tc.desc : Test CheckIfSupport
1182 */
1183 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_058, TestSize.Level1)
1184 {
1185 AudioProcessConfig config = InitProcessConfig();
1186 AudioService *g_audioServicePtr = AudioService::GetInstance();
1187 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1188 bool isVoipMmap = true;
1189 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
1190 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
1191
1192 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
1193 AudioProcessConfig audioProcConfig = {0};
1194 audioProcConfig.capturerInfo.sourceType = SOURCE_TYPE_VOICE_COMMUNICATION;
1195 EXPECT_EQ(true, ptrAudioProcessInClientInner->CheckIfSupport(audioProcConfig));
1196 }
1197
1198 /**
1199 * @tc.name : Test AudioProcessInClientInner API
1200 * @tc.type : FUNC
1201 * @tc.number: AudioProcessInClientInner_059
1202 * @tc.desc : Test CheckIfSupport
1203 */
1204 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_059, TestSize.Level1)
1205 {
1206 AudioProcessConfig config = InitProcessConfig();
1207 AudioService *g_audioServicePtr = AudioService::GetInstance();
1208 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1209 bool isVoipMmap = true;
1210 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
1211 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
1212
1213 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
1214 AudioProcessConfig audioProcConfig = {0};
1215 audioProcConfig.streamInfo.samplingRate = SAMPLE_RATE_8000;
1216 EXPECT_EQ(false, ptrAudioProcessInClientInner->CheckIfSupport(audioProcConfig));
1217 }
1218
1219 /**
1220 * @tc.name : Test AudioProcessInClientInner API
1221 * @tc.type : FUNC
1222 * @tc.number: AudioProcessInClientInner_060
1223 * @tc.desc : Test CheckIfSupport
1224 */
1225 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_060, TestSize.Level1)
1226 {
1227 AudioProcessConfig config = InitProcessConfig();
1228 AudioService *g_audioServicePtr = AudioService::GetInstance();
1229 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1230 bool isVoipMmap = true;
1231 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
1232 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
1233
1234 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
1235 AudioProcessConfig audioProcConfig = {0};
1236 audioProcConfig.streamInfo.encoding = ENCODING_AUDIOVIVID;
1237 EXPECT_EQ(false, ptrAudioProcessInClientInner->CheckIfSupport(audioProcConfig));
1238 }
1239
1240 /**
1241 * @tc.name : Test AudioProcessInClientInner API
1242 * @tc.type : FUNC
1243 * @tc.number: AudioProcessInClientInner_061
1244 * @tc.desc : Test CheckIfSupport
1245 */
1246 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_061, TestSize.Level1)
1247 {
1248 AudioProcessConfig config = InitProcessConfig();
1249 AudioService *g_audioServicePtr = AudioService::GetInstance();
1250 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1251 bool isVoipMmap = true;
1252 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
1253 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
1254
1255 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
1256 AudioProcessConfig audioProcConfig = {0};
1257 audioProcConfig.streamInfo.format = SAMPLE_S24LE;
1258 EXPECT_EQ(false, ptrAudioProcessInClientInner->CheckIfSupport(audioProcConfig));
1259 }
1260
1261 /**
1262 * @tc.name : Test AudioProcessInClientInner API
1263 * @tc.type : FUNC
1264 * @tc.number: AudioProcessInClientInner_062
1265 * @tc.desc : Test CheckIfSupport
1266 */
1267 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_062, 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 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
1274 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
1275
1276 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
1277 AudioProcessConfig audioProcConfig = {0};
1278 audioProcConfig.streamInfo.channels = CHANNEL_3;
1279 EXPECT_EQ(false, ptrAudioProcessInClientInner->CheckIfSupport(audioProcConfig));
1280 }
1281
1282 /**
1283 * @tc.name : Test AudioProcessInClientInner API
1284 * @tc.type : FUNC
1285 * @tc.number: AudioProcessInClientInner_063
1286 * @tc.desc : Test CheckIfSupport
1287 */
1288 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_063, 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 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
1295 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
1296
1297 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
1298 AudioProcessConfig audioProcConfig = {0};
1299 audioProcConfig.rendererInfo.streamUsage = STREAM_USAGE_MEDIA;
1300 audioProcConfig.capturerInfo.sourceType = SOURCE_TYPE_VOICE_CALL;
1301 audioProcConfig.streamInfo.samplingRate = SAMPLE_RATE_48000;
1302 audioProcConfig.streamInfo.encoding = ENCODING_PCM;
1303 audioProcConfig.streamInfo.format = SAMPLE_S16LE;
1304 audioProcConfig.streamInfo.channels = MONO;
1305 EXPECT_EQ(true, ptrAudioProcessInClientInner->CheckIfSupport(audioProcConfig));
1306 }
1307
1308 /**
1309 * @tc.name : Test AudioProcessInClientInner API
1310 * @tc.type : FUNC
1311 * @tc.number: AudioProcessInClientInner_064
1312 * @tc.desc : Test SetMute, SetDuckVolume, SetUnderflowCount, GetUnderflowCount, SetOverflowCount, GetOverflowCount
1313 */
1314 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_064, TestSize.Level1)
1315 {
1316 AudioProcessConfig config = InitProcessConfig();
1317 AudioService *g_audioServicePtr = AudioService::GetInstance();
1318 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1319 bool isVoipMmap = true;
1320 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
1321 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
1322
1323 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
1324 int32_t ret = ptrAudioProcessInClientInner->SetMute(true);
1325 EXPECT_EQ(0, ret);
1326 ret = ptrAudioProcessInClientInner->SetDuckVolume(0.5f);
1327 EXPECT_EQ(0, ret);
1328 ptrAudioProcessInClientInner->underflowCount_ = 0;
1329 ptrAudioProcessInClientInner->SetUnderflowCount(1);
1330 uint32_t res = ptrAudioProcessInClientInner->GetUnderflowCount();
1331 EXPECT_EQ(1, res);
1332 ptrAudioProcessInClientInner->overflowCount_ = 0;
1333 ptrAudioProcessInClientInner->SetOverflowCount(1);
1334 res = ptrAudioProcessInClientInner->GetOverflowCount();
1335 EXPECT_EQ(1, res);
1336 }
1337
1338 /**
1339 * @tc.name : Test AudioProcessInClientInner API
1340 * @tc.type : FUNC
1341 * @tc.number: AudioProcessInClientInner_065
1342 * @tc.desc : Test GetFramesWritten, GetFramesRead, UpdateLatencyTimestamp
1343 */
1344 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_065, TestSize.Level1)
1345 {
1346 AudioProcessConfig config = InitProcessConfig();
1347 AudioService *g_audioServicePtr = AudioService::GetInstance();
1348 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1349 bool isVoipMmap = true;
1350 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
1351 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
1352
1353 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
1354 ptrAudioProcessInClientInner->processConfig_.audioMode = AUDIO_MODE_PLAYBACK;
1355 int64_t res = 0;
1356 res = ptrAudioProcessInClientInner->GetFramesWritten();
1357 EXPECT_EQ(res, -1);
1358 ptrAudioProcessInClientInner->processConfig_.audioMode = AUDIO_MODE_RECORD;
1359 res = ptrAudioProcessInClientInner->GetFramesRead();
1360 EXPECT_EQ(res, -1);
1361 }
1362
1363 /**
1364 * @tc.name : Test AudioProcessInClientInner API
1365 * @tc.type : FUNC
1366 * @tc.number: AudioProcessInClientInner_066
1367 * @tc.desc : Test SaveUnderrunCallback
1368 */
1369 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_066, 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 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
1376 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
1377
1378 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
1379 std::shared_ptr<ClientUnderrunCallBack> underrunCallback = nullptr;
1380 ptrAudioProcessInClientInner->isInited_ = false;
1381 int32_t ret = ptrAudioProcessInClientInner->SaveUnderrunCallback(underrunCallback);
1382 EXPECT_EQ(ERR_ILLEGAL_STATE, ret);
1383 }
1384
1385 /**
1386 * @tc.name : Test AudioProcessInClientInner API
1387 * @tc.type : FUNC
1388 * @tc.number: AudioProcessInClientInner_067
1389 * @tc.desc : Test ChannelFormatS16Convert
1390 */
1391 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_067, TestSize.Level1)
1392 {
1393 sptr<AudioProcessInServer> stream = AudioProcessInServer::Create(InitProcessConfig(), AudioService::GetInstance());
1394
1395 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
1396 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(stream, true, info);
1397
1398 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
1399 AudioStreamData srcData;
1400 AudioStreamData dstData;
1401 srcData.streamInfo.samplingRate = SAMPLE_RATE_16000;
1402 dstData.streamInfo.samplingRate = SAMPLE_RATE_48000;
1403 bool ret = ptrAudioProcessInClientInner->ChannelFormatS16Convert(srcData, dstData);
1404 EXPECT_EQ(false, ret);
1405 dstData.streamInfo.samplingRate = SAMPLE_RATE_16000;
1406 srcData.streamInfo.format = SAMPLE_S16LE;
1407 srcData.streamInfo.channels = STEREO;
1408 dstData.streamInfo.encoding = ENCODING_AUDIOVIVID;
1409 ret = ptrAudioProcessInClientInner->ChannelFormatS16Convert(srcData, dstData);
1410 EXPECT_EQ(false, ret);
1411 dstData.streamInfo.encoding = ENCODING_PCM;
1412 ret = ptrAudioProcessInClientInner->ChannelFormatS16Convert(srcData, dstData);
1413 EXPECT_EQ(true, ret);
1414 srcData.streamInfo.channels = MONO;
1415 ret = ptrAudioProcessInClientInner->ChannelFormatS16Convert(srcData, dstData);
1416 EXPECT_EQ(false, ret);
1417
1418 srcData.streamInfo.format = SAMPLE_S32LE;
1419 ret = ptrAudioProcessInClientInner->ChannelFormatS16Convert(srcData, dstData);
1420 EXPECT_EQ(false, ret);
1421 srcData.streamInfo.channels = CHANNEL_3;
1422 ret = ptrAudioProcessInClientInner->ChannelFormatS16Convert(srcData, dstData);
1423 EXPECT_EQ(false, ret);
1424 srcData.streamInfo.channels = STEREO;
1425 ret = ptrAudioProcessInClientInner->ChannelFormatS16Convert(srcData, dstData);
1426 EXPECT_EQ(false, ret);
1427 srcData.streamInfo.format = INVALID_WIDTH;
1428 ret = ptrAudioProcessInClientInner->ChannelFormatS16Convert(srcData, dstData);
1429 EXPECT_EQ(false, ret);
1430 srcData.streamInfo.format = SAMPLE_F32LE;
1431 srcData.streamInfo.channels = MONO;
1432 uint8_t src1[NUMBER4] = {0};
1433 srcData.bufferDesc = {src1, NUMBER4, NUMBER4};
1434 uint8_t dst[NUMBER4] = {0};
1435 dstData.bufferDesc = {dst, NUMBER4, NUMBER4};
1436 ret = ptrAudioProcessInClientInner->ChannelFormatS16Convert(srcData, dstData);
1437 EXPECT_EQ(true, ret);
1438 srcData.streamInfo.channels = STEREO;
1439 uint8_t src2[NUMBER8] = {0};
1440 srcData.bufferDesc = {src2, NUMBER8, NUMBER8};
1441 ret = ptrAudioProcessInClientInner->ChannelFormatS16Convert(srcData, dstData);
1442 EXPECT_EQ(true, ret);
1443 }
1444
1445 /**
1446 * @tc.name : Test AudioProcessInClientInner API
1447 * @tc.type : FUNC
1448 * @tc.number: AudioProcessInClientInner_068
1449 * @tc.desc : Test Pause, Resume
1450 */
1451 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_068, TestSize.Level1)
1452 {
1453 AudioProcessConfig config = InitProcessConfig();
1454 AudioService *g_audioServicePtr = AudioService::GetInstance();
1455 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1456 bool isVoipMmap = true;
1457 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
1458 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
1459
1460 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
1461 int32_t ret = ptrAudioProcessInClientInner->Pause(true);
1462 EXPECT_EQ(ERR_ILLEGAL_STATE, ret);
1463 ret = ptrAudioProcessInClientInner->Pause(true);
1464 EXPECT_EQ(ERR_ILLEGAL_STATE, ret);
1465 ret = ptrAudioProcessInClientInner->Resume();
1466 EXPECT_EQ(ERR_ILLEGAL_STATE, ret);
1467 }
1468
1469 /**
1470 * @tc.name : Test AudioProcessInClientInner API
1471 * @tc.type : FUNC
1472 * @tc.number: AudioProcessInClientInner_069
1473 * @tc.desc : Test CheckIfSupport
1474 */
1475 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_069, TestSize.Level1)
1476 {
1477 AudioProcessConfig config = InitProcessConfig();
1478 AudioService *g_audioServicePtr = AudioService::GetInstance();
1479 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1480 bool isVoipMmap = true;
1481 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
1482 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
1483
1484 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
1485 AudioProcessConfig audioProcConfig;
1486 audioProcConfig.rendererInfo.streamUsage = STREAM_USAGE_MEDIA;
1487 audioProcConfig.capturerInfo.sourceType = SOURCE_TYPE_VOICE_CALL;
1488 audioProcConfig.streamInfo.samplingRate = SAMPLE_RATE_48000;
1489 audioProcConfig.streamInfo.encoding = ENCODING_AUDIOVIVID;
1490 audioProcConfig.streamInfo.channels = MONO;
1491 EXPECT_EQ(false, ptrAudioProcessInClientInner->CheckIfSupport(audioProcConfig));
1492 audioProcConfig.streamInfo.encoding = ENCODING_PCM;
1493 audioProcConfig.streamInfo.format = SAMPLE_S24LE;
1494 EXPECT_EQ(false, ptrAudioProcessInClientInner->CheckIfSupport(audioProcConfig));
1495 audioProcConfig.streamInfo.format = SAMPLE_S32LE;
1496 EXPECT_EQ(true, ptrAudioProcessInClientInner->CheckIfSupport(audioProcConfig));
1497 }
1498
1499 /**
1500 * @tc.name : Test AudioProcessInClientInner API
1501 * @tc.type : FUNC
1502 * @tc.number: AudioProcessInClientInner_070
1503 * @tc.desc : Test CheckIfSupport
1504 */
1505 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_070, TestSize.Level1)
1506 {
1507 AudioProcessConfig config = InitProcessConfig();
1508 AudioService *g_audioServicePtr = AudioService::GetInstance();
1509 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1510 bool isVoipMmap = false;
1511 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
1512 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
1513 auto ptrFastAudioStream = std::make_shared<FastAudioStream>(config.streamType,
1514 AUDIO_MODE_RECORD, config.appInfo.appUid);
1515 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
1516 bool ret = ptrAudioProcessInClientInner->Init(config, ptrFastAudioStream);
1517 EXPECT_EQ(ret, false);
1518 }
1519
1520 /**
1521 * @tc.name : Test AudioProcessInClientInner API
1522 * @tc.type : FUNC
1523 * @tc.number: AudioProcessInClientInner_072
1524 * @tc.desc : Test AudioProcessInClientInner::GetAudioTime
1525 */
1526 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_072, TestSize.Level1)
1527 {
1528 AudioProcessConfig config = InitProcessConfig();
1529 AudioService *g_audioServicePtr = AudioService::GetInstance();
1530 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1531 bool isVoipMmap = true;
1532 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
1533 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
1534 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
1535
1536 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_CLIENT;
1537 uint32_t totalSizeInFrame = 0;
1538 uint32_t byteSizePerFrame = 0;
1539 ptrAudioProcessInClientInner->audioBuffer_ = std::make_shared<OHAudioBufferBase>(bufferHolder, totalSizeInFrame,
1540 byteSizePerFrame);
1541 ASSERT_TRUE(ptrAudioProcessInClientInner->audioBuffer_ != nullptr);
1542
1543 ptrAudioProcessInClientInner->audioBuffer_->basicBufferInfo_ = new BasicBufferInfo();
1544 auto ptrBufferInfo = ptrAudioProcessInClientInner->audioBuffer_->basicBufferInfo_;
1545 ASSERT_TRUE(ptrBufferInfo != nullptr);
1546
1547 ptrBufferInfo->curReadFrame.store(UINT32_MAX + 1);
1548 auto ptrFastAudioStream = std::make_shared<FastAudioStream>(config.streamType,
1549 AUDIO_MODE_RECORD, config.appInfo.appUid);
1550 ptrAudioProcessInClientInner->Init(config, ptrFastAudioStream);
1551
1552 uint32_t framePos = 0;
1553 int64_t sec = 0;
1554 int64_t nanoSec = 0;
1555 auto ret = ptrAudioProcessInClientInner->GetAudioTime(framePos, sec, nanoSec);
1556 delete ptrBufferInfo;
1557 EXPECT_EQ(ret, true);
1558 }
1559
1560 /**
1561 * @tc.name : Test AudioProcessInClientInner API
1562 * @tc.type : FUNC
1563 * @tc.number: AudioProcessInClientInner_073
1564 * @tc.desc : Test AudioProcessInClientInner::GetFramesWritten
1565 */
1566 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_073, TestSize.Level1)
1567 {
1568 AudioProcessConfig config = InitProcessConfig();
1569 AudioService *g_audioServicePtr = AudioService::GetInstance();
1570 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1571 bool isVoipMmap = true;
1572 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
1573 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
1574 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
1575
1576 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_CLIENT;
1577 uint32_t totalSizeInFrame = 0;
1578 uint32_t byteSizePerFrame = 0;
1579 ptrAudioProcessInClientInner->audioBuffer_ = std::make_shared<OHAudioBufferBase>(bufferHolder, totalSizeInFrame,
1580 byteSizePerFrame);
1581 ASSERT_TRUE(ptrAudioProcessInClientInner->audioBuffer_ != nullptr);
1582
1583 auto ptrFastAudioStream = std::make_shared<FastAudioStream>(config.streamType,
1584 AUDIO_MODE_RECORD, config.appInfo.appUid);
1585 ptrAudioProcessInClientInner->Init(config, ptrFastAudioStream);
1586 ptrAudioProcessInClientInner->processConfig_.audioMode = AUDIO_MODE_PLAYBACK;
1587 ptrAudioProcessInClientInner->audioBuffer_->basicBufferInfo_ = new BasicBufferInfo();
1588 auto ptrBufferInfo = ptrAudioProcessInClientInner->audioBuffer_->basicBufferInfo_;
1589 ASSERT_TRUE(ptrBufferInfo != nullptr);
1590
1591 ptrBufferInfo->curWriteFrame.store(0);
1592
1593 auto ret = ptrAudioProcessInClientInner->GetFramesWritten();
1594 delete ptrBufferInfo;
1595 EXPECT_EQ(ret, 0);
1596 }
1597
1598 /**
1599 * @tc.name : Test AudioProcessInClientInner API
1600 * @tc.type : FUNC
1601 * @tc.number: AudioProcessInClientInner_074
1602 * @tc.desc : Test AudioProcessInClientInner::GetFramesRead
1603 */
1604 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_074, TestSize.Level1)
1605 {
1606 AudioProcessConfig config = InitProcessConfig();
1607 AudioService *g_audioServicePtr = AudioService::GetInstance();
1608 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1609 bool isVoipMmap = true;
1610 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
1611 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
1612 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
1613
1614 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_CLIENT;
1615 uint32_t totalSizeInFrame = 0;
1616 uint32_t byteSizePerFrame = 0;
1617 ptrAudioProcessInClientInner->audioBuffer_ = std::make_shared<OHAudioBufferBase>(bufferHolder, totalSizeInFrame,
1618 byteSizePerFrame);
1619 ASSERT_TRUE(ptrAudioProcessInClientInner->audioBuffer_ != nullptr);
1620
1621 auto ptrFastAudioStream = std::make_shared<FastAudioStream>(config.streamType,
1622 AUDIO_MODE_RECORD, config.appInfo.appUid);
1623 ptrAudioProcessInClientInner->Init(config, ptrFastAudioStream);
1624 ptrAudioProcessInClientInner->audioBuffer_->basicBufferInfo_ = new BasicBufferInfo();
1625 auto ptrBufferInfo = ptrAudioProcessInClientInner->audioBuffer_->basicBufferInfo_;
1626 ASSERT_TRUE(ptrBufferInfo != nullptr);
1627
1628 ptrBufferInfo->curReadFrame.store(0);
1629
1630 auto ret = ptrAudioProcessInClientInner->GetFramesRead();
1631 delete ptrBufferInfo;
1632 EXPECT_EQ(ret, 0);
1633 }
1634
1635 /**
1636 * @tc.name : Test AudioProcessInClientInner API
1637 * @tc.type : FUNC
1638 * @tc.number: AudioProcessInClientInner_075
1639 * @tc.desc : Test AudioProcessInClientInner::UpdateLatencyTimestamp
1640 */
1641 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_075, TestSize.Level1)
1642 {
1643 AudioProcessConfig config = InitProcessConfig();
1644 AudioService *g_audioServicePtr = AudioService::GetInstance();
1645 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1646 bool isVoipMmap = true;
1647 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
1648 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
1649 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
1650
1651 std::string timestamp = "";
1652 bool isRenderer = true;
1653 ptrAudioProcessInClientInner->UpdateLatencyTimestamp(timestamp, isRenderer);
1654 }
1655
1656 /**
1657 * @tc.name : Test AudioProcessInClientInner API
1658 * @tc.type : FUNC
1659 * @tc.number: AudioProcessInClientInner_076
1660 * @tc.desc : Test AudioProcessInClientInner::Init
1661 */
1662 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_076, TestSize.Level1)
1663 {
1664 AudioProcessConfig config = InitProcessConfig();
1665 AudioService *g_audioServicePtr = AudioService::GetInstance();
1666 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1667 bool isVoipMmap = true;
1668 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
1669 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
1670 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
1671
1672 AudioProcessConfig audioProcessConfig;
1673 auto ptrFastAudioStream = std::make_shared<FastAudioStream>(config.streamType,
1674 AUDIO_MODE_RECORD, config.appInfo.appUid);
1675 auto ret = ptrAudioProcessInClientInner->Init(audioProcessConfig, ptrFastAudioStream);
1676 EXPECT_NE(ret, true);
1677 }
1678
1679 /**
1680 * @tc.name : Test AudioProcessInClientInner API
1681 * @tc.type : FUNC
1682 * @tc.number: AudioProcessInClientInner_077
1683 * @tc.desc : Test AudioProcessInClientInner::SaveUnderrunCallback
1684 */
1685 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_077, TestSize.Level1)
1686 {
1687 AudioProcessConfig config = InitProcessConfig();
1688 AudioService *g_audioServicePtr = AudioService::GetInstance();
1689 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1690 bool isVoipMmap = true;
1691 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
1692 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
1693 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
1694
1695 ptrAudioProcessInClientInner->isInited_ = true;
1696 std::shared_ptr<ClientUnderrunCallBack> underrunCallback;
1697 underrunCallback = std::make_shared<ClientUnderrunCallBackTest>();
1698 ASSERT_TRUE(underrunCallback != nullptr);
1699
1700 auto ret = ptrAudioProcessInClientInner->SaveUnderrunCallback(underrunCallback);
1701 ptrAudioProcessInClientInner->isInited_ = false;
1702 EXPECT_EQ(ret, SUCCESS);
1703 }
1704
1705 /**
1706 * @tc.name : Test AudioProcessInClientInner API
1707 * @tc.type : FUNC
1708 * @tc.number: AudioProcessInClientInner_078
1709 * @tc.desc : Test AudioProcessInClientInner::CheckIfSupport
1710 */
1711 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_078, TestSize.Level1)
1712 {
1713 AudioProcessConfig config = InitProcessConfig();
1714 AudioService *g_audioServicePtr = AudioService::GetInstance();
1715 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1716 bool isVoipMmap = true;
1717 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
1718 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
1719 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
1720
1721 AudioProcessConfig audioProcessConfig;
1722 audioProcessConfig.appInfo.appPid = getpid();
1723 audioProcessConfig.appInfo.appUid = getuid();
1724 audioProcessConfig.audioMode = AUDIO_MODE_RECORD;
1725 audioProcessConfig.capturerInfo.sourceType = SOURCE_TYPE_MIC;
1726 audioProcessConfig.capturerInfo.capturerFlags = STREAM_FLAG_FAST;
1727 audioProcessConfig.streamInfo.channels = STEREO;
1728 audioProcessConfig.streamInfo.encoding = ENCODING_PCM;
1729 audioProcessConfig.streamInfo.format = SAMPLE_S16LE;
1730 audioProcessConfig.streamInfo.samplingRate = SAMPLE_RATE_48000;
1731
1732 auto ret = ptrAudioProcessInClientInner->CheckIfSupport(audioProcessConfig);
1733 EXPECT_EQ(ret, true);
1734 }
1735
1736 /**
1737 * @tc.name : Test AudioProcessInClientInner API
1738 * @tc.type : FUNC
1739 * @tc.number: AudioProcessInClientInner_079
1740 * @tc.desc : Test AudioProcessInClientInner::ChannelFormatS16Convert
1741 */
1742 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_079, TestSize.Level1)
1743 {
1744 AudioProcessConfig config = InitProcessConfig();
1745 AudioService *g_audioServicePtr = AudioService::GetInstance();
1746 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1747 bool isVoipMmap = true;
1748 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
1749 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
1750 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
1751
1752 AudioStreamData dstData;
1753 AudioStreamData srcData;
1754 srcData.streamInfo.format = SAMPLE_F32LE;
1755 srcData.streamInfo.channels = MONO;
1756 dstData.streamInfo.format = SAMPLE_S16LE;
1757 dstData.streamInfo.channels = STEREO;
1758
1759 uint8_t src1[NUMBER4] = {0};
1760 srcData.bufferDesc = {src1, NUMBER4, NUMBER4};
1761 uint8_t dst[NUMBER4] = {0};
1762 dstData.bufferDesc = {dst, NUMBER4, NUMBER4};
1763 auto ret = ptrAudioProcessInClientInner->ChannelFormatS16Convert(srcData, dstData);
1764 EXPECT_EQ(ret, true);
1765 }
1766
1767 /**
1768 * @tc.name : Test AudioProcessInClientInner API
1769 * @tc.type : FUNC
1770 * @tc.number: AudioProcessInClientInner_080
1771 * @tc.desc : Test AudioProcessInClientInner::ChannelFormatS16Convert
1772 */
1773 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_080, TestSize.Level1)
1774 {
1775 AudioProcessConfig config = InitProcessConfig();
1776 AudioService *g_audioServicePtr = AudioService::GetInstance();
1777 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1778 bool isVoipMmap = true;
1779 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
1780 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
1781 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
1782
1783 AudioStreamData dstData;
1784 AudioStreamData srcData;
1785 srcData.streamInfo.format = SAMPLE_F32LE;
1786 srcData.streamInfo.channels = STEREO;
1787 dstData.streamInfo.format = SAMPLE_S16LE;
1788 dstData.streamInfo.channels = STEREO;
1789
1790 uint8_t src1[NUMBER8] = {0};
1791 srcData.bufferDesc = {src1, NUMBER8, NUMBER8};
1792 uint8_t dst[NUMBER4] = {0};
1793 dstData.bufferDesc = {dst, NUMBER4, NUMBER4};
1794 auto ret = ptrAudioProcessInClientInner->ChannelFormatS16Convert(srcData, dstData);
1795 EXPECT_EQ(ret, true);
1796 }
1797
1798 /**
1799 * @tc.name : Test AudioProcessInClientInner API
1800 * @tc.type : FUNC
1801 * @tc.number: AudioProcessInClientInner_081
1802 * @tc.desc : Test AudioProcessInClientInner::CopyWithVolume
1803 */
1804 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_081, TestSize.Level1)
1805 {
1806 AudioProcessConfig config = InitProcessConfig();
1807 AudioService *g_audioServicePtr = AudioService::GetInstance();
1808 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1809 bool isVoipMmap = true;
1810 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
1811 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
1812 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
1813
1814 BufferDesc srcDesc;
1815 BufferDesc dstDesc;
1816 ptrAudioProcessInClientInner->CopyWithVolume(srcDesc, dstDesc);
1817 }
1818
1819 /**
1820 * @tc.name : Test AudioProcessInClientInner API
1821 * @tc.type : FUNC
1822 * @tc.number: AudioProcessInClientInner_082
1823 * @tc.desc : Test AudioProcessInClientInner::ProcessData
1824 */
1825 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_082, TestSize.Level1)
1826 {
1827 AudioProcessConfig config = InitProcessConfig();
1828 AudioService *g_audioServicePtr = AudioService::GetInstance();
1829 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1830 bool isVoipMmap = true;
1831 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
1832 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
1833 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
1834
1835 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_SERVER_INDEPENDENT;
1836 uint32_t totalSizeInFrame = 0;
1837 uint32_t byteSizePerFrame = 0;
1838 ptrAudioProcessInClientInner->audioBuffer_ = std::make_shared<OHAudioBufferBase>(bufferHolder, totalSizeInFrame,
1839 byteSizePerFrame);
1840 ASSERT_TRUE(ptrAudioProcessInClientInner->audioBuffer_ != nullptr);
1841
1842 BufferDesc srcDesc;
1843 BufferDesc dstDesc;
1844 auto ret = ptrAudioProcessInClientInner->ProcessData(srcDesc, dstDesc);
1845 EXPECT_EQ(ret, SUCCESS);
1846 }
1847
1848 /**
1849 * @tc.name : Test AudioProcessInClientInner API
1850 * @tc.type : FUNC
1851 * @tc.number: AudioProcessInClientInner_083
1852 * @tc.desc : Test AudioProcessInClientInner::ProcessData
1853 */
1854 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_083, TestSize.Level1)
1855 {
1856 AudioProcessConfig config = InitProcessConfig();
1857 AudioService *g_audioServicePtr = AudioService::GetInstance();
1858 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1859 bool isVoipMmap = true;
1860 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
1861 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
1862 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
1863
1864 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_CLIENT;
1865 uint32_t totalSizeInFrame = 0;
1866 uint32_t byteSizePerFrame = 0;
1867 ptrAudioProcessInClientInner->audioBuffer_ = std::make_shared<OHAudioBufferBase>(bufferHolder, totalSizeInFrame,
1868 byteSizePerFrame);
1869 ASSERT_TRUE(ptrAudioProcessInClientInner->audioBuffer_ != nullptr);
1870
1871 BufferDesc srcDesc;
1872 BufferDesc dstDesc;
1873 auto ret = ptrAudioProcessInClientInner->ProcessData(srcDesc, dstDesc);
1874 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1875 }
1876
1877 /**
1878 * @tc.name : Test AudioProcessInClientInner API
1879 * @tc.type : FUNC
1880 * @tc.number: AudioProcessInClientInner_084
1881 * @tc.desc : Test AudioProcessInClientInner::Pause
1882 */
1883 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_084, TestSize.Level1)
1884 {
1885 AudioProcessConfig config = InitProcessConfig();
1886 AudioService *g_audioServicePtr = AudioService::GetInstance();
1887 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1888 bool isVoipMmap = true;
1889 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
1890 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
1891 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
1892
1893 ptrAudioProcessInClientInner->isInited_ = true;
1894 ptrAudioProcessInClientInner->streamStatus_ = new std::atomic<StreamStatus>(StreamStatus::STREAM_PAUSED);
1895 auto ptrStreamStatus = ptrAudioProcessInClientInner->streamStatus_;
1896 ASSERT_TRUE(ptrStreamStatus != nullptr);
1897
1898 bool isFlush = true;
1899 auto ret = ptrAudioProcessInClientInner->Pause(isFlush);
1900 EXPECT_EQ(ret, SUCCESS);
1901
1902 ptrAudioProcessInClientInner->streamStatus_ = new std::atomic<StreamStatus>(StreamStatus::STREAM_STAND_BY);
1903 ret = ptrAudioProcessInClientInner->Pause(isFlush);
1904 EXPECT_NE(ret, SUCCESS);
1905
1906 ptrAudioProcessInClientInner->streamStatus_ = new std::atomic<StreamStatus>(StreamStatus::STREAM_RUNNING);
1907 ret = ptrAudioProcessInClientInner->Pause(isFlush);
1908 ptrAudioProcessInClientInner->isInited_ = false;
1909 delete ptrStreamStatus;
1910 EXPECT_NE(ret, SUCCESS);
1911 }
1912
1913 /**
1914 * @tc.name : Test AudioProcessInClientInner API
1915 * @tc.type : FUNC
1916 * @tc.number: AudioProcessInClientInner_085
1917 * @tc.desc : Test AudioProcessInClientInner::Resume
1918 */
1919 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_085, TestSize.Level1)
1920 {
1921 AudioProcessConfig config = InitProcessConfig();
1922 AudioService *g_audioServicePtr = AudioService::GetInstance();
1923 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1924 bool isVoipMmap = true;
1925 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
1926 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
1927 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
1928
1929 ptrAudioProcessInClientInner->isInited_ = true;
1930 ptrAudioProcessInClientInner->streamStatus_ = new std::atomic<StreamStatus>(StreamStatus::STREAM_RUNNING);
1931 auto ptrStreamStatus = ptrAudioProcessInClientInner->streamStatus_;
1932 ASSERT_TRUE(ptrStreamStatus != nullptr);
1933
1934 auto ret = ptrAudioProcessInClientInner->Resume();
1935 ptrAudioProcessInClientInner->isInited_ = false;
1936 delete ptrStreamStatus;
1937 EXPECT_EQ(ret, SUCCESS);
1938 }
1939
1940 /**
1941 * @tc.name : Test AudioProcessInClientInner API
1942 * @tc.type : FUNC
1943 * @tc.number: AudioProcessInClientInner_087
1944 * @tc.desc : Test AudioProcessInClientInner::PrepareCurrent
1945 */
1946 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_087, TestSize.Level1)
1947 {
1948 AudioProcessConfig config = InitProcessConfig();
1949 AudioService *g_audioServicePtr = AudioService::GetInstance();
1950 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1951 bool isVoipMmap = true;
1952 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
1953 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
1954 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
1955
1956 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_CLIENT;
1957 uint32_t totalSizeInFrame = 0;
1958 uint32_t byteSizePerFrame = 0;
1959 ptrAudioProcessInClientInner->audioBuffer_ = std::make_shared<OHAudioBufferBase>(bufferHolder, totalSizeInFrame,
1960 byteSizePerFrame);
1961 ASSERT_TRUE(ptrAudioProcessInClientInner->audioBuffer_ != nullptr);
1962
1963 ptrAudioProcessInClientInner->audioBuffer_->basicBufferInfo_ = new BasicBufferInfo();
1964 auto ptrBufferInfo = ptrAudioProcessInClientInner->audioBuffer_->basicBufferInfo_;
1965 ASSERT_TRUE(ptrBufferInfo != nullptr);
1966
1967 ptrBufferInfo->basePosInFrame.store(0);
1968 }
1969
1970 /**
1971 * @tc.name : Test AudioProcessInClientInner API
1972 * @tc.type : FUNC
1973 * @tc.number: AudioProcessInClientInner_088
1974 * @tc.desc : Test AudioProcessInClientInner::PrepareCurrentLoop
1975 */
1976 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_088, TestSize.Level1)
1977 {
1978 AudioProcessConfig config = InitProcessConfig();
1979 AudioService *g_audioServicePtr = AudioService::GetInstance();
1980 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
1981 bool isVoipMmap = true;
1982 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
1983 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
1984 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
1985
1986 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_CLIENT;
1987 uint32_t totalSizeInFrame = 0;
1988 uint32_t byteSizePerFrame = 0;
1989 ptrAudioProcessInClientInner->audioBuffer_ = std::make_shared<OHAudioBufferBase>(bufferHolder, totalSizeInFrame,
1990 byteSizePerFrame);
1991 ASSERT_TRUE(ptrAudioProcessInClientInner->audioBuffer_ != nullptr);
1992
1993 ptrAudioProcessInClientInner->audioBuffer_->basicBufferInfo_ = new BasicBufferInfo();
1994 auto ptrBufferInfo = ptrAudioProcessInClientInner->audioBuffer_->basicBufferInfo_;
1995 ASSERT_TRUE(ptrBufferInfo != nullptr);
1996
1997 ptrBufferInfo->basePosInFrame.store(0);
1998 }
1999
2000 /**
2001 * @tc.name : Test AudioProcessInClientInner API
2002 * @tc.type : FUNC
2003 * @tc.number: AudioProcessInClientInner_089
2004 * @tc.desc : Test AudioProcessInClientInner::PrepareCurrentLoop
2005 */
2006 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_089, TestSize.Level1)
2007 {
2008 AudioProcessConfig config = InitProcessConfig();
2009 AudioService *g_audioServicePtr = AudioService::GetInstance();
2010 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
2011 bool isVoipMmap = true;
2012 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
2013 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
2014 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
2015
2016 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_CLIENT;
2017 uint32_t totalSizeInFrame = 0;
2018 uint32_t byteSizePerFrame = 0;
2019 ptrAudioProcessInClientInner->audioBuffer_ = std::make_shared<OHAudioBufferBase>(bufferHolder, totalSizeInFrame,
2020 byteSizePerFrame);
2021 ASSERT_TRUE(ptrAudioProcessInClientInner->audioBuffer_ != nullptr);
2022
2023 ptrAudioProcessInClientInner->audioBuffer_->basicBufferInfo_ = new BasicBufferInfo();
2024 auto ptrBufferInfo = ptrAudioProcessInClientInner->audioBuffer_->basicBufferInfo_;
2025 ASSERT_TRUE(ptrBufferInfo != nullptr);
2026
2027 ptrBufferInfo->basePosInFrame.store(0);
2028
2029 ptrAudioProcessInClientInner->spanSizeInFrame_ = 1;
2030 ptrAudioProcessInClientInner->clientSpanSizeInFrame_ = 0;
2031 }
2032
2033 /**
2034 * @tc.name : Test AudioProcessInClientInner API
2035 * @tc.type : FUNC
2036 * @tc.number: AudioProcessInClientInner_090
2037 * @tc.desc : Test AudioProcessInClientInner::FinishHandleCurrent
2038 */
2039 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_090, TestSize.Level1)
2040 {
2041 AudioProcessConfig config = InitProcessConfig();
2042 AudioService *g_audioServicePtr = AudioService::GetInstance();
2043 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
2044 bool isVoipMmap = true;
2045 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
2046 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
2047
2048 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
2049
2050 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_CLIENT;
2051 uint32_t totalSizeInFrame = 0;
2052 uint32_t byteSizePerFrame = 0;
2053 ptrAudioProcessInClientInner->audioBuffer_ = std::make_shared<OHAudioBufferBase>(bufferHolder, totalSizeInFrame,
2054 byteSizePerFrame);
2055 ASSERT_TRUE(ptrAudioProcessInClientInner->audioBuffer_ != nullptr);
2056
2057 ptrAudioProcessInClientInner->audioBuffer_->basicBufferInfo_ = new BasicBufferInfo();
2058 auto ptrBufferInfo = ptrAudioProcessInClientInner->audioBuffer_->basicBufferInfo_;
2059 ASSERT_TRUE(ptrBufferInfo != nullptr);
2060
2061 ptrBufferInfo->basePosInFrame.store(0);
2062 }
2063
2064 /**
2065 * @tc.name : Test AudioProcessInClientInner API
2066 * @tc.type : FUNC
2067 * @tc.number: AudioProcessInClientInner_091
2068 * @tc.desc : Test AudioProcessInClientInner::FinishHandleCurrentLoop
2069 */
2070 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_091, TestSize.Level1)
2071 {
2072 AudioProcessConfig config = InitProcessConfig();
2073 AudioService *g_audioServicePtr = AudioService::GetInstance();
2074 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
2075 bool isVoipMmap = true;
2076 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
2077 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
2078
2079 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
2080
2081 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_CLIENT;
2082 uint32_t totalSizeInFrame = 0;
2083 uint32_t byteSizePerFrame = 0;
2084 ptrAudioProcessInClientInner->audioBuffer_ = std::make_shared<OHAudioBufferBase>(bufferHolder, totalSizeInFrame,
2085 byteSizePerFrame);
2086 ASSERT_TRUE(ptrAudioProcessInClientInner->audioBuffer_ != nullptr);
2087
2088 ptrAudioProcessInClientInner->audioBuffer_->basicBufferInfo_ = new BasicBufferInfo();
2089 auto ptrBufferInfo = ptrAudioProcessInClientInner->audioBuffer_->basicBufferInfo_;
2090 ASSERT_TRUE(ptrBufferInfo != nullptr);
2091
2092 ptrBufferInfo->basePosInFrame.store(0);
2093 }
2094
2095 /**
2096 * @tc.name : Test AudioProcessInClientInner API
2097 * @tc.type : FUNC
2098 * @tc.number: AudioProcessInClientInner_092
2099 * @tc.desc : Test AudioProcessInClientInner::FinishHandleCurrentLoop
2100 */
2101 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_092, TestSize.Level1)
2102 {
2103 AudioProcessConfig config = InitProcessConfig();
2104 AudioService *g_audioServicePtr = AudioService::GetInstance();
2105 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
2106 bool isVoipMmap = true;
2107 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
2108 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
2109
2110 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
2111
2112 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_CLIENT;
2113 uint32_t totalSizeInFrame = 0;
2114 uint32_t byteSizePerFrame = 0;
2115 ptrAudioProcessInClientInner->audioBuffer_ = std::make_shared<OHAudioBufferBase>(bufferHolder, totalSizeInFrame,
2116 byteSizePerFrame);
2117 ASSERT_TRUE(ptrAudioProcessInClientInner->audioBuffer_ != nullptr);
2118
2119 ptrAudioProcessInClientInner->audioBuffer_->basicBufferInfo_ = new BasicBufferInfo();
2120 auto ptrBufferInfo = ptrAudioProcessInClientInner->audioBuffer_->basicBufferInfo_;
2121 ASSERT_TRUE(ptrBufferInfo != nullptr);
2122
2123 ptrBufferInfo->basePosInFrame.store(0);
2124
2125 ptrAudioProcessInClientInner->spanSizeInFrame_ = 1;
2126 ptrAudioProcessInClientInner->clientSpanSizeInFrame_ = 0;
2127 }
2128
2129 /**
2130 * @tc.name : Test AudioProcessInClientInner API
2131 * @tc.type : FUNC
2132 * @tc.number: AudioProcessInClientInner_093
2133 * @tc.desc : Test AudioProcessInClientInner::ProcessCallbackFuc
2134 */
2135 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_093, TestSize.Level1)
2136 {
2137 AudioProcessConfig config = InitProcessConfig();
2138 AudioService *g_audioServicePtr = AudioService::GetInstance();
2139 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
2140 bool isVoipMmap = true;
2141 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
2142 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
2143
2144 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
2145
2146 uint64_t curWritePos = 0;
2147
2148 ptrAudioProcessInClientInner->isCallbackLoopEnd_ = true;
2149 ptrAudioProcessInClientInner->startFadeout_.store(false);
2150 auto ret = ptrAudioProcessInClientInner->ProcessCallbackFuc(curWritePos);
2151 EXPECT_EQ(ret, false);
2152 }
2153
2154 /**
2155 * @tc.name : Test AudioProcessInClientInner API
2156 * @tc.type : FUNC
2157 * @tc.number: AudioProcessInClientInner_094
2158 * @tc.desc : Test AudioProcessInClientInner::ProcessCallbackFuc
2159 */
2160 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_094, TestSize.Level1)
2161 {
2162 AudioProcessConfig config = InitProcessConfig();
2163 AudioService *g_audioServicePtr = AudioService::GetInstance();
2164 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
2165 bool isVoipMmap = true;
2166 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
2167 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
2168
2169 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
2170
2171 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_CLIENT;
2172 uint32_t totalSizeInFrame = 0;
2173 uint32_t byteSizePerFrame = 0;
2174 ptrAudioProcessInClientInner->audioBuffer_ = std::make_shared<OHAudioBufferBase>(bufferHolder, totalSizeInFrame,
2175 byteSizePerFrame);
2176 ASSERT_TRUE(ptrAudioProcessInClientInner->audioBuffer_ != nullptr);
2177
2178 ptrAudioProcessInClientInner->audioBuffer_->basicBufferInfo_ = new BasicBufferInfo();
2179 auto ptrBufferInfo = ptrAudioProcessInClientInner->audioBuffer_->basicBufferInfo_;
2180 ASSERT_TRUE(ptrBufferInfo != nullptr);
2181
2182 ptrBufferInfo->curWriteFrame.store(0);
2183
2184 ptrAudioProcessInClientInner->isCallbackLoopEnd_ = false;
2185 ptrAudioProcessInClientInner->streamStatus_ = new std::atomic<StreamStatus>(StreamStatus::STREAM_RUNNING);
2186 auto ptrStreamStatus = ptrAudioProcessInClientInner->streamStatus_;
2187 ASSERT_TRUE(ptrStreamStatus != nullptr);
2188
2189 uint64_t curWritePos = 0;
2190 auto ret = ptrAudioProcessInClientInner->ProcessCallbackFuc(curWritePos);
2191 EXPECT_EQ(ret, true);
2192 }
2193
2194 /**
2195 * @tc.name : Test AudioProcessInClientInner API
2196 * @tc.type : FUNC
2197 * @tc.number: AudioProcessInClientInner_095
2198 * @tc.desc : Test AudioProcessInClientInner::SetSilentModeAndMixWithOthers
2199 */
2200 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_095, TestSize.Level1)
2201 {
2202 AudioProcessConfig config = InitProcessConfig();
2203 AudioService *g_audioServicePtr = AudioService::GetInstance();
2204 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
2205 bool isVoipMmap = true;
2206 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
2207 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
2208
2209 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
2210
2211 bool on = true;
2212 auto ret = ptrAudioProcessInClientInner->SetSilentModeAndMixWithOthers(on);
2213 EXPECT_EQ(ret, SUCCESS);
2214
2215 ptrAudioProcessInClientInner->processProxy_ = nullptr;
2216 ret = ptrAudioProcessInClientInner->SetSilentModeAndMixWithOthers(on);
2217 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
2218 }
2219
2220 /**
2221 * @tc.name : Test AudioProcessInClientInner API
2222 * @tc.type : FUNC
2223 * @tc.number: AudioProcessInClientInner_096
2224 * @tc.desc : Test AudioProcessInClientInner::SetDefaultOutputDevice
2225 */
2226 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_096, TestSize.Level1)
2227 {
2228 AudioProcessConfig config = InitProcessConfig();
2229 AudioService *g_audioServicePtr = AudioService::GetInstance();
2230 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
2231 bool isVoipMmap = true;
2232 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
2233 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
2234
2235 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
2236
2237 ptrAudioProcessInClientInner->processProxy_ = nullptr;
2238 DeviceType defaultOutputDevice = DEVICE_TYPE_NONE;
2239 auto ret = ptrAudioProcessInClientInner->SetSilentModeAndMixWithOthers(defaultOutputDevice);
2240 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
2241 }
2242
2243 /**
2244 * @tc.name : Test AudioProcessInClientInner API
2245 * @tc.type : FUNC
2246 * @tc.number: AudioProcessInClientInner_097
2247 * @tc.desc : Test AudioProcessInClientInner::SaveDataCallback
2248 */
2249 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_097, TestSize.Level1)
2250 {
2251 AudioProcessConfig config = InitProcessConfig();
2252 AudioService *g_audioServicePtr = AudioService::GetInstance();
2253 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
2254 bool isVoipMmap = true;
2255 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
2256 auto audioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
2257
2258 EXPECT_NE(audioProcessInClientInner, nullptr);
2259
2260 std::shared_ptr<AudioDataCallback> audioDataCallbackTest = nullptr;
2261 audioDataCallbackTest = std::make_shared<AudioDataCallbackTest>();
2262
2263 audioProcessInClientInner->isInited_ = false;
2264 auto ret = audioProcessInClientInner->SaveDataCallback(audioDataCallbackTest);
2265 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
2266 }
2267
2268 /**
2269 * @tc.name : Test AudioProcessInClientInner API
2270 * @tc.type : FUNC
2271 * @tc.number: AudioProcessInClientInner_098
2272 * @tc.desc : Test AudioProcessInClientInner::GetBufferDesc_001
2273 */
2274 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_098, TestSize.Level1)
2275 {
2276 AudioProcessConfig config = InitProcessConfig();
2277 AudioService *g_audioServicePtr = AudioService::GetInstance();
2278 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
2279 bool isVoipMmap = true;
2280 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
2281 auto audioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
2282
2283 EXPECT_NE(audioProcessInClientInner, nullptr);
2284
2285 BufferDesc bufDesc;
2286
2287 audioProcessInClientInner->isInited_ = false;
2288 auto ret = audioProcessInClientInner->GetBufferDesc(bufDesc);
2289 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
2290 }
2291
2292 /**
2293 * @tc.name : Test AudioProcessInClientInner API
2294 * @tc.type : FUNC
2295 * @tc.number: AudioProcessInClientInner_099
2296 * @tc.desc : Test AudioProcessInClientInner::GetBufferDesc_002
2297 */
2298 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_099, TestSize.Level1)
2299 {
2300 AudioProcessConfig config = InitProcessConfig();
2301 AudioService *g_audioServicePtr = AudioService::GetInstance();
2302 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
2303 bool isVoipMmap = true;
2304 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
2305 auto audioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
2306
2307 EXPECT_NE(audioProcessInClientInner, nullptr);
2308
2309 BufferDesc bufDesc;
2310 audioProcessInClientInner->clientSpanSizeInByte_ = 1024;
2311 audioProcessInClientInner->callbackBuffer_ =
2312 std::make_unique<uint8_t[]>(audioProcessInClientInner->clientSpanSizeInByte_);
2313 audioProcessInClientInner->processConfig_.audioMode = AudioMode::AUDIO_MODE_PLAYBACK;
2314 auto ret = audioProcessInClientInner->GetBufferDesc(bufDesc);
2315 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
2316 }
2317
2318 /**
2319 * @tc.name : Test AudioProcessInClientInner API
2320 * @tc.type : FUNC
2321 * @tc.number: AudioProcessInClientInner_100
2322 * @tc.desc : Test AudioProcessInClientInner::Enqueue
2323 */
2324 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_100, TestSize.Level1)
2325 {
2326 AudioProcessConfig config = InitProcessConfig();
2327 AudioService *g_audioServicePtr = AudioService::GetInstance();
2328 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
2329 bool isVoipMmap = true;
2330 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
2331 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
2332
2333 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
2334
2335 BufferDesc bufDesc;
2336 bufDesc.buffer = new uint8_t[ptrAudioProcessInClientInner->clientSpanSizeInByte_];
2337 bufDesc.bufLength = ptrAudioProcessInClientInner->clientSpanSizeInByte_;
2338 bufDesc.dataLength = ptrAudioProcessInClientInner->clientSpanSizeInByte_;
2339
2340 auto ret = ptrAudioProcessInClientInner->Enqueue(bufDesc);
2341 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
2342 }
2343
2344 /**
2345 * @tc.name : Test AudioProcessInClientInner API
2346 * @tc.type : FUNC
2347 * @tc.number: AudioProcessInClientInner_101
2348 * @tc.desc : Test AudioProcessInClientInner::SetVolume
2349 */
2350 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_101, TestSize.Level1)
2351 {
2352 AudioProcessConfig config = InitProcessConfig();
2353 AudioService *g_audioServicePtr = AudioService::GetInstance();
2354 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
2355 bool isVoipMmap = true;
2356 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
2357 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
2358
2359 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
2360
2361 float volume = 0.5f;
2362 auto ret = ptrAudioProcessInClientInner->SetVolume(volume);
2363 EXPECT_EQ(ret, SUCCESS);
2364 }
2365
2366 /**
2367 * @tc.name : Test AudioProcessInClientInner API
2368 * @tc.type : FUNC
2369 * @tc.number: AudioProcessInClientInner_102
2370 * @tc.desc : Test AudioProcessInClientInner::Start
2371 */
2372 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_102, TestSize.Level1)
2373 {
2374 AudioProcessConfig config = InitProcessConfig();
2375 AudioService *g_audioServicePtr = AudioService::GetInstance();
2376 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
2377 bool isVoipMmap = true;
2378 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
2379 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
2380
2381 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
2382
2383 auto ret = ptrAudioProcessInClientInner->Start();
2384 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
2385 }
2386
2387 /**
2388 * @tc.name : Test AudioProcessInClientInner API
2389 * @tc.type : FUNC
2390 * @tc.number: AudioProcessInClientInner_103
2391 * @tc.desc : Test AudioProcessInClientInner::Stop
2392 */
2393 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_103, TestSize.Level1)
2394 {
2395 AudioProcessConfig config = InitProcessConfig();
2396 AudioService *g_audioServicePtr = AudioService::GetInstance();
2397 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
2398 bool isVoipMmap = true;
2399 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
2400 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
2401
2402 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
2403
2404 ptrAudioProcessInClientInner->isInited_ = false;
2405 auto ret = ptrAudioProcessInClientInner->Stop();
2406 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
2407
2408 ptrAudioProcessInClientInner->isInited_ = true;
2409 ptrAudioProcessInClientInner->streamStatus_ = new std::atomic<StreamStatus>(StreamStatus::STREAM_STOPPED);
2410 ret = ptrAudioProcessInClientInner->Stop();
2411 EXPECT_EQ(ret, SUCCESS);
2412
2413 ptrAudioProcessInClientInner->streamStatus_ = new std::atomic<StreamStatus>(StreamStatus::STREAM_RUNNING);
2414 ret = ptrAudioProcessInClientInner->Stop();
2415 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
2416 }
2417
2418 /**
2419 * @tc.name : Test AudioProcessInClientInner API
2420 * @tc.type : FUNC
2421 * @tc.number: AudioProcessInClientInner_104
2422 * @tc.desc : Test AudioProcessInClientInner::Release
2423 */
2424 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_104, TestSize.Level1)
2425 {
2426 AudioProcessConfig config = InitProcessConfig();
2427 AudioService *g_audioServicePtr = AudioService::GetInstance();
2428 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
2429 bool isVoipMmap = true;
2430 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
2431 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
2432
2433 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
2434
2435 ptrAudioProcessInClientInner->isInited_ = false;
2436 auto ret = ptrAudioProcessInClientInner->Release(false);
2437 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
2438
2439 ptrAudioProcessInClientInner->isInited_ = true;
2440 ptrAudioProcessInClientInner->streamStatus_ = new std::atomic<StreamStatus>(StreamStatus::STREAM_RUNNING);
2441 ret = ptrAudioProcessInClientInner->Release(false);
2442 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
2443 }
2444
2445 /**
2446 * @tc.name : Test AudioProcessInClientInner API
2447 * @tc.type : FUNC
2448 * @tc.number: AudioProcessInClientInner_105
2449 * @tc.desc : Test AudioProcessInClientInner::GetSessionID
2450 */
2451 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_105, TestSize.Level1)
2452 {
2453 AudioProcessConfig config = InitProcessConfig();
2454 AudioService *g_audioServicePtr = AudioService::GetInstance();
2455 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
2456 bool isVoipMmap = true;
2457 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
2458 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
2459
2460 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
2461
2462 uint32_t sessionId = 0;
2463 auto ret = ptrAudioProcessInClientInner->GetSessionID(sessionId);
2464 EXPECT_EQ(ret, SUCCESS);
2465 }
2466
2467 /**
2468 * @tc.name : Test AudioProcessInClientInner API
2469 * @tc.type : FUNC
2470 * @tc.number: AudioProcessInClientInner_106
2471 * @tc.desc : Test AudioProcessInClientInner::GetBufferSize
2472 */
2473 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_106, TestSize.Level1)
2474 {
2475 AudioProcessConfig config = InitProcessConfig();
2476 AudioService *g_audioServicePtr = AudioService::GetInstance();
2477 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
2478 bool isVoipMmap = true;
2479 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
2480 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
2481
2482 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
2483
2484 uint32_t bufferSize = 0;
2485 auto ret = ptrAudioProcessInClientInner->GetBufferSize(bufferSize);
2486 EXPECT_EQ(ret, SUCCESS);
2487 }
2488
2489 /**
2490 * @tc.name : Test AudioProcessInClientInner API
2491 * @tc.type : FUNC
2492 * @tc.number: AudioProcessInClientInner_107
2493 * @tc.desc : Test AudioProcessInClientInner::GetFrameCount
2494 */
2495 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_107, TestSize.Level1)
2496 {
2497 AudioProcessConfig config = InitProcessConfig();
2498 AudioService *g_audioServicePtr = AudioService::GetInstance();
2499 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
2500 bool isVoipMmap = true;
2501 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
2502 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
2503
2504 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
2505
2506 uint32_t frameCount = 0;
2507 auto ret = ptrAudioProcessInClientInner->GetFrameCount(frameCount);
2508 EXPECT_EQ(ret, SUCCESS);
2509 }
2510
2511 /**
2512 * @tc.name : Test AudioProcessInClientInner API
2513 * @tc.type : FUNC
2514 * @tc.number: AudioProcessInClientInner_108
2515 * @tc.desc : Test AudioProcessInClientInner::GetAudioServerProxy
2516 */
2517 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_108, TestSize.Level1)
2518 {
2519 AudioProcessConfig config = InitProcessConfig();
2520 AudioService *g_audioServicePtr = AudioService::GetInstance();
2521 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
2522 bool isVoipMmap = true;
2523 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
2524 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
2525
2526 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
2527
2528 auto ret = AudioProcessInClientInner::GetAudioServerProxy();
2529 EXPECT_NE(ret, nullptr);
2530 }
2531
2532 /**
2533 * @tc.name : Test AudioProcessInClientInner API
2534 * @tc.type : FUNC
2535 * @tc.number: AudioProcessInClientInner_109
2536 * @tc.desc : Test AudioProcessInClientInner::InitAudioBuffer
2537 */
2538 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_109, TestSize.Level1)
2539 {
2540 AudioProcessConfig config = InitProcessConfig();
2541 AudioService *g_audioServicePtr = AudioService::GetInstance();
2542 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
2543 bool isVoipMmap = true;
2544 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
2545 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
2546
2547 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
2548
2549 auto ret = ptrAudioProcessInClientInner->InitAudioBuffer();
2550 EXPECT_EQ(ret, false);
2551 }
2552
2553 /**
2554 * @tc.name : Test AudioProcessInClientInner API
2555 * @tc.type : FUNC
2556 * @tc.number: AudioProcessInClientInner_110
2557 * @tc.desc : Test AudioProcessInClientInner::ReadFromProcessClient
2558 */
2559 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_110, TestSize.Level1)
2560 {
2561 AudioProcessConfig config = InitProcessConfig();
2562 AudioService *g_audioServicePtr = AudioService::GetInstance();
2563 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
2564 bool isVoipMmap = true;
2565 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
2566 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
2567
2568 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
2569
2570 auto ret = ptrAudioProcessInClientInner->ReadFromProcessClient();
2571 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
2572 }
2573
2574 /**
2575 * @tc.name : Test AudioProcessInClientInner API
2576 * @tc.type : FUNC
2577 * @tc.number: AudioProcessInClientInner_ConvertS32_001
2578 * @tc.desc : Test Convert success
2579 */
2580 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_ConvertS32_001, TestSize.Level1)
2581 {
2582 AudioStreamData srcData;
2583 srcData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_F32LE, STEREO};
2584 uint8_t srcArray[NUMBER8] = {0};
2585 srcData.bufferDesc = {srcArray, NUMBER8, NUMBER8};
2586
2587 AudioStreamData dstData;
2588 dstData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S32LE, STEREO};
2589 uint8_t dstArray[NUMBER8] = {0};
2590 dstData.bufferDesc = {dstArray, NUMBER8, NUMBER8};
2591
2592 bool ret = AudioProcessInClientInner::ChannelFormatS32Convert(srcData, dstData);
2593 EXPECT_EQ(true, ret) << "convert failed, check format";
2594 }
2595
2596 /**
2597 * @tc.name : Test AudioProcessInClientInner API
2598 * @tc.type : FUNC
2599 * @tc.number: AudioProcessInClientInner_ConvertS32_002
2600 * @tc.desc : Test sample rate or encoding different
2601 */
2602 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_ConvertS32_002, TestSize.Level1)
2603 {
2604 AudioStreamData srcData;
2605 srcData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S32LE, STEREO};
2606 uint8_t srcArray[NUMBER8] = {0};
2607 srcData.bufferDesc = {srcArray, NUMBER8, NUMBER8};
2608
2609 AudioStreamData dstData;
2610 dstData.streamInfo = {SAMPLE_RATE_16000, ENCODING_PCM, SAMPLE_S32LE, STEREO};
2611 uint8_t dstArray[NUMBER8] = {0};
2612 dstData.bufferDesc = {dstArray, NUMBER8, NUMBER8};
2613
2614 // samplingRate diff
2615 bool ret = AudioProcessInClientInner::ChannelFormatS32Convert(srcData, dstData);
2616 EXPECT_EQ(false, ret);
2617
2618 dstData.streamInfo = {SAMPLE_RATE_48000, ENCODING_AUDIOVIVID, SAMPLE_S32LE, STEREO};
2619 // encoding diff
2620 ret = AudioProcessInClientInner::ChannelFormatS32Convert(srcData, dstData);
2621 EXPECT_EQ(false, ret);
2622 }
2623
2624 /**
2625 * @tc.name : Test AudioProcessInClientInner API
2626 * @tc.type : FUNC
2627 * @tc.number: AudioProcessInClientInner_ConvertS32_003
2628 * @tc.desc : Test convert SAMPLE_S16LE STEREO
2629 */
2630 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_ConvertS32_003, TestSize.Level1)
2631 {
2632 AudioStreamData srcData;
2633 srcData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
2634 uint8_t srcArray[NUMBER4] = {0};
2635 srcData.bufferDesc = {srcArray, NUMBER4, NUMBER4};
2636
2637 AudioStreamData dstData;
2638 dstData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S32LE, STEREO};
2639 uint8_t dstArray[NUMBER8] = {0};
2640 dstData.bufferDesc = {dstArray, NUMBER8, NUMBER8};
2641
2642 bool ret = AudioProcessInClientInner::ChannelFormatS32Convert(srcData, dstData);
2643 EXPECT_EQ(true, ret) << "convert failed, check format";
2644 }
2645
2646 /**
2647 * @tc.name : Test AudioProcessInClientInner API
2648 * @tc.type : FUNC
2649 * @tc.number: AudioProcessInClientInner_ConvertS32_004
2650 * @tc.desc : Test convert SAMPLE_S16LE MONO
2651 */
2652 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_ConvertS32_004, TestSize.Level1)
2653 {
2654 AudioStreamData srcData;
2655 srcData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, MONO};
2656 uint8_t srcArray[NUMBER2] = {0};
2657 srcData.bufferDesc = {srcArray, NUMBER2, NUMBER2};
2658
2659 AudioStreamData dstData;
2660 dstData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S32LE, STEREO};
2661 uint8_t dstArray[NUMBER8] = {0};
2662 dstData.bufferDesc = {dstArray, NUMBER8, NUMBER8};
2663
2664 bool ret = AudioProcessInClientInner::ChannelFormatS32Convert(srcData, dstData);
2665 EXPECT_EQ(true, ret) << "convert failed, check format";
2666 }
2667
2668 /**
2669 * @tc.name : Test AudioProcessInClientInner API
2670 * @tc.type : FUNC
2671 * @tc.number: AudioProcessInClientInner_ConvertS32_005
2672 * @tc.desc : Test convert SAMPLE_S32LE MONO
2673 */
2674 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_ConvertS32_005, TestSize.Level1)
2675 {
2676 AudioStreamData srcData;
2677 srcData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S32LE, MONO};
2678 uint8_t srcArray[NUMBER4] = {0};
2679 srcData.bufferDesc = {srcArray, NUMBER4, NUMBER4};
2680
2681 AudioStreamData dstData;
2682 dstData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S32LE, STEREO};
2683 uint8_t dstArray[NUMBER8] = {0};
2684 dstData.bufferDesc = {dstArray, NUMBER8, NUMBER8};
2685
2686 bool ret = AudioProcessInClientInner::ChannelFormatS32Convert(srcData, dstData);
2687 EXPECT_EQ(true, ret) << "convert failed, check format";
2688 }
2689
2690 /**
2691 * @tc.name : Test AudioProcessInClientInner API
2692 * @tc.type : FUNC
2693 * @tc.number: AudioProcessInClientInner_ConvertS32_006
2694 * @tc.desc : Test convert SAMPLE_S32LE STEREO
2695 */
2696 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_ConvertS32_006, TestSize.Level1)
2697 {
2698 AudioStreamData srcData;
2699 srcData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S32LE, STEREO};
2700 uint8_t srcArray[NUMBER8] = {0};
2701 srcData.bufferDesc = {srcArray, NUMBER8, NUMBER8};
2702
2703 AudioStreamData dstData;
2704 dstData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S32LE, STEREO};
2705 uint8_t dstArray[NUMBER8] = {0};
2706 dstData.bufferDesc = {dstArray, NUMBER8, NUMBER8};
2707
2708 bool ret = AudioProcessInClientInner::ChannelFormatS32Convert(srcData, dstData);
2709 EXPECT_EQ(true, ret) << "convert failed, check format";
2710 }
2711
2712 /**
2713 * @tc.name : Test AudioProcessInClientInner API
2714 * @tc.type : FUNC
2715 * @tc.number: AudioProcessInClientInner_ConvertS32_007
2716 * @tc.desc : Test convert SAMPLE_F32LE STEREO
2717 */
2718 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_ConvertS32_007, TestSize.Level1)
2719 {
2720 AudioStreamData srcData;
2721 srcData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_F32LE, MONO};
2722 uint8_t srcArray[NUMBER4] = {0};
2723 srcData.bufferDesc = {srcArray, NUMBER4, NUMBER4};
2724
2725 AudioStreamData dstData;
2726 dstData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S32LE, STEREO};
2727 uint8_t dstArray[NUMBER8] = {0};
2728 dstData.bufferDesc = {dstArray, NUMBER8, NUMBER8};
2729
2730 bool ret = AudioProcessInClientInner::ChannelFormatS32Convert(srcData, dstData);
2731 EXPECT_EQ(true, ret) << "convert failed, check format";
2732 }
2733
2734 /**
2735 * @tc.name : Test AudioProcessInClientInner API
2736 * @tc.type : FUNC
2737 * @tc.number: AudioProcessInClientInner_ConvertS32_008
2738 * @tc.desc : Test convert SAMPLE_F32LE STEREO failed
2739 */
2740 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_ConvertS32_008, TestSize.Level1)
2741 {
2742 AudioStreamData srcData;
2743 srcData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_F32LE, STEREO};
2744
2745 AudioStreamData dstData;
2746 dstData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S32LE, STEREO};
2747
2748 srcData.bufferDesc.bufLength = NUMBER8;
2749 bool ret = AudioProcessInClientInner::ChannelFormatS32Convert(srcData, dstData);
2750 EXPECT_EQ(false, ret) << "bufLength not equel fail";
2751
2752 dstData.bufferDesc.bufLength = NUMBER8;
2753 ret = AudioProcessInClientInner::ChannelFormatS32Convert(srcData, dstData);
2754 EXPECT_EQ(false, ret) << "srcDesc.buffer nullptr fail";
2755 }
2756
2757 /**
2758 * @tc.name : Test AudioProcessInClientInner API
2759 * @tc.type : FUNC
2760 * @tc.number: AudioProcessInClientInner_ConvertS32_009
2761 * @tc.desc : Test convert SAMPLE_F32LE STEREO failed
2762 */
2763 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_ConvertS32_009, TestSize.Level1)
2764 {
2765 AudioStreamData srcData;
2766 srcData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_F32LE, STEREO};
2767
2768 AudioStreamData dstData;
2769 dstData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S32LE, STEREO};
2770
2771 dstData.bufferDesc.bufLength = NUMBER8;
2772
2773 uint8_t srcArray[NUMBER8] = {0};
2774 srcData.bufferDesc = {srcArray, NUMBER8, NUMBER8};
2775 bool ret = AudioProcessInClientInner::ChannelFormatS32Convert(srcData, dstData);
2776 EXPECT_EQ(false, ret) << "dstDesc.buffer nullptr fail";
2777 }
2778
2779 /**
2780 * @tc.name : Test AudioProcessInClientInner API
2781 * @tc.type : FUNC
2782 * @tc.number: AudioProcessInClientInner_ConvertS32_010
2783 * @tc.desc : Test convert SAMPLE_S16LE STEREO failed
2784 */
2785 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_ConvertS32_010, TestSize.Level1)
2786 {
2787 AudioStreamData srcData;
2788 srcData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
2789
2790 AudioStreamData dstData;
2791 dstData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S32LE, STEREO};
2792
2793 srcData.bufferDesc.bufLength = NUMBER4;
2794 bool ret = AudioProcessInClientInner::ChannelFormatS32Convert(srcData, dstData);
2795 EXPECT_EQ(false, ret) << "bufLength failed";
2796
2797 dstData.bufferDesc.bufLength = NUMBER8;
2798 ret = AudioProcessInClientInner::ChannelFormatS32Convert(srcData, dstData);
2799 EXPECT_EQ(false, ret) << "srcDesc.buffer is nullptr should fail";
2800
2801 uint8_t srcArray[NUMBER4] = {0};
2802 srcData.bufferDesc = {srcArray, NUMBER4, NUMBER4};
2803 ret = AudioProcessInClientInner::ChannelFormatS32Convert(srcData, dstData);
2804 EXPECT_EQ(false, ret) << "dstDesc.buffer is nullptr should fail";
2805 }
2806
2807 /**
2808 * @tc.name : Test AudioProcessInClientInner API
2809 * @tc.type : FUNC
2810 * @tc.number: AudioProcessInClientInner_ConvertS32_011
2811 * @tc.desc : Test convert SAMPLE_S16LE MONO failed
2812 */
2813 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_ConvertS32_011, TestSize.Level1)
2814 {
2815 AudioStreamData srcData;
2816 srcData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, MONO};
2817
2818 AudioStreamData dstData;
2819 dstData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S32LE, STEREO};
2820
2821 srcData.bufferDesc.bufLength = NUMBER2;
2822 bool ret = AudioProcessInClientInner::ChannelFormatS32Convert(srcData, dstData);
2823 EXPECT_EQ(false, ret) << "bufLength failed";
2824
2825 dstData.bufferDesc.bufLength = NUMBER8;
2826 ret = AudioProcessInClientInner::ChannelFormatS32Convert(srcData, dstData);
2827 EXPECT_EQ(false, ret) << "srcDesc.buffer is nullptr should fail";
2828
2829 uint8_t srcArray[NUMBER2] = {0};
2830 srcData.bufferDesc = {srcArray, NUMBER2, NUMBER2};
2831 ret = AudioProcessInClientInner::ChannelFormatS32Convert(srcData, dstData);
2832 EXPECT_EQ(false, ret) << "dstDesc.buffer is nullptr should fail";
2833 }
2834
2835 /**
2836 * @tc.name : Test AudioProcessInClientInner API
2837 * @tc.type : FUNC
2838 * @tc.number: AudioProcessInClientInner_ConvertS32_012
2839 * @tc.desc : Test convert SAMPLE_S32LE MONO failed
2840 */
2841 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_ConvertS32_012, TestSize.Level1)
2842 {
2843 AudioStreamData srcData;
2844 srcData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S32LE, MONO};
2845
2846 AudioStreamData dstData;
2847 dstData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S32LE, STEREO};
2848
2849 srcData.bufferDesc.bufLength = NUMBER4;
2850 bool ret = AudioProcessInClientInner::ChannelFormatS32Convert(srcData, dstData);
2851 EXPECT_EQ(false, ret) << "bufLength failed";
2852
2853 dstData.bufferDesc.bufLength = NUMBER8;
2854 ret = AudioProcessInClientInner::ChannelFormatS32Convert(srcData, dstData);
2855 EXPECT_EQ(false, ret) << "srcDesc.buffer is nullptr should fail";
2856
2857 uint8_t srcArray[NUMBER4] = {0};
2858 srcData.bufferDesc = {srcArray, NUMBER4, NUMBER4};
2859 ret = AudioProcessInClientInner::ChannelFormatS32Convert(srcData, dstData);
2860 EXPECT_EQ(false, ret) << "dstDesc.buffer is nullptr should fail";
2861 }
2862
2863 /**
2864 * @tc.name : Test AudioProcessInClientInner API
2865 * @tc.type : FUNC
2866 * @tc.number: AudioProcessInClientInner_ConvertS32_013
2867 * @tc.desc : Test convert SAMPLE_S32LE CHANNEL_3 failed
2868 */
2869 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_ConvertS32_013, TestSize.Level1)
2870 {
2871 AudioStreamData srcData;
2872 srcData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S32LE, CHANNEL_3};
2873
2874 AudioStreamData dstData;
2875 dstData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S32LE, STEREO};
2876
2877 bool ret = AudioProcessInClientInner::ChannelFormatS32Convert(srcData, dstData);
2878 EXPECT_EQ(false, ret) << "CHANNEL_3 not supported";
2879 }
2880
2881 /**
2882 * @tc.name : Test AudioProcessInClientInner API
2883 * @tc.type : FUNC
2884 * @tc.number: AudioProcessInClientInner_ConvertS32_014
2885 * @tc.desc : Test convert SAMPLE_F32LE MONO failed
2886 */
2887 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_ConvertS32_014, TestSize.Level1)
2888 {
2889 AudioStreamData srcData;
2890 srcData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_F32LE, MONO};
2891
2892 AudioStreamData dstData;
2893 dstData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S32LE, STEREO};
2894
2895 srcData.bufferDesc.bufLength = NUMBER4;
2896 bool ret = AudioProcessInClientInner::ChannelFormatS32Convert(srcData, dstData);
2897 EXPECT_EQ(false, ret) << "bufLength failed";
2898
2899 dstData.bufferDesc.bufLength = NUMBER8;
2900 ret = AudioProcessInClientInner::ChannelFormatS32Convert(srcData, dstData);
2901 EXPECT_EQ(false, ret) << "srcDesc.buffer is nullptr should fail";
2902
2903 uint8_t srcArray[NUMBER4] = {0};
2904 srcData.bufferDesc = {srcArray, NUMBER4, NUMBER4};
2905 ret = AudioProcessInClientInner::ChannelFormatS32Convert(srcData, dstData);
2906 EXPECT_EQ(false, ret) << "dstDesc.buffer is nullptr should fail";
2907 }
2908
2909 /**
2910 * @tc.name : Test AudioProcessInClientInner API
2911 * @tc.type : FUNC
2912 * @tc.number: AudioProcessInClientInner_ConvertS32_015
2913 * @tc.desc : Test convert SAMPLE_F32LE STEREO
2914 */
2915 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_ConvertS32_015, TestSize.Level1)
2916 {
2917 AudioStreamData srcData;
2918 srcData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_F32LE, STEREO};
2919
2920 AudioStreamData dstData;
2921 dstData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S32LE, STEREO};
2922
2923 srcData.bufferDesc.bufLength = NUMBER8;
2924 bool ret = AudioProcessInClientInner::ChannelFormatS32Convert(srcData, dstData);
2925 EXPECT_EQ(false, ret) << "bufLength failed";
2926
2927 dstData.bufferDesc.bufLength = NUMBER8;
2928 ret = AudioProcessInClientInner::ChannelFormatS32Convert(srcData, dstData);
2929 EXPECT_EQ(false, ret) << "srcDesc.buffer is nullptr should fail";
2930
2931 uint8_t srcArray[NUMBER8] = {0};
2932 srcData.bufferDesc = {srcArray, NUMBER8, NUMBER8};
2933 ret = AudioProcessInClientInner::ChannelFormatS32Convert(srcData, dstData);
2934 EXPECT_EQ(false, ret) << "dstDesc.buffer is nullptr should fail";
2935 }
2936
2937 /**
2938 * @tc.name : Test AudioProcessInClientInner API
2939 * @tc.type : FUNC
2940 * @tc.number: AudioProcessInClientInner_WaitIfBufferEmpty_001
2941 * @tc.desc : Test AudioProcessInClientInner::WaitIfBufferEmpty
2942 */
2943 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_WaitIfBufferEmpty_001, TestSize.Level1)
2944 {
2945 AudioProcessConfig config = InitProcessConfig();
2946 AudioService *g_audioServicePtr = AudioService::GetInstance();
2947 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
2948 bool isVoipMmap = true;
2949 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
2950 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
2951
2952 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
2953
2954 BufferDesc bufDesc;
2955 bufDesc.buffer;
2956 bufDesc.dataLength = 0;
2957
2958 auto ret = ptrAudioProcessInClientInner->WaitIfBufferEmpty(bufDesc);
2959 EXPECT_EQ(ret, false);
2960 }
2961
2962 /**
2963 * @tc.name : Test AudioProcessInClientInner API
2964 * @tc.type : FUNC
2965 * @tc.number: AudioProcessInClientInner_WaitIfBufferEmpty_002
2966 * @tc.desc : Test AudioProcessInClientInner::WaitIfBufferEmpty
2967 */
2968 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_WaitIfBufferEmpty_002, TestSize.Level1)
2969 {
2970 AudioProcessConfig config = InitProcessConfig();
2971 AudioService *g_audioServicePtr = AudioService::GetInstance();
2972 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
2973 bool isVoipMmap = false;
2974 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
2975 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
2976
2977 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
2978
2979 BufferDesc bufDesc;
2980 bufDesc.buffer;
2981 bufDesc.dataLength = 0;
2982
2983 auto ret = ptrAudioProcessInClientInner->WaitIfBufferEmpty(bufDesc);
2984 EXPECT_EQ(ret, false);
2985 }
2986
2987 /**
2988 * @tc.name : Test AudioProcessInClientInner API
2989 * @tc.type : FUNC
2990 * @tc.number: AudioProcessInClientInner_WaitIfBufferEmpty_003
2991 * @tc.desc : Test AudioProcessInClientInner::WaitIfBufferEmpty
2992 */
2993 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_WaitIfBufferEmpty_003, TestSize.Level1)
2994 {
2995 AudioProcessConfig config = InitProcessConfig();
2996 AudioService *g_audioServicePtr = AudioService::GetInstance();
2997 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
2998 bool isVoipMmap = true;
2999 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
3000 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
3001
3002 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
3003
3004 BufferDesc bufDesc;
3005 bufDesc.buffer;
3006 // datalenth > 0
3007 bufDesc.dataLength = 1;
3008
3009 auto ret = ptrAudioProcessInClientInner->WaitIfBufferEmpty(bufDesc);
3010 EXPECT_EQ(ret, true);
3011 }
3012
3013 /**
3014 * @tc.name : Test AudioProcessInClientInner API
3015 * @tc.type : FUNC
3016 * @tc.number: AudioProcessInClientInner_WaitIfBufferEmpty_004
3017 * @tc.desc : Test AudioProcessInClientInner::WaitIfBufferEmpty
3018 */
3019 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_WaitIfBufferEmpty_004, TestSize.Level1)
3020 {
3021 AudioProcessConfig config = InitProcessConfig();
3022 AudioService *g_audioServicePtr = AudioService::GetInstance();
3023 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
3024 bool isVoipMmap = false;
3025 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
3026 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
3027
3028 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
3029
3030 BufferDesc bufDesc;
3031 bufDesc.buffer;
3032 // datalenth > 0
3033 bufDesc.dataLength = 1;
3034
3035 auto ret = ptrAudioProcessInClientInner->WaitIfBufferEmpty(bufDesc);
3036 EXPECT_EQ(ret, true);
3037 }
3038
3039 /**
3040 * @tc.name : Test AudioProcessInClientInner API
3041 * @tc.type : FUNC
3042 * @tc.number: AudioProcessInClientInner_GetAudioTime_002
3043 * @tc.desc : Test AudioProcessInClientInner::GetAudioTime
3044 */
3045 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_GetAudioTime_002, TestSize.Level1)
3046 {
3047 AudioProcessConfig config = InitProcessConfig();
3048 AudioService *g_audioServicePtr = AudioService::GetInstance();
3049 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
3050 bool isVoipMmap = true;
3051 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
3052 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
3053 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
3054
3055 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_CLIENT;
3056 uint32_t totalSizeInFrame = 0;
3057 uint32_t byteSizePerFrame = 0;
3058 ptrAudioProcessInClientInner->audioBuffer_ = std::make_shared<OHAudioBufferBase>(bufferHolder, totalSizeInFrame,
3059 byteSizePerFrame);
3060 ASSERT_TRUE(ptrAudioProcessInClientInner->audioBuffer_ != nullptr);
3061
3062 ptrAudioProcessInClientInner->audioBuffer_->basicBufferInfo_ = new BasicBufferInfo();
3063 auto ptrBufferInfo = ptrAudioProcessInClientInner->audioBuffer_->basicBufferInfo_;
3064 ASSERT_TRUE(ptrBufferInfo != nullptr);
3065
3066 auto ptrFastAudioStream = std::make_shared<FastAudioStream>(config.streamType,
3067 AUDIO_MODE_RECORD, config.appInfo.appUid);
3068 ptrAudioProcessInClientInner->Init(config, ptrFastAudioStream);
3069
3070 ptrBufferInfo->handlePos.store(0);
3071 ptrBufferInfo->handleTime.store(0);
3072
3073 uint32_t framePos = 0;
3074 int64_t sec = 0;
3075 int64_t nanoSec = 0;
3076 auto ret = ptrAudioProcessInClientInner->GetAudioTime(framePos, sec, nanoSec);
3077 EXPECT_EQ(ret, true);
3078 EXPECT_EQ(nanoSec, 0);
3079
3080 ptrBufferInfo->handleTime++;
3081 ptrAudioProcessInClientInner->GetAudioTime(framePos, sec, nanoSec);
3082 EXPECT_EQ(nanoSec, 1);
3083
3084 ptrBufferInfo->handlePos++;
3085 ptrAudioProcessInClientInner->GetAudioTime(framePos, sec, nanoSec);
3086 EXPECT_EQ(nanoSec, 1);
3087
3088 ptrBufferInfo->handleTime++;
3089 ptrAudioProcessInClientInner->GetAudioTime(framePos, sec, nanoSec);
3090 EXPECT_EQ(nanoSec, 1);
3091
3092 delete ptrBufferInfo;
3093 }
3094
3095 /**
3096 * @tc.name : Test AudioProcessInClientInner API
3097 * @tc.type : FUNC
3098 * @tc.number: AudioProcessInClientInner_ExitStandByIfNeed_001
3099 * @tc.desc : Test AudioProcessInClientInner::ExitStandByIfNeed
3100 */
3101 HWTEST(AudioProcessInClientUnitTest, AudioProcessInClientInner_ExitStandByIfNeed_001, TestSize.Level0)
3102 {
3103 AudioProcessConfig config = InitProcessConfig();
3104 AudioService *g_audioServicePtr = AudioService::GetInstance();
3105 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
3106 bool isVoipMmap = true;
3107 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
3108 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
3109 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
3110
3111 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_CLIENT;
3112 uint32_t totalSizeInFrame = 0;
3113 uint32_t byteSizePerFrame = 0;
3114 ptrAudioProcessInClientInner->audioBuffer_ = std::make_shared<OHAudioBufferBase>(bufferHolder, totalSizeInFrame,
3115 byteSizePerFrame);
3116 ASSERT_TRUE(ptrAudioProcessInClientInner->audioBuffer_ != nullptr);
3117
3118 ptrAudioProcessInClientInner->audioBuffer_->basicBufferInfo_ = new BasicBufferInfo();
3119 auto ptrBufferInfo = ptrAudioProcessInClientInner->audioBuffer_->basicBufferInfo_;
3120 ASSERT_TRUE(ptrBufferInfo != nullptr);
3121
3122 auto ptrFastAudioStream = std::make_shared<FastAudioStream>(config.streamType,
3123 AUDIO_MODE_RECORD, config.appInfo.appUid);
3124 ptrAudioProcessInClientInner->Init(config, ptrFastAudioStream);
3125
3126 ptrBufferInfo->handlePos.store(0);
3127 ptrBufferInfo->handleTime.store(0);
3128
3129 auto mockIAudioProcess = sptr<MockIAudioProcess>::MakeSptr();
3130 ptrAudioProcessInClientInner->processProxy_ = mockIAudioProcess;
3131 std::atomic<StreamStatus> streamStatus;
3132 streamStatus.store(StreamStatus::STREAM_STAND_BY);
3133 ptrAudioProcessInClientInner->streamStatus_ = &streamStatus;
3134
3135 EXPECT_CALL(*mockIAudioProcess, Start()).Times(1).WillOnce(Return(0));
3136 ptrAudioProcessInClientInner->ExitStandByIfNeed();
3137
3138 delete ptrBufferInfo;
3139 }
3140
3141 /**
3142 * @tc.name : Test CallClientHandleCurrent API
3143 * @tc.type : FUNC
3144 * @tc.number: CallClientHandleCurrent_001
3145 * @tc.desc : Test CallClientHandleCurrent
3146 */
3147 HWTEST(AudioProcessInClientUnitTest, CallClientHandleCurrent_001, TestSize.Level1)
3148 {
3149 AudioProcessConfig config = InitProcessConfig();
3150 AudioService *g_audioServicePtr = AudioService::GetInstance();
3151 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
3152 bool isVoipMmap = true;
3153 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
3154 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
3155 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
3156 ptrAudioProcessInClientInner->CallClientHandleCurrent();
3157 }
3158
3159 /**
3160 * @tc.name : Test IsRestoreNeeded API
3161 * @tc.type : FUNC
3162 * @tc.number: IsRestoreNeeded_001
3163 * @tc.desc : Test IsRestoreNeeded
3164 */
3165 HWTEST(AudioProcessInClientUnitTest, IsRestoreNeeded_001, TestSize.Level1)
3166 {
3167 AudioProcessConfig config = InitProcessConfig();
3168 AudioService *g_audioServicePtr = AudioService::GetInstance();
3169 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
3170 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
3171 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, true, info);
3172 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
3173
3174 std::atomic<StreamStatus> streamStatus;
3175 streamStatus.store(StreamStatus::STREAM_RUNNING);
3176 ptrAudioProcessInClientInner->streamStatus_ = &streamStatus;
3177
3178 // totalsize is 100, byteSizePerFrame is 1
3179 ptrAudioProcessInClientInner->audioBuffer_ = OHAudioBufferBase::CreateFromLocal(100, 1);
3180 ptrAudioProcessInClientInner->audioBuffer_->basicBufferInfo_->restoreStatus.store(NO_NEED_FOR_RESTORE);
3181 EXPECT_EQ(ptrAudioProcessInClientInner->IsRestoreNeeded(), false);
3182
3183 ptrAudioProcessInClientInner->audioBuffer_->basicBufferInfo_->restoreStatus.store(NEED_RESTORE);
3184 EXPECT_EQ(ptrAudioProcessInClientInner->CheckAndWaitBufferReadyForRecord(), true);
3185 EXPECT_EQ(ptrAudioProcessInClientInner->CheckAndWaitBufferReadyForPlayback(), true);
3186 EXPECT_EQ(ptrAudioProcessInClientInner->IsRestoreNeeded(), true);
3187
3188 ptrAudioProcessInClientInner->audioBuffer_->basicBufferInfo_->restoreStatus.store(NEED_RESTORE_TO_NORMAL);
3189 EXPECT_EQ(ptrAudioProcessInClientInner->CheckAndWaitBufferReadyForRecord(), true);
3190 EXPECT_EQ(ptrAudioProcessInClientInner->CheckAndWaitBufferReadyForPlayback(), true);
3191 EXPECT_EQ(ptrAudioProcessInClientInner->IsRestoreNeeded(), true);
3192 }
3193 } // namespace AudioStandard
3194 } // namespace OHOS
3195