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 DeviceStreamInfo g_audioStreamInfo = {
61 SAMPLE_RATE_48000,
62 ENCODING_PCM,
63 SAMPLE_S16LE,
64 STEREO
65 };
66
InitProcessConfig()67 static AudioProcessConfig InitProcessConfig()
68 {
69 AudioProcessConfig config;
70 config.appInfo.appFullTokenId = 1;
71 config.appInfo.appTokenId = 1;
72 config.appInfo.appUid = DEFAULT_STREAM_ID;
73 config.appInfo.appPid = DEFAULT_STREAM_ID;
74 config.streamInfo.format = SAMPLE_S32LE;
75 config.streamInfo.samplingRate = SAMPLE_RATE_48000;
76 config.streamInfo.channels = STEREO;
77 config.streamInfo.channelLayout = AudioChannelLayout::CH_LAYOUT_STEREO;
78 config.audioMode = AudioMode::AUDIO_MODE_RECORD;
79 config.streamType = AudioStreamType::STREAM_MUSIC;
80 config.deviceType = DEVICE_TYPE_USB_HEADSET;
81 return config;
82 }
83
84 /**
85 * @tc.name : Test AudioProcessInServer API
86 * @tc.type : FUNC
87 * @tc.number: AudioProcessInServer_001
88 * @tc.desc : Test AudioProcessInServer interface.
89 */
90 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_001, TestSize.Level1)
91 {
92 AudioProcessConfig configRet = InitProcessConfig();
93 AudioService *releaseCallbackRet = AudioService::GetInstance();
94 sptr<AudioProcessInServer> audioProcessInServer = AudioProcessInServer::Create(configRet, releaseCallbackRet);
95 uint32_t sessionIdRet = 0;
96 bool muteFlagRet = true;
97 auto ret = audioProcessInServer->GetSessionId(sessionIdRet);
98 EXPECT_EQ(ret, SUCCESS);
99 EXPECT_EQ(audioProcessInServer->GetSessionId(), sessionIdRet);
100 ret = audioProcessInServer->GetMuteState();
101 EXPECT_EQ(ret, false);
102 audioProcessInServer->SetNonInterruptMute(muteFlagRet);
103 EXPECT_EQ(audioProcessInServer->GetMuteState(), true);
104 }
105
106 /**
107 * @tc.name : Test AudioProcessInServer API
108 * @tc.type : FUNC
109 * @tc.number: AudioProcessInServer_002
110 * @tc.desc : Test AudioProcessInServer interface.
111 */
112 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_002, TestSize.Level1)
113 {
114 AudioProcessConfig configRet = InitProcessConfig();
115 AudioService *releaseCallbackRet = AudioService::GetInstance();
116 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
117 std::shared_ptr<OHAudioBuffer> bufferRet = nullptr;
118 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_SERVER_SHARED;
119 uint32_t byteSizePerFrame = 1000;
120 EXPECT_EQ(audioProcessInServerRet.processBuffer_, nullptr);
121 audioProcessInServerRet.ResolveBuffer(bufferRet);
122 audioProcessInServerRet.processBuffer_ = std::make_shared<OHAudioBuffer>(bufferHolder,
123 TOTAL_SIZE_IN_FRAME, SPAN_SIZE_IN_FRAME, byteSizePerFrame);
124 EXPECT_NE(audioProcessInServerRet.processBuffer_, nullptr);
125 auto ret = audioProcessInServerRet.ResolveBuffer(bufferRet);
126 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
127 }
128
129 /**
130 * @tc.name : Test AudioProcessInServer API
131 * @tc.type : FUNC
132 * @tc.number: AudioProcessInServer_003
133 * @tc.desc : Test AudioProcessInServer interface.
134 */
135 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_003, TestSize.Level1)
136 {
137 AudioProcessConfig configRet = InitProcessConfig();
138 AudioService *releaseCallbackRet = AudioService::GetInstance();
139 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
140 audioProcessInServerRet.isInited_ = true;
141 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_SERVER_SHARED;
142 uint32_t byteSizePerFrame = 1000;
143 audioProcessInServerRet.processBuffer_ = std::make_shared<OHAudioBuffer>(bufferHolder,
144 TOTAL_SIZE_IN_FRAME, SPAN_SIZE_IN_FRAME, byteSizePerFrame);
145 EXPECT_NE(audioProcessInServerRet.processBuffer_, nullptr);
146 bool isAsyncRet = false;
147 auto ret = audioProcessInServerRet.RequestHandleInfo(isAsyncRet);
148 EXPECT_EQ(ret, SUCCESS);
149 }
150
151 /**
152 * @tc.name : Test AudioProcessInServer API
153 * @tc.type : FUNC
154 * @tc.number: AudioProcessInServer_004
155 * @tc.desc : Test AudioProcessInServer interface.
156 */
157 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_004, TestSize.Level1)
158 {
159 AudioProcessConfig configRet = InitProcessConfig();
160 AudioService *releaseCallbackRet = AudioService::GetInstance();
161 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
162 std::shared_ptr<OHAudioBuffer> buffer = nullptr;
163 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
164 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
165
166 EXPECT_EQ(audioProcessInServerRet.processBuffer_, nullptr);
167 auto ret = audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
168 spanSizeInFrame, g_audioStreamInfo, buffer);
169 EXPECT_EQ(ret, SUCCESS);
170 }
171
172 /**
173 * @tc.name : Test AudioProcessInServer API
174 * @tc.type : FUNC
175 * @tc.number: AudioProcessInServer_005
176 * @tc.desc : Test AudioProcessInServer interface.
177 */
178 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_005, TestSize.Level1)
179 {
180 AudioProcessConfig configRet = InitProcessConfig();
181 configRet.streamInfo.format = SAMPLE_U8;
182 AudioService *releaseCallbackRet = AudioService::GetInstance();
183 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
184 std::shared_ptr<OHAudioBuffer> buffer = nullptr;
185 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
186 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
187
188 EXPECT_EQ(audioProcessInServerRet.processBuffer_, nullptr);
189 auto ret = audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
190 spanSizeInFrame, g_audioStreamInfo, buffer);
191 EXPECT_EQ(ret, SUCCESS);
192 }
193
194 /**
195 * @tc.name : Test AudioProcessInServer API
196 * @tc.type : FUNC
197 * @tc.number: AudioProcessInServer_006
198 * @tc.desc : Test AudioProcessInServer interface.
199 */
200 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_006, TestSize.Level1)
201 {
202 AudioProcessConfig configRet = InitProcessConfig();
203 configRet.streamInfo.format = SAMPLE_S16LE;
204 AudioService *releaseCallbackRet = AudioService::GetInstance();
205 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
206 std::shared_ptr<OHAudioBuffer> buffer = nullptr;
207 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
208 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
209
210 EXPECT_EQ(audioProcessInServerRet.processBuffer_, nullptr);
211 auto ret = audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
212 spanSizeInFrame, g_audioStreamInfo, buffer);
213 EXPECT_EQ(ret, SUCCESS);
214 }
215
216 /**
217 * @tc.name : Test AudioProcessInServer API
218 * @tc.type : FUNC
219 * @tc.number: AudioProcessInServer_007
220 * @tc.desc : Test AudioProcessInServer interface.
221 */
222 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_007, TestSize.Level1)
223 {
224 AudioProcessConfig configRet = InitProcessConfig();
225 configRet.streamInfo.format = SAMPLE_S24LE;
226 AudioService *releaseCallbackRet = AudioService::GetInstance();
227 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
228 std::shared_ptr<OHAudioBuffer> buffer = nullptr;
229 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
230 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
231
232 EXPECT_EQ(audioProcessInServerRet.processBuffer_, nullptr);
233 auto ret = audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
234 spanSizeInFrame, g_audioStreamInfo, buffer);
235 EXPECT_EQ(ret, SUCCESS);
236 }
237
238 /**
239 * @tc.name : Test AudioProcessInServer API
240 * @tc.type : FUNC
241 * @tc.number: AudioProcessInServer_008
242 * @tc.desc : Test AudioProcessInServer interface.
243 */
244 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_008, TestSize.Level1)
245 {
246 AudioProcessConfig configRet = InitProcessConfig();
247 configRet.streamInfo.format = SAMPLE_F32LE;
248 AudioService *releaseCallbackRet = AudioService::GetInstance();
249 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
250 std::shared_ptr<OHAudioBuffer> buffer = nullptr;
251 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
252 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
253
254 EXPECT_EQ(audioProcessInServerRet.processBuffer_, nullptr);
255 auto ret = audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
256 spanSizeInFrame, g_audioStreamInfo, buffer);
257 EXPECT_EQ(ret, SUCCESS);
258 }
259
260 /**
261 * @tc.name : Test AudioProcessInServer API
262 * @tc.type : FUNC
263 * @tc.number: AudioProcessInServer_009
264 * @tc.desc : Test AudioProcessInServer interface.
265 */
266 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_009, TestSize.Level1)
267 {
268 AudioProcessConfig configRet = InitProcessConfig();
269 configRet.streamInfo.format = INVALID_WIDTH;
270 AudioService *releaseCallbackRet = AudioService::GetInstance();
271 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
272 std::shared_ptr<OHAudioBuffer> buffer = nullptr;
273 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
274 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
275
276 EXPECT_EQ(audioProcessInServerRet.processBuffer_, nullptr);
277 auto ret = audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
278 spanSizeInFrame, g_audioStreamInfo, buffer);
279 EXPECT_EQ(ret, SUCCESS);
280 }
281
282 // /**
283 // * @tc.name : Test AudioProcessInServer API
284 // * @tc.type : FUNC
285 // * @tc.number: AudioProcessInServer_010
286 // * @tc.desc : Test AudioProcessInServer interface.
287 // */
288 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_010, TestSize.Level1)
289 {
290 AudioProcessConfig configRet = InitProcessConfig();
291 AudioService *releaseCallbackRet = AudioService::GetInstance();
292 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
293 audioProcessInServerRet.isInited_ = true;
294 std::shared_ptr<OHAudioBuffer> buffer = nullptr;
295 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
296 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
297 audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
298 spanSizeInFrame, g_audioStreamInfo, buffer);
299
300 audioProcessInServerRet.streamStatus_->store(STREAM_STAND_BY);
301 EXPECT_EQ(audioProcessInServerRet.streamStatus_->load(), STREAM_STAND_BY);
302
303 auto ret = audioProcessInServerRet.Start();
304 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
305 }
306
307 // /**
308 // * @tc.name : Test AudioProcessInServer API
309 // * @tc.type : FUNC
310 // * @tc.number: AudioProcessInServer_011
311 // * @tc.desc : Test AudioProcessInServer interface.
312 // */
313 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_011, TestSize.Level1)
314 {
315 AudioProcessConfig configRet = InitProcessConfig();
316 AudioService *releaseCallbackRet = AudioService::GetInstance();
317 configRet.audioMode = AUDIO_MODE_PLAYBACK;
318 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
319 audioProcessInServerRet.isInited_ = true;
320 std::shared_ptr<OHAudioBuffer> buffer = nullptr;
321 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
322 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
323 audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
324 spanSizeInFrame, g_audioStreamInfo, buffer);
325
326 audioProcessInServerRet.streamStatus_->store(STREAM_STAND_BY);
327 EXPECT_EQ(audioProcessInServerRet.streamStatus_->load(), STREAM_STAND_BY);
328 EXPECT_EQ(audioProcessInServerRet.needCheckBackground_, false);
329 auto ret = audioProcessInServerRet.Start();
330 EXPECT_EQ(audioProcessInServerRet.needCheckBackground_, false);
331 EXPECT_EQ(ret, SUCCESS);
332
333 audioProcessInServerRet.needCheckBackground_ = true;
334 ret = audioProcessInServerRet.Start();
335 EXPECT_EQ(ret, SUCCESS);
336 }
337
338 /**
339 * @tc.name : Test AudioProcessInServer API
340 * @tc.type : FUNC
341 * @tc.number: AudioProcessInServer_012
342 * @tc.desc : Test AudioProcessInServer interface.
343 */
344 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_012, TestSize.Level1)
345 {
346 AudioProcessConfig configRet = InitProcessConfig();
347 AudioService *releaseCallbackRet = AudioService::GetInstance();
348 configRet.callerUid = INTELL_VOICE_SERVICR_UID;
349 configRet.audioMode = AUDIO_MODE_PLAYBACK;
350 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
351 audioProcessInServerRet.isInited_ = true;
352 std::shared_ptr<OHAudioBuffer> buffer = nullptr;
353 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
354 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
355 audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
356 spanSizeInFrame, g_audioStreamInfo, buffer);
357
358 audioProcessInServerRet.streamStatus_->store(STREAM_STARTING);
359 EXPECT_EQ(audioProcessInServerRet.streamStatus_->load(), STREAM_STARTING);
360 EXPECT_EQ(audioProcessInServerRet.needCheckBackground_, false);
361 auto ret = audioProcessInServerRet.Start();
362 EXPECT_EQ(audioProcessInServerRet.needCheckBackground_, false);
363 EXPECT_EQ(ret, SUCCESS);
364
365 audioProcessInServerRet.needCheckBackground_ = true;
366 ret = audioProcessInServerRet.Start();
367 EXPECT_EQ(ret, SUCCESS);
368 }
369
370 /**
371 * @tc.name : Test AudioProcessInServer API
372 * @tc.type : FUNC
373 * @tc.number: AudioProcessInServer_013
374 * @tc.desc : Test AudioProcessInServer interface.
375 */
376 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_013, TestSize.Level1)
377 {
378 AudioProcessConfig configRet = InitProcessConfig();
379 AudioService *releaseCallbackRet = AudioService::GetInstance();
380 configRet.callerUid = INTELL_VOICE_SERVICR_UID;
381 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
382 audioProcessInServerRet.isInited_ = true;
383 std::shared_ptr<OHAudioBuffer> buffer = nullptr;
384 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
385 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
386 audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
387 spanSizeInFrame, g_audioStreamInfo, buffer);
388
389 audioProcessInServerRet.streamStatus_->store(STREAM_STARTING);
390 EXPECT_EQ(audioProcessInServerRet.streamStatus_->load(), STREAM_STARTING);
391 auto ret = audioProcessInServerRet.Start();
392 EXPECT_EQ(ret, SUCCESS);
393
394 audioProcessInServerRet.needCheckBackground_ = true;
395 ret = audioProcessInServerRet.Start();
396 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
397 }
398
399 /**
400 * @tc.name : Test AudioProcessInServer API
401 * @tc.type : FUNC
402 * @tc.number: AudioProcessInServer_014
403 * @tc.desc : Test AudioProcessInServer interface.
404 */
405 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_014, TestSize.Level1)
406 {
407 AudioProcessConfig configRet = InitProcessConfig();
408 AudioService *releaseCallbackRet = AudioService::GetInstance();
409 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
410 audioProcessInServerRet.isInited_ = true;
411 audioProcessInServerRet.needCheckBackground_ = true;
412 std::shared_ptr<OHAudioBuffer> buffer = nullptr;
413 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
414 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
415 audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
416 spanSizeInFrame, g_audioStreamInfo, buffer);
417 audioProcessInServerRet.streamStatus_->store(STREAM_PAUSING);
418 bool isFlush = true;
419
420 auto ret = audioProcessInServerRet.Pause(isFlush);
421 EXPECT_EQ(ret, SUCCESS);
422
423 audioProcessInServerRet.needCheckBackground_ = false;
424 ret = audioProcessInServerRet.Pause(isFlush);
425 EXPECT_EQ(ret, SUCCESS);
426 }
427
428 /**
429 * @tc.name : Test AudioProcessInServer API
430 * @tc.type : FUNC
431 * @tc.number: AudioProcessInServer_015
432 * @tc.desc : Test AudioProcessInServer interface.
433 */
434 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_015, TestSize.Level1)
435 {
436 AudioProcessConfig configRet = InitProcessConfig();
437 AudioService *releaseCallbackRet = AudioService::GetInstance();
438 configRet.audioMode = AUDIO_MODE_PLAYBACK;
439 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
440 audioProcessInServerRet.isInited_ = true;
441 std::shared_ptr<OHAudioBuffer> buffer = nullptr;
442 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
443 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
444 audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
445 spanSizeInFrame, g_audioStreamInfo, buffer);
446 audioProcessInServerRet.streamStatus_->store(STREAM_PAUSING);
447 bool isFlush = true;
448
449 auto ret = audioProcessInServerRet.Pause(isFlush);
450 EXPECT_EQ(ret, SUCCESS);
451
452 audioProcessInServerRet.needCheckBackground_ = true;
453 ret = audioProcessInServerRet.Pause(isFlush);
454 EXPECT_EQ(ret, SUCCESS);
455 }
456
457 // /**
458 // * @tc.name : Test AudioProcessInServer API
459 // * @tc.type : FUNC
460 // * @tc.number: AudioProcessInServer_016
461 // * @tc.desc : Test AudioProcessInServer interface.
462 // */
463 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_016, TestSize.Level1)
464 {
465 AudioProcessConfig configRet = InitProcessConfig();
466 AudioService *releaseCallbackRet = AudioService::GetInstance();
467 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
468 audioProcessInServerRet.isInited_ = true;
469 std::shared_ptr<OHAudioBuffer> buffer = nullptr;
470 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
471 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
472 audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
473 spanSizeInFrame, g_audioStreamInfo, buffer);
474
475 audioProcessInServerRet.streamStatus_->store(STREAM_STARTING);
476 EXPECT_EQ(audioProcessInServerRet.streamStatus_->load(), STREAM_STARTING);
477
478 auto ret = audioProcessInServerRet.Resume();
479 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
480 }
481
482 // /**
483 // * @tc.name : Test AudioProcessInServer API
484 // * @tc.type : FUNC
485 // * @tc.number: AudioProcessInServer_017
486 // * @tc.desc : Test AudioProcessInServer interface.
487 // */
488 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_017, TestSize.Level1)
489 {
490 AudioProcessConfig configRet = InitProcessConfig();
491 AudioService *releaseCallbackRet = AudioService::GetInstance();
492 configRet.audioMode = AUDIO_MODE_PLAYBACK;
493 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
494 audioProcessInServerRet.isInited_ = true;
495 std::shared_ptr<OHAudioBuffer> buffer = nullptr;
496 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
497 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
498 audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
499 spanSizeInFrame, g_audioStreamInfo, buffer);
500
501 audioProcessInServerRet.streamStatus_->store(STREAM_STARTING);
502 EXPECT_EQ(audioProcessInServerRet.streamStatus_->load(), STREAM_STARTING);
503 auto ret = audioProcessInServerRet.Resume();
504 EXPECT_EQ(ret, SUCCESS);
505
506 audioProcessInServerRet.needCheckBackground_ = true;
507 ret = audioProcessInServerRet.Resume();
508 EXPECT_EQ(ret, SUCCESS);
509 }
510
511 /**
512 * @tc.name : Test AudioProcessInServer API
513 * @tc.type : FUNC
514 * @tc.number: AudioProcessInServer_018
515 * @tc.desc : Test AudioProcessInServer interface.
516 */
517 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_018, TestSize.Level1)
518 {
519 AudioProcessConfig configRet = InitProcessConfig();
520 AudioService *releaseCallbackRet = AudioService::GetInstance();
521 configRet.callerUid = INTELL_VOICE_SERVICR_UID;
522 configRet.audioMode = AUDIO_MODE_PLAYBACK;
523 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
524 audioProcessInServerRet.isInited_ = true;
525 std::shared_ptr<OHAudioBuffer> buffer = nullptr;
526 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
527 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
528 audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
529 spanSizeInFrame, g_audioStreamInfo, buffer);
530
531 audioProcessInServerRet.streamStatus_->store(STREAM_STARTING);
532 EXPECT_EQ(audioProcessInServerRet.streamStatus_->load(), STREAM_STARTING);
533 EXPECT_EQ(audioProcessInServerRet.needCheckBackground_, false);
534 auto ret = audioProcessInServerRet.Resume();
535 EXPECT_EQ(audioProcessInServerRet.needCheckBackground_, false);
536 EXPECT_EQ(ret, SUCCESS);
537
538 audioProcessInServerRet.needCheckBackground_ = true;
539 ret = audioProcessInServerRet.Resume();
540 EXPECT_EQ(ret, SUCCESS);
541 }
542
543 /**
544 * @tc.name : Test AudioProcessInServer API
545 * @tc.type : FUNC
546 * @tc.number: AudioProcessInServer_019
547 * @tc.desc : Test AudioProcessInServer interface.
548 */
549 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_019, TestSize.Level1)
550 {
551 AudioProcessConfig configRet = InitProcessConfig();
552 AudioService *releaseCallbackRet = AudioService::GetInstance();
553 configRet.callerUid = INTELL_VOICE_SERVICR_UID;
554 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
555 audioProcessInServerRet.isInited_ = true;
556 std::shared_ptr<OHAudioBuffer> buffer = nullptr;
557 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
558 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
559 audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
560 spanSizeInFrame, g_audioStreamInfo, buffer);
561
562 audioProcessInServerRet.streamStatus_->store(STREAM_STARTING);
563 EXPECT_EQ(audioProcessInServerRet.streamStatus_->load(), STREAM_STARTING);
564 auto ret = audioProcessInServerRet.Resume();
565 EXPECT_EQ(ret, SUCCESS);
566
567 audioProcessInServerRet.needCheckBackground_ = true;
568 ret = audioProcessInServerRet.Resume();
569 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
570 }
571
572 /**
573 * @tc.name : Test AudioProcessInServer API
574 * @tc.type : FUNC
575 * @tc.number: AudioProcessInServer_020
576 * @tc.desc : Test AudioProcessInServer interface.
577 */
578 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_020, TestSize.Level1)
579 {
580 AudioProcessConfig configRet = InitProcessConfig();
581 AudioService *releaseCallbackRet = AudioService::GetInstance();
582 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
583 audioProcessInServerRet.isInited_ = true;
584 audioProcessInServerRet.needCheckBackground_ = true;
585 std::shared_ptr<OHAudioBuffer> buffer = nullptr;
586 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
587 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
588 audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
589 spanSizeInFrame, g_audioStreamInfo, buffer);
590 audioProcessInServerRet.streamStatus_->store(STREAM_STOPPING);
591
592 auto ret = audioProcessInServerRet.Stop();
593 EXPECT_EQ(ret, SUCCESS);
594
595 audioProcessInServerRet.needCheckBackground_ = false;
596 ret = audioProcessInServerRet.Stop();
597 EXPECT_EQ(ret, SUCCESS);
598 }
599
600 /**
601 * @tc.name : Test AudioProcessInServer API
602 * @tc.type : FUNC
603 * @tc.number: AudioProcessInServer_021
604 * @tc.desc : Test AudioProcessInServer interface.
605 */
606 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_021, TestSize.Level1)
607 {
608 AudioProcessConfig configRet = InitProcessConfig();
609 AudioService *releaseCallbackRet = AudioService::GetInstance();
610 configRet.audioMode = AUDIO_MODE_PLAYBACK;
611 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
612 audioProcessInServerRet.isInited_ = true;
613 std::shared_ptr<OHAudioBuffer> buffer = nullptr;
614 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
615 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
616 audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
617 spanSizeInFrame, g_audioStreamInfo, buffer);
618 audioProcessInServerRet.streamStatus_->store(STREAM_STOPPING);
619
620 auto ret = audioProcessInServerRet.Stop();
621 EXPECT_EQ(ret, SUCCESS);
622
623 audioProcessInServerRet.needCheckBackground_ = true;
624 ret = audioProcessInServerRet.Stop();
625 EXPECT_EQ(ret, SUCCESS);
626 }
627
628 /**
629 * @tc.name : Test AudioProcessInServer API
630 * @tc.type : FUNC
631 * @tc.number: AudioProcessInServer_022
632 * @tc.desc : Test AudioProcessInServer interface.
633 */
634 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_022, TestSize.Level1)
635 {
636 AudioProcessConfig configRet = InitProcessConfig();
637 AudioService *releaseCallbackRet = AudioService::GetInstance();
638 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
639 audioProcessInServerRet.isInited_ = true;
640 audioProcessInServerRet.needCheckBackground_ = true;
641 std::shared_ptr<OHAudioBuffer> buffer = nullptr;
642 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
643 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
644 audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
645 spanSizeInFrame, g_audioStreamInfo, buffer);
646 audioProcessInServerRet.streamStatus_->store(STREAM_STOPPING);
647 bool isSwitchStream = false;
648
649 EXPECT_NE(audioProcessInServerRet.releaseCallback_, nullptr);
650 auto ret = audioProcessInServerRet.Release(isSwitchStream);
651 EXPECT_EQ(ret, SUCCESS);
652
653 audioProcessInServerRet.isInited_ = true;
654 audioProcessInServerRet.needCheckBackground_ = false;
655 ret = audioProcessInServerRet.Release(isSwitchStream);
656 EXPECT_EQ(ret, SUCCESS);
657 }
658
659 /**
660 * @tc.name : Test AudioProcessInServer API
661 * @tc.type : FUNC
662 * @tc.number: AudioProcessInServer_023
663 * @tc.desc : Test AudioProcessInServer interface.
664 */
665 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_023, TestSize.Level1)
666 {
667 AudioProcessConfig configRet = InitProcessConfig();
668 AudioService *releaseCallbackRet = AudioService::GetInstance();
669 configRet.audioMode = AUDIO_MODE_PLAYBACK;
670 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
671 audioProcessInServerRet.isInited_ = true;
672 std::shared_ptr<OHAudioBuffer> buffer = nullptr;
673 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
674 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
675 audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
676 spanSizeInFrame, g_audioStreamInfo, buffer);
677 audioProcessInServerRet.streamStatus_->store(STREAM_STOPPING);
678 bool isSwitchStream = false;
679
680 auto ret = audioProcessInServerRet.Release(isSwitchStream);
681 EXPECT_EQ(ret, SUCCESS);
682
683 audioProcessInServerRet.isInited_ = true;
684 audioProcessInServerRet.needCheckBackground_ = true;
685 ret = audioProcessInServerRet.Release(isSwitchStream);
686 EXPECT_EQ(ret, SUCCESS);
687 }
688
689 /**
690 * @tc.name : Test AudioProcessInServer API
691 * @tc.type : FUNC
692 * @tc.number: AudioProcessInServer_024
693 * @tc.desc : Test AudioProcessInServer interface.
694 */
695 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_024, TestSize.Level1)
696 {
697 AudioProcessConfig configRet = InitProcessConfig();
698 AudioService *releaseCallbackRet = AudioService::GetInstance();
699 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
700 std::string dumpStringRet1;
701
702 EXPECT_EQ(audioProcessInServerRet.streamStatus_, nullptr);
703 audioProcessInServerRet.Dump(dumpStringRet1);
704
705 audioProcessInServerRet.isInited_ = true;
706 std::shared_ptr<OHAudioBuffer> buffer = nullptr;
707 uint32_t totalSizeInFrame = TOTAL_SIZE_IN_FRAME;
708 uint32_t spanSizeInFrame = SPAN_SIZE_IN_FRAME;
709 audioProcessInServerRet.ConfigProcessBuffer(totalSizeInFrame,
710 spanSizeInFrame, g_audioStreamInfo, buffer);
711 audioProcessInServerRet.streamStatus_->store(STREAM_STOPPING);
712 std::string dumpStringRet2;
713
714 EXPECT_NE(audioProcessInServerRet.streamStatus_, nullptr);
715 audioProcessInServerRet.Dump(dumpStringRet2);
716 }
717
718 /**
719 * @tc.name : Test AudioProcessInServer API
720 * @tc.type : FUNC
721 * @tc.number: AudioProcessInServer_025
722 * @tc.desc : Test AudioProcessInServer interface.
723 */
724 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_025, TestSize.Level1)
725 {
726 AudioProcessConfig configRet = InitProcessConfig();
727 AudioService *releaseCallbackRet = AudioService::GetInstance();
728 AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet);
729 std::string name = "unit_test";
730 auto ret = audioProcessInServerRet.RegisterThreadPriority(0, name);
731 EXPECT_EQ(ret, SUCCESS);
732
733 audioProcessInServerRet.clientThreadPriorityRequested_ = true;
734 ret = audioProcessInServerRet.RegisterThreadPriority(0, name);
735 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
736 }
737 /**
738 * @tc.name : Test AudioProcessInServer API
739 * @tc.type : FUNC
740 * @tc.number: AudioProcessInServer_026
741 * @tc.desc : Test AudioProcessInServer interface.
742 */
743 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_026, TestSize.Level1)
744 {
745 AudioProcessConfig configRet = InitProcessConfig();
746 AudioService *releaseCallbackRet = AudioService::GetInstance();
747
748 configRet.originalSessionId = DEFAULT_STREAM_ID;
749 auto audioProcessInServer = std::make_shared<AudioProcessInServer>(configRet, releaseCallbackRet);
750 EXPECT_NE(audioProcessInServer, nullptr);
751 }
752
753 /**
754 * @tc.name : Test AudioProcessInServer API
755 * @tc.type : FUNC
756 * @tc.number: AudioProcessInServer_027
757 * @tc.desc : Test AudioProcessInServer interface.
758 */
759 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_027, TestSize.Level1)
760 {
761 AudioProcessConfig configRet = InitProcessConfig();
762 AudioService *releaseCallbackRet = AudioService::GetInstance();
763
764 configRet.originalSessionId = MIN_STREAMID_2;
765 auto audioProcessInServer = std::make_shared<AudioProcessInServer>(configRet, releaseCallbackRet);
766 EXPECT_NE(audioProcessInServer, nullptr);
767 }
768
769 /**
770 * @tc.name : Test AudioProcessInServer API
771 * @tc.type : FUNC
772 * @tc.number: AudioProcessInServer_028
773 * @tc.desc : Test AudioProcessInServer interface.
774 */
775 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_028, TestSize.Level1)
776 {
777 AudioProcessConfig configRet = InitProcessConfig();
778 AudioService *releaseCallbackRet = AudioService::GetInstance();
779
780 configRet.originalSessionId = MIN_STREAMID_3;
781 auto audioProcessInServer = std::make_shared<AudioProcessInServer>(configRet, releaseCallbackRet);
782 EXPECT_NE(audioProcessInServer, nullptr);
783 }
784
785 /**
786 * @tc.name : Test AudioProcessInServer API
787 * @tc.type : FUNC
788 * @tc.number: AudioProcessInServer_029
789 * @tc.desc : Test AudioProcessInServer interface.
790 */
791 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_029, TestSize.Level1)
792 {
793 AudioProcessConfig configRet = InitProcessConfig();
794 AudioService *releaseCallbackRet = AudioService::GetInstance();
795
796 auto audioProcessInServer = std::make_shared<AudioProcessInServer>(configRet, releaseCallbackRet);
797
798 bool isStandby = true;
799 int64_t enterStandbyTime = 0;
800
801 audioProcessInServer->processBuffer_ = nullptr;
802 auto ret = audioProcessInServer->GetStandbyStatus(isStandby, enterStandbyTime);
803 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
804 }
805
806 /**
807 * @tc.name : Test AudioProcessInServer API
808 * @tc.type : FUNC
809 * @tc.number: AudioProcessInServer_030
810 * @tc.desc : Test AudioProcessInServer interface.
811 */
812 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_030, TestSize.Level1)
813 {
814 AudioProcessConfig configRet = InitProcessConfig();
815 AudioService *releaseCallbackRet = AudioService::GetInstance();
816
817 auto audioProcessInServer = std::make_shared<AudioProcessInServer>(configRet, releaseCallbackRet);
818
819 bool isStandby = true;
820 int64_t enterStandbyTime = 0;
821
822 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_SERVER_SHARED;
823 uint32_t byteSizePerFrame = SPAN_SIZE_IN_FRAME;
824 audioProcessInServer->processBuffer_ = std::make_shared<OHAudioBuffer>(bufferHolder,
825 TOTAL_SIZE_IN_FRAME, SPAN_SIZE_IN_FRAME, byteSizePerFrame);
826 EXPECT_NE(audioProcessInServer->processBuffer_, nullptr);
827
828 audioProcessInServer->processBuffer_->basicBufferInfo_ = nullptr;
829 auto ret = audioProcessInServer->GetStandbyStatus(isStandby, enterStandbyTime);
830 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
831 }
832
833 /**
834 * @tc.name : Test AudioProcessInServer API
835 * @tc.type : FUNC
836 * @tc.number: AudioProcessInServer_031
837 * @tc.desc : Test AudioProcessInServer interface.
838 */
839 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_031, TestSize.Level1)
840 {
841 AudioProcessConfig configRet = InitProcessConfig();
842 AudioService *releaseCallbackRet = AudioService::GetInstance();
843
844 auto audioProcessInServer = std::make_shared<AudioProcessInServer>(configRet, releaseCallbackRet);
845
846 bool isStandby = true;
847 int64_t enterStandbyTime = INTELL_VOICE_SERVICR_UID;
848
849 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_SERVER_SHARED;
850 uint32_t byteSizePerFrame = SPAN_SIZE_IN_FRAME;
851 audioProcessInServer->processBuffer_ = std::make_shared<OHAudioBuffer>(bufferHolder,
852 TOTAL_SIZE_IN_FRAME, SPAN_SIZE_IN_FRAME, byteSizePerFrame);
853 EXPECT_NE(audioProcessInServer->processBuffer_, nullptr);
854
855 BasicBufferInfo basicBufferInfo;
856 audioProcessInServer->processBuffer_->basicBufferInfo_ = &basicBufferInfo;
857 EXPECT_NE(audioProcessInServer->processBuffer_->basicBufferInfo_, nullptr);
858 audioProcessInServer->processBuffer_->basicBufferInfo_->streamStatus = STREAM_STAND_BY;
859
860 audioProcessInServer->enterStandbyTime_ = DEFAULT_STREAM_ID;
861
862 auto ret = audioProcessInServer->GetStandbyStatus(isStandby, enterStandbyTime);
863 EXPECT_EQ(ret, SUCCESS);
864 EXPECT_EQ(enterStandbyTime, DEFAULT_STREAM_ID);
865 }
866
867 /**
868 * @tc.name : Test AudioProcessInServer API
869 * @tc.type : FUNC
870 * @tc.number: AudioProcessInServer_032
871 * @tc.desc : Test AudioProcessInServer interface.
872 */
873 HWTEST(AudioProcessInServerUnitTest, AudioProcessInServer_032, TestSize.Level1)
874 {
875 AudioProcessConfig configRet = InitProcessConfig();
876 AudioService *releaseCallbackRet = AudioService::GetInstance();
877
878 auto audioProcessInServer = std::make_shared<AudioProcessInServer>(configRet, releaseCallbackRet);
879
880 bool isStandby = true;
881 int64_t enterStandbyTime = INTELL_VOICE_SERVICR_UID;
882
883 AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_SERVER_SHARED;
884 uint32_t byteSizePerFrame = SPAN_SIZE_IN_FRAME;
885 audioProcessInServer->processBuffer_ = std::make_shared<OHAudioBuffer>(bufferHolder,
886 TOTAL_SIZE_IN_FRAME, SPAN_SIZE_IN_FRAME, byteSizePerFrame);
887 EXPECT_NE(audioProcessInServer->processBuffer_, nullptr);
888
889 BasicBufferInfo basicBufferInfo;
890 audioProcessInServer->processBuffer_->basicBufferInfo_ = &basicBufferInfo;
891 EXPECT_NE(audioProcessInServer->processBuffer_->basicBufferInfo_, nullptr);
892 audioProcessInServer->processBuffer_->basicBufferInfo_->streamStatus = STREAM_IDEL;
893
894 audioProcessInServer->enterStandbyTime_ = DEFAULT_STREAM_ID;
895
896 auto ret = audioProcessInServer->GetStandbyStatus(isStandby, enterStandbyTime);
897 EXPECT_EQ(ret, SUCCESS);
898 EXPECT_EQ(enterStandbyTime, 0);
899 }
900 } // namespace AudioStandard
901 } // namespace OHOS