1 /*
2 * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include "audio_process_in_server.h"
18 #include "audio_errors.h"
19 #include "audio_service.h"
20 #include "audio_device_info.h"
21
22 using namespace testing::ext;
23
24 namespace OHOS {
25 namespace AudioStandard {
26 constexpr int32_t DEFAULT_STREAM_ID = 10;
27 const uint32_t SPAN_SIZE_IN_FRAME = 1000;
28 const uint32_t TOTAL_SIZE_IN_FRAME = 1000;
29 const int32_t INTELL_VOICE_SERVICR_UID = 1042;
30 constexpr uint32_t MIN_STREAMID_2 = UINT32_MAX - MIN_STREAMID + DEFAULT_STREAM_ID;
31 constexpr uint32_t MIN_STREAMID_3 = UINT32_MAX - MIN_STREAMID - DEFAULT_STREAM_ID;
32 class AudioProcessInServerUnitTest : public testing::Test {
33 public:
34 static void SetUpTestCase(void);
35 static void TearDownTestCase(void);
36 void SetUp();
37 void TearDown();
38 };
39
SetUpTestCase(void)40 void AudioProcessInServerUnitTest::SetUpTestCase(void)
41 {
42 // input testsuit setup step，setup invoked before all testcases
43 }
44
TearDownTestCase(void)45 void AudioProcessInServerUnitTest::TearDownTestCase(void)
46 {
47 // input testsuit teardown step，teardown invoked after all testcases
48 }
49
SetUp(void)50 void AudioProcessInServerUnitTest::SetUp(void)
51 {
52 // input testcase setup step，setup invoked before each testcases
53 }
54
TearDown(void)55 void AudioProcessInServerUnitTest::TearDown(void)
56 {
57 // input testcase teardown step，teardown invoked after each testcases
58 }
59
60 AudioStreamInfo g_audioStreamInfo = {
61 SAMPLE_RATE_48000,
62 ENCODING_PCM,
63 SAMPLE_S16LE,
64 STEREO,
65 CH_LAYOUT_STEREO
66 };
67
InitProcessConfig()68 static AudioProcessConfig InitProcessConfig()
69 {
70 AudioProcessConfig config;
71 config.appInfo.appFullTokenId = 1;
72 config.appInfo.appTokenId = 1;
73 config.appInfo.appUid = DEFAULT_STREAM_ID;
74 config.appInfo.appPid = DEFAULT_STREAM_ID;
75 config.streamInfo.format = SAMPLE_S32LE;
76 config.streamInfo.samplingRate = SAMPLE_RATE_48000;
77 config.streamInfo.channels = STEREO;
78 config.streamInfo.channelLayout = AudioChannelLayout::CH_LAYOUT_STEREO;
79 config.audioMode = AudioMode::AUDIO_MODE_RECORD;
80 config.streamType = AudioStreamType::STREAM_MUSIC;
81 config.deviceType = DEVICE_TYPE_USB_HEADSET;
82 return config;
83 }
84
85 /**
86 * @tc.name : Test AudioProcessInServer API
87 * @tc.type : FUNC
88 * @tc.number: AudioProcessInServer_001
89 * @tc.desc : Test AudioProcessInServer interface.
90 */
91 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_001, TestSize.Level1)
92 {
93 AudioProcessConfig configRet = InitProcessConfig();
94 AudioService *releaseCallbackRet = AudioService::GetInstance();
95 sptr<AudioProcessInServer> audioProcessInServer = AudioProcessInServer::Create(configRet, releaseCallbackRet);
96 uint32_t sessionIdRet = 0;
97 bool muteFlagRet = true;
98 auto ret = audioProcessInServer->GetSessionId(sessionIdRet);
99 EXPECT_EQ(ret, SUCCESS);
100 EXPECT_EQ(audioProcessInServer->GetSessionId(), sessionIdRet);
101 ret = audioProcessInServer->GetMuteState();
102 EXPECT_EQ(ret, false);
103 audioProcessInServer->SetNonInterruptMute(muteFlagRet);
104 EXPECT_EQ(audioProcessInServer->GetMuteState(), true);
105 }
106
107 /**
108 * @tc.name : Test AudioProcessInServer API
109 * @tc.type : FUNC
110 * @tc.number: AudioProcessInServer_002
111 * @tc.desc : Test AudioProcessInServer interface.
112 */
113 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_002, TestSize.Level1)
114 {
115 AudioProcessConfig configRet = InitProcessConfig();
116 AudioService *releaseCallbackRet = AudioService::GetInstance();
117 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
118 std::shared_ptr<OHAudioBufferBase> bufferRet = nullptr;
119 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_SERVER_SHARED;
120 uint32_t byteSizePerFrame = 1000;
121 EXPECT_EQ(audioProcessInServerRet.processBuffer_, nullptr);
122 uint32_t spanSizeInFrame;
123 audioProcessInServerRet.ResolveBufferBaseAndGetServerSpanSize(
124 bufferRet, spanSizeInFrame);
125 audioProcessInServerRet.processBuffer_ = std::make_shared<OHAudioBufferBase>(
126 bufferHolder, TOTAL_SIZE_IN_FRAME, byteSizePerFrame);
127 EXPECT_NE(audioProcessInServerRet.processBuffer_, nullptr);
128 auto ret = audioProcessInServerRet.ResolveBufferBaseAndGetServerSpanSize(
129 bufferRet, spanSizeInFrame);
130 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
131 }
132
133 /**
134 * @tc.name : Test AudioProcessInServer API
135 * @tc.type : FUNC
136 * @tc.number: AudioProcessInServer_003
137 * @tc.desc : Test AudioProcessInServer interface.
138 */
139 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_003, TestSize.Level1)
140 {
141 AudioProcessConfig configRet = InitProcessConfig();
142 AudioService *releaseCallbackRet = AudioService::GetInstance();
143 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
144 audioProcessInServerRet.isInited_ = true;
145 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_SERVER_SHARED;
146 uint32_t byteSizePerFrame = 1000;
147 audioProcessInServerRet.processBuffer_ = std::make_shared<OHAudioBufferBase>(bufferHolder,
148 TOTAL_SIZE_IN_FRAME, byteSizePerFrame);
149 EXPECT_NE(audioProcessInServerRet.processBuffer_, nullptr);
150 auto ret = audioProcessInServerRet.RequestHandleInfo();
151 EXPECT_EQ(ret, SUCCESS);
152 }
153
154 /**
155 * @tc.name : Test AudioProcessInServer API
156 * @tc.type : FUNC
157 * @tc.number: AudioProcessInServer_004
158 * @tc.desc : Test AudioProcessInServer interface.
159 */
160 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_004, TestSize.Level1)
161 {
162 AudioProcessConfig configRet = InitProcessConfig();
163 AudioService *releaseCallbackRet = AudioService::GetInstance();
164 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
165 std::shared_ptr<OHAudioBufferBase> buffer = nullptr;
166 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
167 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
168
169 EXPECT_EQ(audioProcessInServerRet.processBuffer_, nullptr);
170 auto ret = audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
171 spanSizeInFrame, g_audioStreamInfo, buffer);
172 EXPECT_EQ(ret, SUCCESS);
173 }
174
175 /**
176 * @tc.name : Test AudioProcessInServer API
177 * @tc.type : FUNC
178 * @tc.number: AudioProcessInServer_005
179 * @tc.desc : Test AudioProcessInServer interface.
180 */
181 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_005, TestSize.Level1)
182 {
183 AudioProcessConfig configRet = InitProcessConfig();
184 configRet.streamInfo.format = SAMPLE_U8;
185 AudioService *releaseCallbackRet = AudioService::GetInstance();
186 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
187 std::shared_ptr<OHAudioBufferBase> buffer = nullptr;
188 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
189 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
190
191 EXPECT_EQ(audioProcessInServerRet.processBuffer_, nullptr);
192 auto ret = audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
193 spanSizeInFrame, g_audioStreamInfo, buffer);
194 EXPECT_EQ(ret, SUCCESS);
195 }
196
197 /**
198 * @tc.name : Test AudioProcessInServer API
199 * @tc.type : FUNC
200 * @tc.number: AudioProcessInServer_006
201 * @tc.desc : Test AudioProcessInServer interface.
202 */
203 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_006, TestSize.Level1)
204 {
205 AudioProcessConfig configRet = InitProcessConfig();
206 configRet.streamInfo.format = SAMPLE_S16LE;
207 AudioService *releaseCallbackRet = AudioService::GetInstance();
208 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
209 std::shared_ptr<OHAudioBufferBase> buffer = nullptr;
210 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
211 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
212
213 EXPECT_EQ(audioProcessInServerRet.processBuffer_, nullptr);
214 auto ret = audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
215 spanSizeInFrame, g_audioStreamInfo, buffer);
216 EXPECT_EQ(ret, SUCCESS);
217 }
218
219 /**
220 * @tc.name : Test AudioProcessInServer API
221 * @tc.type : FUNC
222 * @tc.number: AudioProcessInServer_007
223 * @tc.desc : Test AudioProcessInServer interface.
224 */
225 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_007, TestSize.Level1)
226 {
227 AudioProcessConfig configRet = InitProcessConfig();
228 configRet.streamInfo.format = SAMPLE_S24LE;
229 AudioService *releaseCallbackRet = AudioService::GetInstance();
230 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
231 std::shared_ptr<OHAudioBufferBase> buffer = nullptr;
232 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
233 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
234
235 EXPECT_EQ(audioProcessInServerRet.processBuffer_, nullptr);
236 auto ret = audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
237 spanSizeInFrame, g_audioStreamInfo, buffer);
238 EXPECT_EQ(ret, SUCCESS);
239 }
240
241 /**
242 * @tc.name : Test AudioProcessInServer API
243 * @tc.type : FUNC
244 * @tc.number: AudioProcessInServer_008
245 * @tc.desc : Test AudioProcessInServer interface.
246 */
247 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_008, TestSize.Level1)
248 {
249 AudioProcessConfig configRet = InitProcessConfig();
250 configRet.streamInfo.format = SAMPLE_F32LE;
251 AudioService *releaseCallbackRet = AudioService::GetInstance();
252 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
253 std::shared_ptr<OHAudioBufferBase> buffer = nullptr;
254 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
255 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
256
257 EXPECT_EQ(audioProcessInServerRet.processBuffer_, nullptr);
258 auto ret = audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
259 spanSizeInFrame, g_audioStreamInfo, buffer);
260 EXPECT_EQ(ret, SUCCESS);
261 }
262
263 /**
264 * @tc.name : Test AudioProcessInServer API
265 * @tc.type : FUNC
266 * @tc.number: AudioProcessInServer_009
267 * @tc.desc : Test AudioProcessInServer interface.
268 */
269 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_009, TestSize.Level1)
270 {
271 AudioProcessConfig configRet = InitProcessConfig();
272 configRet.streamInfo.format = INVALID_WIDTH;
273 AudioService *releaseCallbackRet = AudioService::GetInstance();
274 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
275 std::shared_ptr<OHAudioBufferBase> buffer = nullptr;
276 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
277 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
278
279 EXPECT_EQ(audioProcessInServerRet.processBuffer_, nullptr);
280 auto ret = audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
281 spanSizeInFrame, g_audioStreamInfo, buffer);
282 EXPECT_EQ(ret, SUCCESS);
283 }
284
285 // /**
286 // * @tc.name : Test AudioProcessInServer API
287 // * @tc.type : FUNC
288 // * @tc.number: AudioProcessInServer_010
289 // * @tc.desc : Test AudioProcessInServer interface.
290 // */
291 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_010, TestSize.Level1)
292 {
293 AudioProcessConfig configRet = InitProcessConfig();
294 AudioService *releaseCallbackRet = AudioService::GetInstance();
295 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
296 audioProcessInServerRet.isInited_ = true;
297 std::shared_ptr<OHAudioBufferBase> buffer = nullptr;
298 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
299 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
300 audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
301 spanSizeInFrame, g_audioStreamInfo, buffer);
302
303 audioProcessInServerRet.streamStatus_->store(STREAM_STAND_BY);
304 EXPECT_EQ(audioProcessInServerRet.streamStatus_->load(), STREAM_STAND_BY);
305
306 auto ret = audioProcessInServerRet.Start();
307 EXPECT_NE(ret, SUCCESS);
308 }
309
310 // /**
311 // * @tc.name : Test AudioProcessInServer API
312 // * @tc.type : FUNC
313 // * @tc.number: AudioProcessInServer_011
314 // * @tc.desc : Test AudioProcessInServer interface.
315 // */
316 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_011, TestSize.Level1)
317 {
318 AudioProcessConfig configRet = InitProcessConfig();
319 AudioService *releaseCallbackRet = AudioService::GetInstance();
320 configRet.audioMode = AUDIO_MODE_PLAYBACK;
321 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
322 audioProcessInServerRet.isInited_ = true;
323 std::shared_ptr<OHAudioBufferBase> buffer = nullptr;
324 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
325 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
326 audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
327 spanSizeInFrame, g_audioStreamInfo, buffer);
328
329 audioProcessInServerRet.streamStatus_->store(STREAM_STAND_BY);
330 EXPECT_EQ(audioProcessInServerRet.streamStatus_->load(), STREAM_STAND_BY);
331 EXPECT_EQ(audioProcessInServerRet.needCheckBackground_, false);
332 auto ret = audioProcessInServerRet.Start();
333 EXPECT_EQ(audioProcessInServerRet.needCheckBackground_, false);
334 EXPECT_NE(ret, SUCCESS);
335
336 audioProcessInServerRet.needCheckBackground_ = true;
337 ret = audioProcessInServerRet.Start();
338 EXPECT_NE(ret, SUCCESS);
339 }
340
341 /**
342 * @tc.name : Test AudioProcessInServer API
343 * @tc.type : FUNC
344 * @tc.number: AudioProcessInServer_012
345 * @tc.desc : Test AudioProcessInServer interface.
346 */
347 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_012, TestSize.Level1)
348 {
349 AudioProcessConfig configRet = InitProcessConfig();
350 AudioService *releaseCallbackRet = AudioService::GetInstance();
351 configRet.callerUid = INTELL_VOICE_SERVICR_UID;
352 configRet.audioMode = AUDIO_MODE_PLAYBACK;
353 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
354 audioProcessInServerRet.isInited_ = true;
355 std::shared_ptr<OHAudioBufferBase> buffer = nullptr;
356 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
357 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
358 audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
359 spanSizeInFrame, g_audioStreamInfo, buffer);
360
361 audioProcessInServerRet.streamStatus_->store(STREAM_STARTING);
362 EXPECT_EQ(audioProcessInServerRet.streamStatus_->load(), STREAM_STARTING);
363 EXPECT_EQ(audioProcessInServerRet.needCheckBackground_, false);
364 auto ret = audioProcessInServerRet.Start();
365 EXPECT_EQ(audioProcessInServerRet.needCheckBackground_, false);
366 EXPECT_NE(ret, SUCCESS);
367
368 audioProcessInServerRet.needCheckBackground_ = true;
369 ret = audioProcessInServerRet.Start();
370 EXPECT_NE(ret, SUCCESS);
371 }
372
373 /**
374 * @tc.name : Test AudioProcessInServer API
375 * @tc.type : FUNC
376 * @tc.number: AudioProcessInServer_013
377 * @tc.desc : Test AudioProcessInServer interface.
378 */
379 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_013, TestSize.Level1)
380 {
381 AudioProcessConfig configRet = InitProcessConfig();
382 AudioService *releaseCallbackRet = AudioService::GetInstance();
383 configRet.callerUid = INTELL_VOICE_SERVICR_UID;
384 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
385 audioProcessInServerRet.isInited_ = true;
386 std::shared_ptr<OHAudioBufferBase> buffer = nullptr;
387 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
388 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
389 audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
390 spanSizeInFrame, g_audioStreamInfo, buffer);
391
392 audioProcessInServerRet.streamStatus_->store(STREAM_STARTING);
393 EXPECT_EQ(audioProcessInServerRet.streamStatus_->load(), STREAM_STARTING);
394 auto ret = audioProcessInServerRet.Start();
395 EXPECT_NE(ret, SUCCESS);
396
397 audioProcessInServerRet.needCheckBackground_ = true;
398 ret = audioProcessInServerRet.Start();
399 EXPECT_NE(ret, SUCCESS);
400 }
401
402 /**
403 * @tc.name : Test AudioProcessInServer API
404 * @tc.type : FUNC
405 * @tc.number: AudioProcessInServer_014
406 * @tc.desc : Test AudioProcessInServer interface.
407 */
408 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_014, TestSize.Level1)
409 {
410 AudioProcessConfig configRet = InitProcessConfig();
411 AudioService *releaseCallbackRet = AudioService::GetInstance();
412 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
413 audioProcessInServerRet.isInited_ = true;
414 audioProcessInServerRet.needCheckBackground_ = true;
415 std::shared_ptr<OHAudioBufferBase> buffer = nullptr;
416 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
417 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
418 audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
419 spanSizeInFrame, g_audioStreamInfo, buffer);
420 audioProcessInServerRet.streamStatus_->store(STREAM_PAUSING);
421 bool isFlush = true;
422
423 auto ret = audioProcessInServerRet.Pause(isFlush);
424 EXPECT_EQ(ret, SUCCESS);
425
426 audioProcessInServerRet.needCheckBackground_ = false;
427 ret = audioProcessInServerRet.Pause(isFlush);
428 EXPECT_EQ(ret, SUCCESS);
429 }
430
431 /**
432 * @tc.name : Test AudioProcessInServer API
433 * @tc.type : FUNC
434 * @tc.number: AudioProcessInServer_015
435 * @tc.desc : Test AudioProcessInServer interface.
436 */
437 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_015, TestSize.Level1)
438 {
439 AudioProcessConfig configRet = InitProcessConfig();
440 AudioService *releaseCallbackRet = AudioService::GetInstance();
441 configRet.audioMode = AUDIO_MODE_PLAYBACK;
442 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
443 audioProcessInServerRet.isInited_ = true;
444 std::shared_ptr<OHAudioBufferBase> buffer = nullptr;
445 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
446 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
447 audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
448 spanSizeInFrame, g_audioStreamInfo, buffer);
449 audioProcessInServerRet.streamStatus_->store(STREAM_PAUSING);
450 bool isFlush = true;
451
452 auto ret = audioProcessInServerRet.Pause(isFlush);
453 EXPECT_EQ(ret, SUCCESS);
454
455 audioProcessInServerRet.needCheckBackground_ = true;
456 ret = audioProcessInServerRet.Pause(isFlush);
457 EXPECT_EQ(ret, SUCCESS);
458 }
459
460 // /**
461 // * @tc.name : Test AudioProcessInServer API
462 // * @tc.type : FUNC
463 // * @tc.number: AudioProcessInServer_016
464 // * @tc.desc : Test AudioProcessInServer interface.
465 // */
466 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_016, TestSize.Level1)
467 {
468 AudioProcessConfig configRet = InitProcessConfig();
469 AudioService *releaseCallbackRet = AudioService::GetInstance();
470 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
471 audioProcessInServerRet.isInited_ = true;
472 std::shared_ptr<OHAudioBufferBase> buffer = nullptr;
473 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
474 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
475 audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
476 spanSizeInFrame, g_audioStreamInfo, buffer);
477
478 audioProcessInServerRet.streamStatus_->store(STREAM_STARTING);
479 EXPECT_EQ(audioProcessInServerRet.streamStatus_->load(), STREAM_STARTING);
480
481 auto ret = audioProcessInServerRet.Resume();
482 EXPECT_NE(ret, SUCCESS);
483 }
484
485 // /**
486 // * @tc.name : Test AudioProcessInServer API
487 // * @tc.type : FUNC
488 // * @tc.number: AudioProcessInServer_017
489 // * @tc.desc : Test AudioProcessInServer interface.
490 // */
491 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_017, TestSize.Level1)
492 {
493 AudioProcessConfig configRet = InitProcessConfig();
494 AudioService *releaseCallbackRet = AudioService::GetInstance();
495 configRet.audioMode = AUDIO_MODE_PLAYBACK;
496 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
497 audioProcessInServerRet.isInited_ = true;
498 std::shared_ptr<OHAudioBufferBase> buffer = nullptr;
499 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
500 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
501 audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
502 spanSizeInFrame, g_audioStreamInfo, buffer);
503
504 audioProcessInServerRet.streamStatus_->store(STREAM_STARTING);
505 EXPECT_EQ(audioProcessInServerRet.streamStatus_->load(), STREAM_STARTING);
506 auto ret = audioProcessInServerRet.Resume();
507 EXPECT_EQ(ret, SUCCESS);
508
509 audioProcessInServerRet.needCheckBackground_ = true;
510 ret = audioProcessInServerRet.Resume();
511 EXPECT_EQ(ret, SUCCESS);
512 }
513
514 /**
515 * @tc.name : Test AudioProcessInServer API
516 * @tc.type : FUNC
517 * @tc.number: AudioProcessInServer_018
518 * @tc.desc : Test AudioProcessInServer interface.
519 */
520 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_018, TestSize.Level1)
521 {
522 AudioProcessConfig configRet = InitProcessConfig();
523 AudioService *releaseCallbackRet = AudioService::GetInstance();
524 configRet.callerUid = INTELL_VOICE_SERVICR_UID;
525 configRet.audioMode = AUDIO_MODE_PLAYBACK;
526 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
527 audioProcessInServerRet.isInited_ = true;
528 std::shared_ptr<OHAudioBufferBase> buffer = nullptr;
529 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
530 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
531 audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
532 spanSizeInFrame, g_audioStreamInfo, buffer);
533
534 audioProcessInServerRet.streamStatus_->store(STREAM_STARTING);
535 EXPECT_EQ(audioProcessInServerRet.streamStatus_->load(), STREAM_STARTING);
536 EXPECT_EQ(audioProcessInServerRet.needCheckBackground_, false);
537 auto ret = audioProcessInServerRet.Resume();
538 EXPECT_EQ(audioProcessInServerRet.needCheckBackground_, false);
539 EXPECT_EQ(ret, SUCCESS);
540
541 audioProcessInServerRet.needCheckBackground_ = true;
542 ret = audioProcessInServerRet.Resume();
543 EXPECT_EQ(ret, SUCCESS);
544 }
545
546 /**
547 * @tc.name : Test AudioProcessInServer API
548 * @tc.type : FUNC
549 * @tc.number: AudioProcessInServer_019
550 * @tc.desc : Test AudioProcessInServer interface.
551 */
552 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_019, TestSize.Level1)
553 {
554 AudioProcessConfig configRet = InitProcessConfig();
555 AudioService *releaseCallbackRet = AudioService::GetInstance();
556 configRet.callerUid = INTELL_VOICE_SERVICR_UID;
557 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
558 audioProcessInServerRet.isInited_ = true;
559 std::shared_ptr<OHAudioBufferBase> buffer = nullptr;
560 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
561 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
562 audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
563 spanSizeInFrame, g_audioStreamInfo, buffer);
564
565 audioProcessInServerRet.streamStatus_->store(STREAM_STARTING);
566 EXPECT_EQ(audioProcessInServerRet.streamStatus_->load(), STREAM_STARTING);
567 auto ret = audioProcessInServerRet.Resume();
568 EXPECT_EQ(ret, SUCCESS);
569
570 audioProcessInServerRet.needCheckBackground_ = true;
571 ret = audioProcessInServerRet.Resume();
572 EXPECT_NE(ret, SUCCESS);
573 }
574
575 /**
576 * @tc.name : Test AudioProcessInServer API
577 * @tc.type : FUNC
578 * @tc.number: AudioProcessInServer_020
579 * @tc.desc : Test AudioProcessInServer interface.
580 */
581 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_020, TestSize.Level1)
582 {
583 AudioProcessConfig configRet = InitProcessConfig();
584 AudioService *releaseCallbackRet = AudioService::GetInstance();
585 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
586 audioProcessInServerRet.isInited_ = true;
587 audioProcessInServerRet.needCheckBackground_ = true;
588 std::shared_ptr<OHAudioBufferBase> buffer = nullptr;
589 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
590 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
591 audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
592 spanSizeInFrame, g_audioStreamInfo, buffer);
593 audioProcessInServerRet.streamStatus_->store(STREAM_STOPPING);
594
595 int32_t ret = 0;
596 audioProcessInServerRet.Stop(ret);
597 EXPECT_EQ(ret, SUCCESS);
598
599 audioProcessInServerRet.needCheckBackground_ = false;
600 audioProcessInServerRet.Stop(ret);
601 EXPECT_EQ(ret, SUCCESS);
602 }
603
604 /**
605 * @tc.name : Test AudioProcessInServer API
606 * @tc.type : FUNC
607 * @tc.number: AudioProcessInServer_021
608 * @tc.desc : Test AudioProcessInServer interface.
609 */
610 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_021, TestSize.Level1)
611 {
612 AudioProcessConfig configRet = InitProcessConfig();
613 AudioService *releaseCallbackRet = AudioService::GetInstance();
614 configRet.audioMode = AUDIO_MODE_PLAYBACK;
615 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
616 audioProcessInServerRet.isInited_ = true;
617 std::shared_ptr<OHAudioBufferBase> buffer = nullptr;
618 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
619 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
620 audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
621 spanSizeInFrame, g_audioStreamInfo, buffer);
622 audioProcessInServerRet.streamStatus_->store(STREAM_STOPPING);
623
624 int32_t ret = 0;
625 audioProcessInServerRet.Stop(ret);
626 EXPECT_EQ(ret, SUCCESS);
627
628 audioProcessInServerRet.needCheckBackground_ = true;
629 audioProcessInServerRet.Stop(ret);
630 EXPECT_EQ(ret, SUCCESS);
631 }
632
633 /**
634 * @tc.name : Test AudioProcessInServer API
635 * @tc.type : FUNC
636 * @tc.number: AudioProcessInServer_022
637 * @tc.desc : Test AudioProcessInServer interface.
638 */
639 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_022, TestSize.Level1)
640 {
641 AudioProcessConfig configRet = InitProcessConfig();
642 AudioService *releaseCallbackRet = AudioService::GetInstance();
643 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
644 audioProcessInServerRet.isInited_ = true;
645 audioProcessInServerRet.needCheckBackground_ = true;
646 std::shared_ptr<OHAudioBufferBase> buffer = nullptr;
647 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
648 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
649 audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
650 spanSizeInFrame, g_audioStreamInfo, buffer);
651 audioProcessInServerRet.streamStatus_->store(STREAM_STOPPING);
652 bool isSwitchStream = false;
653
654 EXPECT_NE(audioProcessInServerRet.releaseCallback_, nullptr);
655 auto ret = audioProcessInServerRet.Release(isSwitchStream);
656 EXPECT_NE(ret, SUCCESS);
657
658 audioProcessInServerRet.isInited_ = true;
659 audioProcessInServerRet.needCheckBackground_ = false;
660 ret = audioProcessInServerRet.Release(isSwitchStream);
661 EXPECT_NE(ret, SUCCESS);
662 }
663
664 /**
665 * @tc.name : Test AudioProcessInServer API
666 * @tc.type : FUNC
667 * @tc.number: AudioProcessInServer_023
668 * @tc.desc : Test AudioProcessInServer interface.
669 */
670 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_023, TestSize.Level1)
671 {
672 AudioProcessConfig configRet = InitProcessConfig();
673 AudioService *releaseCallbackRet = AudioService::GetInstance();
674 configRet.audioMode = AUDIO_MODE_PLAYBACK;
675 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
676 audioProcessInServerRet.isInited_ = true;
677 std::shared_ptr<OHAudioBufferBase> buffer = nullptr;
678 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
679 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
680 audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
681 spanSizeInFrame, g_audioStreamInfo, buffer);
682 audioProcessInServerRet.streamStatus_->store(STREAM_STOPPING);
683 bool isSwitchStream = false;
684
685 auto ret = audioProcessInServerRet.Release(isSwitchStream);
686 EXPECT_NE(ret, SUCCESS);
687
688 audioProcessInServerRet.isInited_ = true;
689 audioProcessInServerRet.needCheckBackground_ = true;
690 ret = audioProcessInServerRet.Release(isSwitchStream);
691 EXPECT_NE(ret, SUCCESS);
692 }
693
694 /**
695 * @tc.name : Test AudioProcessInServer API
696 * @tc.type : FUNC
697 * @tc.number: AudioProcessInServer_024
698 * @tc.desc : Test AudioProcessInServer interface.
699 */
700 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_024, TestSize.Level1)
701 {
702 AudioProcessConfig configRet = InitProcessConfig();
703 AudioService *releaseCallbackRet = AudioService::GetInstance();
704 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
705 std::string dumpStringRet1;
706
707 EXPECT_EQ(audioProcessInServerRet.streamStatus_, nullptr);
708 audioProcessInServerRet.Dump(dumpStringRet1);
709
710 audioProcessInServerRet.isInited_ = true;
711 std::shared_ptr<OHAudioBufferBase> buffer = nullptr;
712 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
713 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
714 audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
715 spanSizeInFrame, g_audioStreamInfo, buffer);
716 audioProcessInServerRet.streamStatus_->store(STREAM_STOPPING);
717 std::string dumpStringRet2;
718
719 EXPECT_NE(audioProcessInServerRet.streamStatus_, nullptr);
720 audioProcessInServerRet.Dump(dumpStringRet2);
721 }
722
723 /**
724 * @tc.name : Test AudioProcessInServer API
725 * @tc.type : FUNC
726 * @tc.number: AudioProcessInServer_025
727 * @tc.desc : Test AudioProcessInServer interface.
728 */
729 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_025, TestSize.Level1)
730 {
731 AudioProcessConfig configRet = InitProcessConfig();
732 AudioService *releaseCallbackRet = AudioService::GetInstance();
733 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
734 std::string name = "unit_test";
735 auto ret = audioProcessInServerRet.RegisterThreadPriority(0, name, METHOD_WRITE_OR_READ);
736 EXPECT_EQ(ret, SUCCESS);
737 }
738 /**
739 * @tc.name : Test AudioProcessInServer API
740 * @tc.type : FUNC
741 * @tc.number: AudioProcessInServer_026
742 * @tc.desc : Test AudioProcessInServer interface.
743 */
744 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_026, TestSize.Level1)
745 {
746 AudioProcessConfig configRet = InitProcessConfig();
747 AudioService *releaseCallbackRet = AudioService::GetInstance();
748
749 configRet.originalSessionId = DEFAULT_STREAM_ID;
750 auto audioProcessInServer = std::make_shared<AudioProcessInServer>(configRet, releaseCallbackRet);
751 EXPECT_NE(audioProcessInServer, nullptr);
752 }
753
754 /**
755 * @tc.name : Test AudioProcessInServer API
756 * @tc.type : FUNC
757 * @tc.number: AudioProcessInServer_027
758 * @tc.desc : Test AudioProcessInServer interface.
759 */
760 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_027, TestSize.Level1)
761 {
762 AudioProcessConfig configRet = InitProcessConfig();
763 AudioService *releaseCallbackRet = AudioService::GetInstance();
764
765 configRet.originalSessionId = MIN_STREAMID_2;
766 auto audioProcessInServer = std::make_shared<AudioProcessInServer>(configRet, releaseCallbackRet);
767 EXPECT_NE(audioProcessInServer, nullptr);
768 }
769
770 /**
771 * @tc.name : Test AudioProcessInServer API
772 * @tc.type : FUNC
773 * @tc.number: AudioProcessInServer_028
774 * @tc.desc : Test AudioProcessInServer interface.
775 */
776 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_028, TestSize.Level1)
777 {
778 AudioProcessConfig configRet = InitProcessConfig();
779 AudioService *releaseCallbackRet = AudioService::GetInstance();
780
781 configRet.originalSessionId = MIN_STREAMID_3;
782 auto audioProcessInServer = std::make_shared<AudioProcessInServer>(configRet, releaseCallbackRet);
783 EXPECT_NE(audioProcessInServer, nullptr);
784 }
785
786 /**
787 * @tc.name : Test AudioProcessInServer API
788 * @tc.type : FUNC
789 * @tc.number: AudioProcessInServer_029
790 * @tc.desc : Test AudioProcessInServer interface.
791 */
792 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_029, TestSize.Level1)
793 {
794 AudioProcessConfig configRet = InitProcessConfig();
795 AudioService *releaseCallbackRet = AudioService::GetInstance();
796
797 auto audioProcessInServer = std::make_shared<AudioProcessInServer>(configRet, releaseCallbackRet);
798
799 bool isStandby = true;
800 int64_t enterStandbyTime = 0;
801
802 audioProcessInServer->processBuffer_ = nullptr;
803 auto ret = audioProcessInServer->GetStandbyStatus(isStandby, enterStandbyTime);
804 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
805 }
806
807 /**
808 * @tc.name : Test AudioProcessInServer API
809 * @tc.type : FUNC
810 * @tc.number: AudioProcessInServer_030
811 * @tc.desc : Test AudioProcessInServer interface.
812 */
813 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_030, TestSize.Level1)
814 {
815 AudioProcessConfig configRet = InitProcessConfig();
816 AudioService *releaseCallbackRet = AudioService::GetInstance();
817
818 auto audioProcessInServer = std::make_shared<AudioProcessInServer>(configRet, releaseCallbackRet);
819
820 bool isStandby = true;
821 int64_t enterStandbyTime = 0;
822
823 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_SERVER_SHARED;
824 uint32_t byteSizePerFrame = SPAN_SIZE_IN_FRAME;
825 audioProcessInServer->processBuffer_ = std::make_shared<OHAudioBufferBase>(
826 bufferHolder, TOTAL_SIZE_IN_FRAME, byteSizePerFrame);
827 EXPECT_NE(audioProcessInServer->processBuffer_, nullptr);
828
829 audioProcessInServer->processBuffer_->basicBufferInfo_ = nullptr;
830 auto ret = audioProcessInServer->GetStandbyStatus(isStandby, enterStandbyTime);
831 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
832 }
833
834 /**
835 * @tc.name : Test AudioProcessInServer API
836 * @tc.type : FUNC
837 * @tc.number: AudioProcessInServer_031
838 * @tc.desc : Test AudioProcessInServer interface.
839 */
840 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_031, TestSize.Level1)
841 {
842 AudioProcessConfig configRet = InitProcessConfig();
843 AudioService *releaseCallbackRet = AudioService::GetInstance();
844
845 auto audioProcessInServer = std::make_shared<AudioProcessInServer>(configRet, releaseCallbackRet);
846
847 bool isStandby = true;
848 int64_t enterStandbyTime = INTELL_VOICE_SERVICR_UID;
849
850 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_SERVER_SHARED;
851 uint32_t byteSizePerFrame = SPAN_SIZE_IN_FRAME;
852 audioProcessInServer->processBuffer_ = std::make_shared<OHAudioBufferBase>(
853 bufferHolder, TOTAL_SIZE_IN_FRAME, byteSizePerFrame);
854 EXPECT_NE(audioProcessInServer->processBuffer_, nullptr);
855
856 BasicBufferInfo basicBufferInfo;
857 audioProcessInServer->processBuffer_->basicBufferInfo_ = &basicBufferInfo;
858 EXPECT_NE(audioProcessInServer->processBuffer_->basicBufferInfo_, nullptr);
859 audioProcessInServer->processBuffer_->basicBufferInfo_->streamStatus = STREAM_STAND_BY;
860
861 audioProcessInServer->enterStandbyTime_ = DEFAULT_STREAM_ID;
862
863 auto ret = audioProcessInServer->GetStandbyStatus(isStandby, enterStandbyTime);
864 EXPECT_EQ(ret, SUCCESS);
865 EXPECT_EQ(enterStandbyTime, DEFAULT_STREAM_ID);
866 }
867
868 /**
869 * @tc.name : Test AudioProcessInServer API
870 * @tc.type : FUNC
871 * @tc.number: AudioProcessInServer_032
872 * @tc.desc : Test AudioProcessInServer interface.
873 */
874 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_032, TestSize.Level1)
875 {
876 AudioProcessConfig configRet = InitProcessConfig();
877 AudioService *releaseCallbackRet = AudioService::GetInstance();
878
879 auto audioProcessInServer = std::make_shared<AudioProcessInServer>(configRet, releaseCallbackRet);
880
881 bool isStandby = true;
882 int64_t enterStandbyTime = INTELL_VOICE_SERVICR_UID;
883
884 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_SERVER_SHARED;
885 uint32_t byteSizePerFrame = SPAN_SIZE_IN_FRAME;
886 audioProcessInServer->processBuffer_ = std::make_shared<OHAudioBufferBase>(
887 bufferHolder, TOTAL_SIZE_IN_FRAME, byteSizePerFrame);
888 EXPECT_NE(audioProcessInServer->processBuffer_, nullptr);
889
890 BasicBufferInfo basicBufferInfo;
891 audioProcessInServer->processBuffer_->basicBufferInfo_ = &basicBufferInfo;
892 EXPECT_NE(audioProcessInServer->processBuffer_->basicBufferInfo_, nullptr);
893 audioProcessInServer->processBuffer_->basicBufferInfo_->streamStatus = STREAM_IDEL;
894
895 audioProcessInServer->enterStandbyTime_ = DEFAULT_STREAM_ID;
896
897 auto ret = audioProcessInServer->GetStandbyStatus(isStandby, enterStandbyTime);
898 EXPECT_EQ(ret, SUCCESS);
899 EXPECT_EQ(enterStandbyTime, 0);
900 }
901
902 /**
903 * @tc.name : Test AudioProcessInServer API
904 * @tc.type : FUNC
905 * @tc.number: AudioProcessInServer_033
906 * @tc.desc : Test AudioProcessInServer interface.
907 */
908 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_033, TestSize.Level1)
909 {
910 AudioProcessConfig configRet = InitProcessConfig();
911 AudioService *releaseCallbackRet = AudioService::GetInstance();
912 auto audioProcessInServer = std::make_shared<AudioProcessInServer>(configRet, releaseCallbackRet);
913 int64_t duration = 0;
914
915 int32_t ret = audioProcessInServer->SetSourceDuration(duration);
916 EXPECT_EQ(ret, SUCCESS);
917 }
918
919 /**
920 * @tc.name : Test AudioProcessInServer API
921 * @tc.type : FUNC
922 * @tc.number: AudioProcessInServer_034
923 * @tc.desc : Test AudioProcessInServer interface.
924 */
925 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_034, TestSize.Level1)
926 {
927 AudioProcessConfig configRet = InitProcessConfig();
928 AudioService *releaseCallbackRet = AudioService::GetInstance();
929 auto audioProcessInServer = std::make_shared<AudioProcessInServer>(configRet, releaseCallbackRet);
930 uint32_t underrunCnt = 0;
931
932 int32_t ret = audioProcessInServer->SetUnderrunCount(underrunCnt);
933 EXPECT_EQ(ret, SUCCESS);
934 }
935
936 /**
937 * @tc.name : Test AudioProcessInServer API
938 * @tc.type : FUNC
939 * @tc.number: AudioProcessInServer_035
940 * @tc.desc : Test AudioProcessInServer interface.
941 */
942 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_035, TestSize.Level1)
943 {
944 AudioProcessConfig configRet = InitProcessConfig();
945 AudioService *releaseCallbackRet = AudioService::GetInstance();
946 auto audioProcessInServer = std::make_shared<AudioProcessInServer>(configRet, releaseCallbackRet);
947 int64_t muteFrameCnt = 1;
948
949 audioProcessInServer->lastWriteMuteFrame_ = 0;
950 audioProcessInServer->AddMuteWriteFrameCnt(muteFrameCnt);
951 EXPECT_EQ(audioProcessInServer->lastWriteMuteFrame_, 1);
952 }
953
954 /**
955 * @tc.name : Test AudioProcessInServer API
956 * @tc.type : FUNC
957 * @tc.number: AudioProcessInServer_036
958 * @tc.desc : Test AudioProcessInServer interface.
959 */
960 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_036, TestSize.Level1)
961 {
962 AudioProcessConfig configRet = InitProcessConfig();
963 AudioService *releaseCallbackRet = AudioService::GetInstance();
964 auto audioProcessInServer = std::make_shared<AudioProcessInServer>(configRet, releaseCallbackRet);
965
966 audioProcessInServer->lastStopTime_ = 10;
967 audioProcessInServer->lastStartTime_ = 100;
968 int64_t ret = audioProcessInServer->GetLastAudioDuration();
969 EXPECT_EQ(ret, -1);
970
971 audioProcessInServer->lastStopTime_ = 100;
972 audioProcessInServer->lastStartTime_ = 10;
973 ret = audioProcessInServer->GetLastAudioDuration();
974 EXPECT_EQ(ret, 90);
975 }
976
977 /**
978 * @tc.name : Test AudioProcessInServer API
979 * @tc.type : FUNC
980 * @tc.number: AudioProcessInServer_037
981 * @tc.desc : Test AudioProcessInServer interface.
982 */
983 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_037, TestSize.Level1)
984 {
985 AudioProcessConfig configRet = InitProcessConfig();
986 AudioService *releaseCallbackRet = AudioService::GetInstance();
987 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
988
989 int32_t syncId = 100;
990 auto ret = audioProcessInServerRet.SetAudioHapticsSyncId(syncId);
991 EXPECT_EQ(ret, SUCCESS);
992 EXPECT_EQ(audioProcessInServerRet.audioHapticsSyncId_, syncId);
993 }
994
995 /**
996 * @tc.name : Test AudioProcessInServer API
997 * @tc.type : FUNC
998 * @tc.number: AudioProcessInServer_038
999 * @tc.desc : Test AudioProcessInServer interface.
1000 */
1001 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_038, TestSize.Level1)
1002 {
1003 AudioProcessConfig configRet = InitProcessConfig();
1004 AudioService *releaseCallbackRet = AudioService::GetInstance();
1005 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
1006
1007 int32_t syncId = 100;
1008 audioProcessInServerRet.audioHapticsSyncId_.store(syncId);
1009 auto ret = audioProcessInServerRet.GetAudioHapticsSyncId();
1010 EXPECT_EQ(ret, syncId);
1011 }
1012
1013 /**
1014 * @tc.name : Test TurnOnMicIndicator API
1015 * @tc.type : FUNC
1016 * @tc.number: TurnOnMicIndicator_001
1017 * @tc.desc : Test TurnOnMicIndicator interface.
1018 */
1019 HWTEST(AudioProcessInServerUnitTest, TurnOnMicIndicator_001, TestSize.Level2)
1020 {
1021 AudioProcessConfig configRet = InitProcessConfig();
1022 AudioService *releaseCallbackRet = AudioService::GetInstance();
1023 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
1024 CapturerState capturerState = CapturerState::CAPTURER_PREPARED;
1025 audioProcessInServerRet.isMicIndicatorOn_ = true;
1026
1027 bool ret = audioProcessInServerRet.TurnOnMicIndicator(capturerState);
1028 EXPECT_FALSE(ret);
1029 }
1030
1031 /**
1032 * @tc.name : Test TurnOnMicIndicator API
1033 * @tc.type : FUNC
1034 * @tc.number: TurnOnMicIndicator_002
1035 * @tc.desc : Test TurnOnMicIndicator interface.
1036 */
1037 HWTEST(AudioProcessInServerUnitTest, TurnOnMicIndicator_002, TestSize.Level2)
1038 {
1039 AudioProcessConfig configRet = InitProcessConfig();
1040 AudioService *releaseCallbackRet = AudioService::GetInstance();
1041 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
1042 CapturerState capturerState = CapturerState::CAPTURER_PREPARED;
1043 audioProcessInServerRet.isMicIndicatorOn_ = false;
1044
1045 bool ret = audioProcessInServerRet.TurnOnMicIndicator(capturerState);
1046 EXPECT_FALSE(ret);
1047 }
1048
1049 /**
1050 * @tc.name : Test TurnOffMicIndicator API
1051 * @tc.type : FUNC
1052 * @tc.number: TurnOffMicIndicator_001
1053 * @tc.desc : Test TurnOffMicIndicator interface.
1054 */
1055 HWTEST(AudioProcessInServerUnitTest, TurnOffMicIndicator_001, TestSize.Level2)
1056 {
1057 AudioProcessConfig configRet = InitProcessConfig();
1058 AudioService *releaseCallbackRet = AudioService::GetInstance();
1059 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
1060 CapturerState capturerState = CapturerState::CAPTURER_PREPARED;
1061 audioProcessInServerRet.isMicIndicatorOn_ = false;
1062
1063 bool ret = audioProcessInServerRet.TurnOffMicIndicator(capturerState);
1064 EXPECT_TRUE(ret);
1065 }
1066
1067 /**
1068 * @tc.name : Test TurnOffMicIndicator API
1069 * @tc.type : FUNC
1070 * @tc.number: TurnOffMicIndicator_002
1071 * @tc.desc : Test TurnOffMicIndicator interface.
1072 */
1073 HWTEST(AudioProcessInServerUnitTest, TurnOffMicIndicator_002, TestSize.Level2)
1074 {
1075 AudioProcessConfig configRet = InitProcessConfig();
1076 AudioService *releaseCallbackRet = AudioService::GetInstance();
1077 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
1078 CapturerState capturerState = CapturerState::CAPTURER_PREPARED;
1079 audioProcessInServerRet.isMicIndicatorOn_ = true;
1080
1081 bool ret = audioProcessInServerRet.TurnOffMicIndicator(capturerState);
1082 EXPECT_TRUE(ret);
1083 }
1084
1085 /**
1086 * @tc.name : Test GetInnerCapState API
1087 * @tc.type : FUNC
1088 * @tc.number: GetInnerCapState_001
1089 * @tc.desc : Test GetInnerCapState interface.
1090 */
1091 HWTEST(AudioProcessInServerUnitTest, GetInnerCapState_001, TestSize.Level2)
1092 {
1093 AudioProcessConfig configRet = InitProcessConfig();
1094 AudioService *releaseCallbackRet = AudioService::GetInstance();
1095 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
1096 CapturerState capturerState = CapturerState::CAPTURER_PREPARED;
1097 audioProcessInServerRet.isMicIndicatorOn_ = true;
1098
1099 bool ret = audioProcessInServerRet.GetInnerCapState(capturerState);
1100 EXPECT_FALSE(ret);
1101 }
1102
1103 /**
1104 * @tc.name : Test GetInnerCapState API
1105 * @tc.type : FUNC
1106 * @tc.number: GetInnerCapState_002
1107 * @tc.desc : Test GetInnerCapState interface.
1108 */
1109 HWTEST(AudioProcessInServerUnitTest, GetInnerCapState_002, TestSize.Level2)
1110 {
1111 AudioProcessConfig configRet = InitProcessConfig();
1112 AudioService *releaseCallbackRet = AudioService::GetInstance();
1113 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
1114 int32_t innerCapId = 1;
1115 audioProcessInServerRet.SetInnerCapState(true, innerCapId);
1116
1117 bool ret = audioProcessInServerRet.GetInnerCapState(innerCapId);
1118 EXPECT_TRUE(ret);
1119 }
1120
1121 /**
1122 * @tc.name : Test CheckBGCapturer API
1123 * @tc.type : FUNC
1124 * @tc.number: CheckBGCapturer_001
1125 * @tc.desc : Test CheckBGCapturer interface.
1126 */
1127 HWTEST(AudioProcessInServerUnitTest, CheckBGCapturer_001, TestSize.Level4)
1128 {
1129 AudioProcessConfig configRet = InitProcessConfig();
1130 AudioService *releaseCallbackRet = AudioService::GetInstance();
1131 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
1132
1133 EXPECT_FALSE(audioProcessInServerRet.CheckBGCapturer());
1134 }
1135 } // namespace AudioStandard
1136 } // namespace OHOS
1137