1 /*
2 * Copyright (c) 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 <string>
18 #include <thread>
19 #include <chrono>
20 #include "test_case_common.h"
21 #include "audio_errors.h"
22 #include "hpae_capturer_manager.h"
23 #include "hpae_node_common.h"
24
25 using namespace OHOS;
26 using namespace AudioStandard;
27 using namespace HPAE;
28 using namespace testing::ext;
29 using namespace testing;
30 namespace OHOS {
31 namespace AudioStandard {
32 namespace HPAE {
33
34 static std::string g_rootCapturerPath = "/data/source_file_io_48000_2_s16le.pcm";
35 const uint32_t DEFAULT_FRAME_LENGTH = 960;
36 const uint32_t DEFAULT_SESSION_ID = 123456;
37 const uint32_t DEFAULT_NODE_ID = 1243;
38 const std::string DEFAULT_SOURCE_NAME = "Built_in_mic";
39
40 class HpaeCapturerManagerTest : public testing::Test {
41 public:
42 void SetUp();
43 void TearDown();
44 };
45
SetUp()46 void HpaeCapturerManagerTest::SetUp()
47 {}
48
TearDown()49 void HpaeCapturerManagerTest::TearDown()
50 {}
51
TestCheckSourceOutputInfo(HpaeSourceOutputInfo & sourceOutputInfo,const HpaeStreamInfo & streamInfo)52 static void TestCheckSourceOutputInfo(HpaeSourceOutputInfo& sourceOutputInfo, const HpaeStreamInfo& streamInfo)
53 {
54 EXPECT_EQ(sourceOutputInfo.nodeInfo.channels == streamInfo.channels, true);
55 EXPECT_EQ(sourceOutputInfo.nodeInfo.format == streamInfo.format, true);
56 EXPECT_EQ(sourceOutputInfo.nodeInfo.frameLen == streamInfo.frameLen, true);
57 EXPECT_EQ(sourceOutputInfo.nodeInfo.sessionId == streamInfo.sessionId, true);
58 EXPECT_EQ(sourceOutputInfo.nodeInfo.samplingRate == streamInfo.samplingRate, true);
59 EXPECT_EQ(sourceOutputInfo.nodeInfo.streamType == streamInfo.streamType, true);
60 }
61
InitSourceInfo(HpaeSourceInfo & sourceInfo)62 static void InitSourceInfo(HpaeSourceInfo &sourceInfo)
63 {
64 sourceInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
65 sourceInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
66 sourceInfo.sourceType = SOURCE_TYPE_MIC;
67 sourceInfo.filePath = g_rootCapturerPath;
68
69 sourceInfo.samplingRate = SAMPLE_RATE_48000;
70 sourceInfo.channels = STEREO;
71 sourceInfo.format = SAMPLE_S16LE;
72 sourceInfo.frameLen = DEFAULT_FRAME_LENGTH;
73 sourceInfo.ecType = HPAE_EC_TYPE_NONE;
74 sourceInfo.micRef = HPAE_REF_OFF;
75 }
76
InitReloadStreamInfo(HpaeStreamInfo & streamInfo)77 static void InitReloadStreamInfo(HpaeStreamInfo &streamInfo)
78 {
79 streamInfo.channels = STEREO;
80 streamInfo.samplingRate = SAMPLE_RATE_48000;
81 streamInfo.format = SAMPLE_S16LE;
82 streamInfo.frameLen = DEFAULT_FRAME_LENGTH;
83 streamInfo.sessionId = DEFAULT_SESSION_ID;
84 streamInfo.streamType = STREAM_MUSIC;
85 streamInfo.streamClassType = HPAE_STREAM_CLASS_TYPE_RECORD;
86 streamInfo.deviceName = "Built_in_mic";
87 }
88
WaitForMsgProcessing(std::shared_ptr<IHpaeCapturerManager> & capturerManager)89 static void WaitForMsgProcessing(std::shared_ptr<IHpaeCapturerManager> &capturerManager)
90 {
91 int waitCount = 0;
92 const int waitCountThd = 5;
93 while (capturerManager->IsMsgProcessing()) {
94 std::this_thread::sleep_for(std::chrono::milliseconds(20)); // 20 for sleep
95 waitCount++;
96 if (waitCount >= waitCountThd) {
97 break;
98 }
99 }
100 std::this_thread::sleep_for(std::chrono::milliseconds(40)); // 40 for sleep
101 EXPECT_EQ(capturerManager->IsMsgProcessing(), false);
102 EXPECT_EQ(waitCount < waitCountThd, true);
103 }
104
InitNodeInfo(HpaeNodeInfo & nodeInfo)105 static void InitNodeInfo(HpaeNodeInfo &nodeInfo)
106 {
107 nodeInfo.nodeId = DEFAULT_NODE_ID;
108 nodeInfo.frameLen = DEFAULT_FRAME_LENGTH;
109 nodeInfo.samplingRate = SAMPLE_RATE_48000;
110 nodeInfo.channels = STEREO;
111 nodeInfo.format = SAMPLE_S16LE;
112 nodeInfo.sceneType = HPAE_SCENE_RECORD;
113 nodeInfo.sourceBufferType = HPAE_SOURCE_BUFFER_TYPE_MIC;
114 }
115
116 /*
117 * tc.name : Test HpaeCapturerManager API
118 * tc.type : FUNC
119 * tc.number : HpaeCapturerManagerTest_001
120 * tc.desc : Test HpaeCapturerManagerConstructTest
121 */
122 HWTEST_F(HpaeCapturerManagerTest, HpaeCapturerManagerConstructTest, TestSize.Level0)
123 {
124 HpaeSourceInfo sourceInfo;
125 InitSourceInfo(sourceInfo);
126
127 std::shared_ptr<IHpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
128 HpaeSourceInfo dstSourceInfo = capturerManager->GetSourceInfo();
129 EXPECT_EQ(dstSourceInfo.deviceNetId == sourceInfo.deviceNetId, true);
130 EXPECT_EQ(dstSourceInfo.deviceClass == sourceInfo.deviceClass, true);
131 EXPECT_EQ(dstSourceInfo.frameLen == sourceInfo.frameLen, true);
132 EXPECT_EQ(dstSourceInfo.samplingRate == sourceInfo.samplingRate, true);
133 EXPECT_EQ(dstSourceInfo.format == sourceInfo.format, true);
134 EXPECT_EQ(dstSourceInfo.channels == sourceInfo.channels, true);
135 EXPECT_EQ(dstSourceInfo.ecType == sourceInfo.ecType, true);
136 EXPECT_EQ(dstSourceInfo.micRef == sourceInfo.micRef, true);
137 }
138
139 /*
140 * tc.name : Test HpaeCapturerManager API
141 * tc.type : FUNC
142 * tc.number : HpaeCapturerManagerTest_002
143 * tc.desc : Test HpaeCapturerManagerInitTest
144 */
145 HWTEST_F(HpaeCapturerManagerTest, HpaeCapturerManagerInitTest, TestSize.Level1)
146 {
147 HpaeSourceInfo sourceInfo;
148 InitSourceInfo(sourceInfo);
149
150 std::shared_ptr<IHpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
151 EXPECT_EQ(capturerManager->Init() == SUCCESS, true);
152 WaitForMsgProcessing(capturerManager);
153 EXPECT_EQ(capturerManager->DeInit() == SUCCESS, true);
154 WaitForMsgProcessing(capturerManager);
155 }
156
157 /*
158 * tc.name : Test HpaeCapturerManager API
159 * tc.type : FUNC
160 * tc.number : HpaeCapturerManagerTest_003
161 * tc.desc : Test HpaeCapturerManagerCreateDestoryStreamTest
162 */
163 HWTEST_F(HpaeCapturerManagerTest, HpaeCapturerManagerCreateDestoryStreamTest, TestSize.Level1)
164 {
165 HpaeSourceInfo sourceInfo;
166 InitSourceInfo(sourceInfo);
167
168 std::shared_ptr<IHpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
169 EXPECT_EQ(capturerManager->Init() == SUCCESS, true);
170 WaitForMsgProcessing(capturerManager);
171 EXPECT_EQ(capturerManager->IsInit(), true);
172 HpaeStreamInfo streamInfo;
173 InitReloadStreamInfo(streamInfo);
174 EXPECT_EQ(capturerManager->CreateStream(streamInfo) == SUCCESS, true);
175 WaitForMsgProcessing(capturerManager);
176 HpaeSourceOutputInfo sourceOutputInfo;
177 EXPECT_EQ(capturerManager->GetSourceOutputInfo(streamInfo.sessionId, sourceOutputInfo) == SUCCESS, true);
178 TestCheckSourceOutputInfo(sourceOutputInfo, streamInfo);
179 EXPECT_EQ(sourceOutputInfo.capturerSessionInfo.state, HPAE_SESSION_PREPARED);
180 EXPECT_EQ(capturerManager->DestroyStream(streamInfo.sessionId) == SUCCESS, true);
181 WaitForMsgProcessing(capturerManager);
182 EXPECT_EQ(
183 capturerManager->GetSourceOutputInfo(streamInfo.sessionId, sourceOutputInfo) == ERR_INVALID_OPERATION, true);
184 EXPECT_EQ(capturerManager->DestroyStream(streamInfo.sessionId) == SUCCESS, true);
185 WaitForMsgProcessing(capturerManager);
186 EXPECT_EQ(capturerManager->DeInit() == SUCCESS, true);
187 WaitForMsgProcessing(capturerManager);
188 }
189
StateControlTest(std::shared_ptr<IHpaeCapturerManager> & capturerManager,HpaeStreamInfo & streamInfo,HpaeSourceOutputInfo & sourceOutputInfo)190 static void StateControlTest(std::shared_ptr<IHpaeCapturerManager> &capturerManager, HpaeStreamInfo &streamInfo,
191 HpaeSourceOutputInfo &sourceOutputInfo)
192 {
193 EXPECT_EQ(capturerManager->Start(streamInfo.sessionId) == SUCCESS, true);
194 WaitForMsgProcessing(capturerManager);
195 EXPECT_EQ(capturerManager->GetSourceOutputInfo(streamInfo.sessionId, sourceOutputInfo) == SUCCESS, true);
196 EXPECT_EQ(sourceOutputInfo.capturerSessionInfo.state, HPAE_SESSION_RUNNING);
197 EXPECT_EQ(capturerManager->IsRunning(), true);
198
199 EXPECT_EQ(capturerManager->Pause(streamInfo.sessionId) == SUCCESS, true);
200 WaitForMsgProcessing(capturerManager);
201 EXPECT_EQ(capturerManager->GetSourceOutputInfo(streamInfo.sessionId, sourceOutputInfo) == SUCCESS, true);
202 EXPECT_EQ(sourceOutputInfo.capturerSessionInfo.state, HPAE_SESSION_PAUSED);
203 EXPECT_EQ(capturerManager->IsRunning(), false);
204
205 EXPECT_EQ(capturerManager->Start(streamInfo.sessionId) == SUCCESS, true);
206 WaitForMsgProcessing(capturerManager);
207 EXPECT_EQ(capturerManager->GetSourceOutputInfo(streamInfo.sessionId, sourceOutputInfo) == SUCCESS, true);
208 EXPECT_EQ(sourceOutputInfo.capturerSessionInfo.state, HPAE_SESSION_RUNNING);
209 EXPECT_EQ(capturerManager->IsRunning(), true);
210
211 EXPECT_EQ(capturerManager->Stop(streamInfo.sessionId) == SUCCESS, true);
212 WaitForMsgProcessing(capturerManager);
213 EXPECT_EQ(capturerManager->GetSourceOutputInfo(streamInfo.sessionId, sourceOutputInfo) == SUCCESS, true);
214 EXPECT_EQ(sourceOutputInfo.capturerSessionInfo.state, HPAE_SESSION_STOPPED);
215 EXPECT_EQ(capturerManager->IsRunning(), false);
216
217 EXPECT_EQ(capturerManager->DestroyStream(streamInfo.sessionId) == SUCCESS, true);
218 WaitForMsgProcessing(capturerManager);
219 EXPECT_EQ(
220 capturerManager->GetSourceOutputInfo(streamInfo.sessionId, sourceOutputInfo) == ERR_INVALID_OPERATION, true);
221 EXPECT_EQ(capturerManager->IsRunning(), false);
222 }
223
224 /*
225 * tc.name : Test HpaeCapturerManager API
226 * tc.type : FUNC
227 * tc.number : HpaeCapturerManagerTest_004
228 * tc.desc : Test HpaeCapturerManagerStartStopTest
229 */
230 HWTEST_F(HpaeCapturerManagerTest, HpaeCapturerManagerStartStopTest, TestSize.Level1)
231 {
232 HpaeSourceInfo sourceInfo;
233 InitSourceInfo(sourceInfo);
234
235 std::shared_ptr<IHpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
236 EXPECT_EQ(capturerManager->Init() == SUCCESS, true);
237 WaitForMsgProcessing(capturerManager);
238 EXPECT_EQ(capturerManager->IsInit(), true);
239
240 HpaeStreamInfo streamInfo;
241 InitReloadStreamInfo(streamInfo);
242 EXPECT_EQ(capturerManager->CreateStream(streamInfo) == SUCCESS, true);
243 WaitForMsgProcessing(capturerManager);
244
245 HpaeSourceOutputInfo sourceOutputInfo;
246 EXPECT_EQ(capturerManager->GetSourceOutputInfo(streamInfo.sessionId, sourceOutputInfo) == SUCCESS, true);
247 TestCheckSourceOutputInfo(sourceOutputInfo, streamInfo);
248 EXPECT_EQ(sourceOutputInfo.capturerSessionInfo.state, HPAE_SESSION_PREPARED);
249 EXPECT_EQ(capturerManager->IsRunning(), false);
250
251 std::shared_ptr<ReadDataCb> readDataCb =
252 std::make_shared<ReadDataCb>(g_rootCapturerPath);
253 EXPECT_EQ(capturerManager->RegisterReadCallback(streamInfo.sessionId, readDataCb), SUCCESS);
254 EXPECT_EQ(readDataCb.use_count() == 1, true);
255
256 StateControlTest(capturerManager, streamInfo, sourceOutputInfo);
257 EXPECT_EQ(capturerManager->DeInit() == SUCCESS, true);
258 WaitForMsgProcessing(capturerManager);
259 }
260
InitReloadSourceInfo(HpaeSourceInfo & sourceInfo,HpaeSourceInfo & newSourceInfo)261 static void InitReloadSourceInfo(HpaeSourceInfo &sourceInfo, HpaeSourceInfo &newSourceInfo)
262 {
263 sourceInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
264 sourceInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
265 sourceInfo.sourceType = SOURCE_TYPE_MIC;
266 sourceInfo.filePath = g_rootCapturerPath;
267
268 sourceInfo.samplingRate = SAMPLE_RATE_48000;
269 sourceInfo.channels = STEREO;
270 sourceInfo.format = SAMPLE_S16LE;
271 sourceInfo.frameLen = DEFAULT_FRAME_LENGTH;
272 sourceInfo.ecType = HPAE_EC_TYPE_NONE;
273 sourceInfo.micRef = HPAE_REF_OFF;
274
275 newSourceInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
276 newSourceInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
277 newSourceInfo.sourceType = SOURCE_TYPE_VOICE_TRANSCRIPTION;
278 newSourceInfo.filePath = g_rootCapturerPath;
279
280 newSourceInfo.samplingRate = SAMPLE_RATE_48000;
281 newSourceInfo.channels = STEREO;
282 newSourceInfo.format = SAMPLE_S16LE;
283 newSourceInfo.frameLen = DEFAULT_FRAME_LENGTH;
284 newSourceInfo.ecType = HPAE_EC_TYPE_SAME_ADAPTER;
285 newSourceInfo.micRef = HPAE_REF_OFF;
286 }
287
288 /*
289 * tc.name : Test HpaeCapturerManager API
290 * tc.type : FUNC
291 * tc.number : HpaeCapturerManagerTest_005
292 * tc.desc : Test HpaeCapturerManagerReloadTest
293 */
294 HWTEST_F(HpaeCapturerManagerTest, HpaeCapturerManagerReloadTest, TestSize.Level1)
295 {
296 HpaeSourceInfo sourceInfo;
297 HpaeSourceInfo newSourceInfo;
298 InitReloadSourceInfo(sourceInfo, newSourceInfo);
299
300 std::shared_ptr<IHpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
301 EXPECT_EQ(capturerManager->Init() == SUCCESS, true);
302 WaitForMsgProcessing(capturerManager);
303 EXPECT_EQ(capturerManager->IsInit(), true);
304 HpaeStreamInfo streamInfo;
305 InitReloadStreamInfo(streamInfo);
306 EXPECT_EQ(capturerManager->CreateStream(streamInfo) == SUCCESS, true);
307 WaitForMsgProcessing(capturerManager);
308 HpaeSourceOutputInfo sourceOutputInfo;
309 EXPECT_EQ(capturerManager->GetSourceOutputInfo(streamInfo.sessionId, sourceOutputInfo) == SUCCESS, true);
310 TestCheckSourceOutputInfo(sourceOutputInfo, streamInfo);
311 EXPECT_EQ(sourceOutputInfo.capturerSessionInfo.state, HPAE_SESSION_PREPARED);
312 EXPECT_EQ(capturerManager->ReloadCaptureManager(newSourceInfo) == SUCCESS, true);
313 WaitForMsgProcessing(capturerManager);
314 EXPECT_EQ(capturerManager->GetSourceOutputInfo(streamInfo.sessionId, sourceOutputInfo) == SUCCESS, true);
315 EXPECT_EQ(capturerManager->DeInit() == SUCCESS, true);
316 WaitForMsgProcessing(capturerManager);
317 }
318
319 /*
320 * tc.name : Test HpaeCapturerManager API
321 * tc.type : FUNC
322 * tc.number : HpaeCapturerManagerTest
323 * tc.desc : Test CreateOutputSession_001
324 */
325 HWTEST_F(HpaeCapturerManagerTest, CreateOutputSession_001, TestSize.Level0)
326 {
327 HpaeSourceInfo sourceInfo;
328 InitSourceInfo(sourceInfo);
329
330 std::shared_ptr<HpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
331 EXPECT_NE(capturerManager, nullptr);
332
333 HpaeStreamInfo streamInfo;
334 InitReloadStreamInfo(streamInfo);
335 streamInfo.sourceType = SOURCE_TYPE_MIC;
336
337 EXPECT_EQ(capturerManager->CreateOutputSession(streamInfo), SUCCESS);
338 }
339
340 /*
341 * tc.name : Test HpaeCapturerManager API
342 * tc.type : FUNC
343 * tc.number : HpaeCapturerManagerTest
344 * tc.desc : Test CreateOutputSession_002
345 */
346 HWTEST_F(HpaeCapturerManagerTest, CreateOutputSession_002, TestSize.Level0)
347 {
348 HpaeSourceInfo sourceInfo;
349 InitSourceInfo(sourceInfo);
350
351 std::shared_ptr<HpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
352 EXPECT_NE(capturerManager, nullptr);
353
354 HpaeStreamInfo streamInfo;
355 InitReloadStreamInfo(streamInfo);
356 streamInfo.sourceType = SOURCE_TYPE_WAKEUP;
357
358 EXPECT_EQ(capturerManager->CreateOutputSession(streamInfo), SUCCESS);
359 }
360
361 /*
362 * tc.name : Test HpaeCapturerManager API
363 * tc.type : FUNC
364 * tc.number : HpaeCapturerManagerTest
365 * tc.desc : Test DisConnectSceneClusterFromSourceInputCluster_001
366 */
367 HWTEST_F(HpaeCapturerManagerTest, DisConnectSceneClusterFromSourceInputCluster_001, TestSize.Level0)
368 {
369 HpaeSourceInfo sourceInfo;
370 InitSourceInfo(sourceInfo);
371
372 std::shared_ptr<HpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
373 EXPECT_NE(capturerManager, nullptr);
374
375 HpaeProcessorType sceneType = HPAE_SCENE_VOIP_UP;
376 capturerManager->DisConnectSceneClusterFromSourceInputCluster(sceneType);
377 EXPECT_NE(capturerManager, nullptr);
378 }
379
380 /*
381 * tc.name : Test HpaeCapturerManager API
382 * tc.type : FUNC
383 * tc.number : HpaeCapturerManagerTest
384 * tc.desc : Test DeleteOutputSession_001
385 */
386 HWTEST_F(HpaeCapturerManagerTest, DeleteOutputSession_001, TestSize.Level0)
387 {
388 HpaeSourceInfo sourceInfo;
389 InitSourceInfo(sourceInfo);
390
391 std::shared_ptr<HpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
392 EXPECT_NE(capturerManager, nullptr);
393
394 EXPECT_EQ(capturerManager->DeleteOutputSession(DEFAULT_SESSION_ID), SUCCESS);
395 }
396
397 /*
398 * tc.name : Test HpaeCapturerManager API
399 * tc.type : FUNC
400 * tc.number : HpaeCapturerManagerTest
401 * tc.desc : Test CreateStream_001
402 */
403 HWTEST_F(HpaeCapturerManagerTest, CreateStream_001, TestSize.Level0)
404 {
405 HpaeSourceInfo sourceInfo;
406 InitSourceInfo(sourceInfo);
407
408 std::shared_ptr<HpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
409 EXPECT_NE(capturerManager, nullptr);
410
411 HpaeStreamInfo info;
412 EXPECT_EQ(capturerManager->CreateStream(info), ERR_INVALID_OPERATION);
413 }
414
415 /*
416 * tc.name : Test HpaeCapturerManager API
417 * tc.type : FUNC
418 * tc.number : HpaeCapturerManagerTest
419 * tc.desc : Test DestroyStream_001
420 */
421 HWTEST_F(HpaeCapturerManagerTest, DestroyStream_001, TestSize.Level0)
422 {
423 HpaeSourceInfo sourceInfo;
424 InitSourceInfo(sourceInfo);
425
426 std::shared_ptr<HpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
427 EXPECT_NE(capturerManager, nullptr);
428
429 EXPECT_EQ(capturerManager->DestroyStream(DEFAULT_SESSION_ID), ERR_INVALID_OPERATION);
430 }
431
432 /*
433 * tc.name : Test HpaeCapturerManager API
434 * tc.type : FUNC
435 * tc.number : HpaeCapturerManagerTest
436 * tc.desc : Test Flush_001
437 */
438 HWTEST_F(HpaeCapturerManagerTest, Flush_001, TestSize.Level0)
439 {
440 HpaeSourceInfo sourceInfo;
441 InitSourceInfo(sourceInfo);
442
443 std::shared_ptr<HpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
444 EXPECT_NE(capturerManager, nullptr);
445
446 EXPECT_EQ(capturerManager->Flush(DEFAULT_SESSION_ID), ERR_INVALID_OPERATION);
447 }
448
449 /*
450 * tc.name : Test HpaeCapturerManager API
451 * tc.type : FUNC
452 * tc.number : HpaeCapturerManagerTest
453 * tc.desc : Test Flush_002
454 */
455 HWTEST_F(HpaeCapturerManagerTest, Flush_002, TestSize.Level1)
456 {
457 HpaeSourceInfo sourceInfo;
458 InitSourceInfo(sourceInfo);
459
460 std::shared_ptr<IHpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
461 EXPECT_NE(capturerManager, nullptr);
462 EXPECT_EQ(capturerManager->Init(), SUCCESS);
463 WaitForMsgProcessing(capturerManager);
464 EXPECT_EQ(capturerManager->IsInit(), true);
465 HpaeStreamInfo streamInfo;
466 InitReloadStreamInfo(streamInfo);
467 EXPECT_EQ(capturerManager->CreateStream(streamInfo), SUCCESS);
468 WaitForMsgProcessing(capturerManager);
469 EXPECT_EQ(capturerManager->Flush(DEFAULT_SESSION_ID), SUCCESS);
470 EXPECT_EQ(capturerManager->DeInit(DEFAULT_SESSION_ID), SUCCESS);
471 WaitForMsgProcessing(capturerManager);
472 }
473
474 /*
475 * tc.name : Test HpaeCapturerManager API
476 * tc.type : FUNC
477 * tc.number : HpaeCapturerManagerTest
478 * tc.desc : Test Drain_001
479 */
480 HWTEST_F(HpaeCapturerManagerTest, Drain_001, TestSize.Level0)
481 {
482 HpaeSourceInfo sourceInfo;
483 InitSourceInfo(sourceInfo);
484
485 std::shared_ptr<HpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
486 EXPECT_NE(capturerManager, nullptr);
487
488 EXPECT_EQ(capturerManager->Drain(DEFAULT_SESSION_ID), ERR_INVALID_OPERATION);
489 }
490
491 /*
492 * tc.name : Test HpaeCapturerManager API
493 * tc.type : FUNC
494 * tc.number : HpaeCapturerManagerTest
495 * tc.desc : Test Drain_002
496 */
497 HWTEST_F(HpaeCapturerManagerTest, Drain_002, TestSize.Level1)
498 {
499 HpaeSourceInfo sourceInfo;
500 InitSourceInfo(sourceInfo);
501
502 std::shared_ptr<IHpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
503 EXPECT_NE(capturerManager, nullptr);
504 EXPECT_EQ(capturerManager->Init(), SUCCESS);
505 WaitForMsgProcessing(capturerManager);
506 EXPECT_EQ(capturerManager->IsInit(), true);
507 HpaeStreamInfo streamInfo;
508 InitReloadStreamInfo(streamInfo);
509 EXPECT_EQ(capturerManager->CreateStream(streamInfo), SUCCESS);
510 WaitForMsgProcessing(capturerManager);
511 EXPECT_EQ(capturerManager->Drain(DEFAULT_SESSION_ID), SUCCESS);
512 EXPECT_EQ(capturerManager->DeInit(DEFAULT_SESSION_ID), SUCCESS);
513 WaitForMsgProcessing(capturerManager);
514 }
515
516 /*
517 * tc.name : Test HpaeCapturerManager API
518 * tc.type : FUNC
519 * tc.number : HpaeCapturerManagerTest
520 * tc.desc : Test Release_001
521 */
522 HWTEST_F(HpaeCapturerManagerTest, Release_001, TestSize.Level0)
523 {
524 HpaeSourceInfo sourceInfo;
525 InitSourceInfo(sourceInfo);
526
527 std::shared_ptr<HpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
528 EXPECT_NE(capturerManager, nullptr);
529
530 EXPECT_EQ(capturerManager->Release(DEFAULT_SESSION_ID), ERR_INVALID_OPERATION);
531 }
532
533 /*
534 * tc.name : Test HpaeCapturerManager API
535 * tc.type : FUNC
536 * tc.number : HpaeCapturerManagerTest
537 * tc.desc : Test SetMute_001
538 */
539 HWTEST_F(HpaeCapturerManagerTest, SetMute_001, TestSize.Level0)
540 {
541 HpaeSourceInfo sourceInfo;
542 InitSourceInfo(sourceInfo);
543
544 std::shared_ptr<HpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
545 EXPECT_NE(capturerManager, nullptr);
546
547 EXPECT_EQ(capturerManager->SetMute(false), SUCCESS);
548 }
549
550 /*
551 * tc.name : Test HpaeCapturerManager API
552 * tc.type : FUNC
553 * tc.number : HpaeCapturerManagerTest
554 * tc.desc : Test SetMute_002
555 */
556 HWTEST_F(HpaeCapturerManagerTest, SetMute_002, TestSize.Level0)
557 {
558 HpaeSourceInfo sourceInfo;
559 InitSourceInfo(sourceInfo);
560
561 std::shared_ptr<HpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
562 EXPECT_NE(capturerManager, nullptr);
563
564 EXPECT_EQ(capturerManager->SetMute(true), SUCCESS);
565 }
566
567 /*
568 * tc.name : Test HpaeCapturerManager API
569 * tc.type : FUNC
570 * tc.number : HpaeCapturerManagerTest
571 * tc.desc : Test PrepareCapturerEc_001
572 */
573 HWTEST_F(HpaeCapturerManagerTest, PrepareCapturerEc_001, TestSize.Level0)
574 {
575 HpaeSourceInfo sourceInfo;
576 InitSourceInfo(sourceInfo);
577 sourceInfo.ecType = HPAE_EC_TYPE_DIFF_ADAPTER;
578
579 std::shared_ptr<HpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
580 EXPECT_NE(capturerManager, nullptr);
581
582 HpaeNodeInfo nodeInfo;
583 InitNodeInfo(nodeInfo);
584 EXPECT_EQ(capturerManager->PrepareCapturerEc(nodeInfo), SUCCESS);
585 }
586
587 /*
588 * tc.name : Test HpaeCapturerManager API
589 * tc.type : FUNC
590 * tc.number : HpaeCapturerManagerTest
591 * tc.desc : Test PrepareCapturerMicRef_001
592 */
593 HWTEST_F(HpaeCapturerManagerTest, PrepareCapturerMicRef_001, TestSize.Level0)
594 {
595 HpaeSourceInfo sourceInfo;
596 InitSourceInfo(sourceInfo);
597 sourceInfo.micRef = HPAE_REF_ON;
598
599 std::shared_ptr<HpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
600 EXPECT_NE(capturerManager, nullptr);
601
602 HpaeNodeInfo nodeInfo;
603 InitNodeInfo(nodeInfo);
604 EXPECT_EQ(capturerManager->PrepareCapturerMicRef(nodeInfo), SUCCESS);
605 }
606
607 /*
608 * tc.name : Test HpaeCapturerManager API
609 * tc.type : FUNC
610 * tc.number : HpaeCapturerManagerTest
611 * tc.desc : Test ReloadCaptureManager_001
612 */
613 HWTEST_F(HpaeCapturerManagerTest, ReloadCaptureManager_001, TestSize.Level0)
614 {
615 HpaeSourceInfo sourceInfo;
616 InitSourceInfo(sourceInfo);
617
618 std::shared_ptr<HpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
619 EXPECT_NE(capturerManager, nullptr);
620
621 EXPECT_EQ(capturerManager->ReloadCaptureManager(sourceInfo), SUCCESS);
622 }
623
624 /*
625 * tc.name : Test HpaeCapturerManager API
626 * tc.type : FUNC
627 * tc.number : HpaeCapturerManagerTest
628 * tc.desc : Test ReloadCaptureManager_002
629 */
630 HWTEST_F(HpaeCapturerManagerTest, ReloadCaptureManager_002, TestSize.Level0)
631 {
632 HpaeSourceInfo sourceInfo;
633 InitSourceInfo(sourceInfo);
634
635 std::shared_ptr<HpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
636 EXPECT_NE(capturerManager, nullptr);
637
638 capturerManager->isInit_ = true;
639 EXPECT_EQ(capturerManager->ReloadCaptureManager(sourceInfo), SUCCESS);
640 }
641
642 /*
643 * tc.name : Test HpaeCapturerManager API
644 * tc.type : FUNC
645 * tc.number : HpaeCapturerManagerTest
646 * tc.desc : Test DeInit_001
647 */
648 HWTEST_F(HpaeCapturerManagerTest, DeInit_001, TestSize.Level0)
649 {
650 HpaeSourceInfo sourceInfo;
651 InitSourceInfo(sourceInfo);
652
653 std::shared_ptr<HpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
654 EXPECT_NE(capturerManager, nullptr);
655
656 EXPECT_EQ(capturerManager->DeInit(true), ERR_INVALID_OPERATION);
657 }
658
659 /*
660 * tc.name : Test HpaeCapturerManager API
661 * tc.type : FUNC
662 * tc.number : HpaeCapturerManagerTest
663 * tc.desc : Test DeactivateThread_001
664 */
665 HWTEST_F(HpaeCapturerManagerTest, DeactivateThread_001, TestSize.Level0)
666 {
667 HpaeSourceInfo sourceInfo;
668 InitSourceInfo(sourceInfo);
669
670 std::shared_ptr<HpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
671 EXPECT_NE(capturerManager, nullptr);
672
673 EXPECT_EQ(capturerManager->DeactivateThread(), true);
674 }
675
676 /*
677 * tc.name : Test HpaeCapturerManager API
678 * tc.type : FUNC
679 * tc.number : HpaeCapturerManagerTest
680 * tc.desc : Test RegisterReadCallback_001
681 */
682 HWTEST_F(HpaeCapturerManagerTest, RegisterReadCallback_001, TestSize.Level0)
683 {
684 HpaeSourceInfo sourceInfo;
685 InitSourceInfo(sourceInfo);
686
687 std::shared_ptr<HpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
688 EXPECT_NE(capturerManager, nullptr);
689
690 std::shared_ptr<ReadDataCb> readDataCb =
691 std::make_shared<ReadDataCb>(g_rootCapturerPath);
692 EXPECT_EQ(capturerManager->RegisterReadCallback(DEFAULT_SESSION_ID, readDataCb), SUCCESS);
693 }
694
695 /*
696 * tc.name : Test HpaeCapturerManager API
697 * tc.type : FUNC
698 * tc.number : HpaeCapturerManagerTest
699 * tc.desc : Test GetSourceOutputInfo_001
700 */
701 HWTEST_F(HpaeCapturerManagerTest, GetSourceOutputInfo_001, TestSize.Level0)
702 {
703 HpaeSourceInfo sourceInfo;
704 InitSourceInfo(sourceInfo);
705
706 std::shared_ptr<HpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
707 EXPECT_NE(capturerManager, nullptr);
708
709 HpaeSourceOutputInfo sourceOutputInfo;
710 EXPECT_EQ(capturerManager->GetSourceOutputInfo(DEFAULT_SESSION_ID, sourceOutputInfo), ERR_INVALID_OPERATION);
711 }
712
713 /*
714 * tc.name : Test HpaeCapturerManager API
715 * tc.type : FUNC
716 * tc.number : HpaeCapturerManagerTest
717 * tc.desc : Test GetAllSourceOutputsInfo_001
718 */
719 HWTEST_F(HpaeCapturerManagerTest, GetAllSourceOutputsInfo_001, TestSize.Level0)
720 {
721 HpaeSourceInfo sourceInfo;
722 InitSourceInfo(sourceInfo);
723
724 std::shared_ptr<HpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
725 EXPECT_NE(capturerManager, nullptr);
726
727 std::vector<SourceOutput> sourceOutputInfos = capturerManager->GetAllSourceOutputsInfo();
728 EXPECT_EQ(sourceOutputInfos.size() == 0, true);
729 }
730
731 /*
732 * tc.name : Test HpaeCapturerManager API
733 * tc.type : FUNC
734 * tc.number : HpaeCapturerManagerTest
735 * tc.desc : Test OnNodeStatusUpdate_001
736 */
737 HWTEST_F(HpaeCapturerManagerTest, OnNodeStatusUpdate_001, TestSize.Level0)
738 {
739 HpaeSourceInfo sourceInfo;
740 InitSourceInfo(sourceInfo);
741
742 std::shared_ptr<HpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
743 EXPECT_NE(capturerManager, nullptr);
744
745 capturerManager->OnNodeStatusUpdate(DEFAULT_SESSION_ID, OPERATION_STOPPED);
746 EXPECT_NE(capturerManager, nullptr);
747 }
748
749 /*
750 * tc.name : Test HpaeCapturerManager API
751 * tc.type : FUNC
752 * tc.number : HpaeCapturerManagerTest
753 * tc.desc : Test AddAllNodesToSource_001
754 */
755 HWTEST_F(HpaeCapturerManagerTest, AddAllNodesToSource_001, TestSize.Level0)
756 {
757 HpaeSourceInfo sourceInfo;
758 InitSourceInfo(sourceInfo);
759
760 std::shared_ptr<HpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
761 EXPECT_NE(capturerManager, nullptr);
762
763 std::vector<HpaeCaptureMoveInfo> moveInfos;
764 EXPECT_EQ(capturerManager->AddAllNodesToSource(moveInfos, true), SUCCESS);
765 }
766
767 /*
768 * tc.name : Test HpaeCapturerManager API
769 * tc.type : FUNC
770 * tc.number : HpaeCapturerManagerTest
771 * tc.desc : Test MoveAllStream_001
772 */
773 HWTEST_F(HpaeCapturerManagerTest, MoveAllStream_001, TestSize.Level0)
774 {
775 HpaeSourceInfo sourceInfo;
776 InitSourceInfo(sourceInfo);
777
778 std::shared_ptr<HpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
779 EXPECT_NE(capturerManager, nullptr);
780
781 std::vector<uint32_t> sessionIds;
782 EXPECT_EQ(capturerManager->MoveAllStream(DEFAULT_SOURCE_NAME, sessionIds, MOVE_ALL), SUCCESS);
783 }
784
785 /*
786 * tc.name : Test HpaeCapturerManager API
787 * tc.type : FUNC
788 * tc.number : HpaeCapturerManagerTest
789 * tc.desc : Test MoveAllStream_002
790 */
791 HWTEST_F(HpaeCapturerManagerTest, MoveAllStream_002, TestSize.Level0)
792 {
793 HpaeSourceInfo sourceInfo;
794 InitSourceInfo(sourceInfo);
795
796 std::shared_ptr<HpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
797 EXPECT_NE(capturerManager, nullptr);
798
799 capturerManager->isInit_ = true;
800 std::vector<uint32_t> sessionIds;
801 EXPECT_EQ(capturerManager->MoveAllStream(DEFAULT_SOURCE_NAME, sessionIds, MOVE_ALL), SUCCESS);
802 }
803
804 /*
805 * tc.name : Test HpaeCapturerManager API
806 * tc.type : FUNC
807 * tc.number : HpaeCapturerManagerTest
808 * tc.desc : Test MoveAllStreamToNewSource_001
809 */
810 HWTEST_F(HpaeCapturerManagerTest, MoveAllStreamToNewSource_001, TestSize.Level0)
811 {
812 HpaeSourceInfo sourceInfo;
813 InitSourceInfo(sourceInfo);
814
815 std::shared_ptr<HpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
816 EXPECT_NE(capturerManager, nullptr);
817
818 std::vector<uint32_t> moveIds;
819 capturerManager->MoveAllStreamToNewSource(DEFAULT_SOURCE_NAME, moveIds, MOVE_SINGLE);
820 EXPECT_NE(capturerManager, nullptr);
821 }
822
823 /*
824 * tc.name : Test HpaeCapturerManager API
825 * tc.type : FUNC
826 * tc.number : HpaeCapturerManagerTest
827 * tc.desc : Test MoveAllStreamToNewSource_002
828 */
829 HWTEST_F(HpaeCapturerManagerTest, MoveAllStreamToNewSource_002, TestSize.Level0)
830 {
831 HpaeSourceInfo sourceInfo;
832 InitSourceInfo(sourceInfo);
833
834 std::shared_ptr<HpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
835 EXPECT_NE(capturerManager, nullptr);
836
837 std::vector<uint32_t> moveIds;
838 capturerManager->MoveAllStreamToNewSource(DEFAULT_SOURCE_NAME, moveIds, MOVE_ALL);
839 EXPECT_NE(capturerManager, nullptr);
840 }
841
842 /*
843 * tc.name : Test HpaeCapturerManager API
844 * tc.type : FUNC
845 * tc.number : HpaeCapturerManagerTest
846 * tc.desc : Test OnRequestLatency_001
847 */
848 HWTEST_F(HpaeCapturerManagerTest, OnRequestLatency_001, TestSize.Level0)
849 {
850 HpaeSourceInfo sourceInfo;
851 InitSourceInfo(sourceInfo);
852
853 std::shared_ptr<HpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
854 EXPECT_NE(capturerManager, nullptr);
855
856 uint64_t latency = 0;
857 capturerManager->OnRequestLatency(DEFAULT_SESSION_ID, latency);
858 EXPECT_NE(capturerManager, nullptr);
859 }
860
861 /*
862 * tc.name : Test HpaeCapturerManager API
863 * tc.type : FUNC
864 * tc.number : HpaeCapturerManagerTest
865 * tc.desc : Test DumpSourceInfo_001
866 */
867 HWTEST_F(HpaeCapturerManagerTest, DumpSourceInfo_001, TestSize.Level0)
868 {
869 HpaeSourceInfo sourceInfo;
870 InitSourceInfo(sourceInfo);
871
872 std::shared_ptr<HpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
873 EXPECT_NE(capturerManager, nullptr);
874
875 capturerManager->DumpSourceInfo();
876 EXPECT_NE(capturerManager, nullptr);
877 }
878
879 /*
880 * tc.name : Test HpaeCapturerManager API
881 * tc.type : FUNC
882 * tc.number : HpaeCapturerManagerTest
883 * tc.desc : Test GetDeviceHDFDumpInfo_001
884 */
885 HWTEST_F(HpaeCapturerManagerTest, GetDeviceHDFDumpInfo_001, TestSize.Level0)
886 {
887 HpaeSourceInfo sourceInfo;
888 InitSourceInfo(sourceInfo);
889
890 std::shared_ptr<HpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
891 EXPECT_NE(capturerManager, nullptr);
892
893 std::string config = capturerManager->GetDeviceHDFDumpInfo();
894 std::string info;
895 TransDeviceInfoToString(sourceInfo, info);
896 EXPECT_EQ(config == info, true);
897 }
898
899 /*
900 * tc.name : Test HpaeCapturerManager API
901 * tc.type : FUNC
902 * tc.number : HpaeCapturerManagerTest
903 * tc.desc : Test CheckEcAndMicRefCondition_001
904 */
905 HWTEST_F(HpaeCapturerManagerTest, CheckEcAndMicRefCondition_001, TestSize.Level0)
906 {
907 HpaeSourceInfo sourceInfo;
908 InitSourceInfo(sourceInfo);
909 sourceInfo.ecType = HPAE_EC_TYPE_SAME_ADAPTER;
910 sourceInfo.micRef = HPAE_REF_ON;
911
912 std::shared_ptr<HpaeCapturerManager> capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
913 EXPECT_NE(capturerManager, nullptr);
914
915 HpaeProcessorType sceneType = HPAE_SCENE_VOIP_UP;
916 HpaeNodeInfo ecNodeInfo;
917 HpaeSourceInputNodeType ecNodeType = HPAE_SOURCE_DEFAULT;
918 EXPECT_EQ(capturerManager->CheckEcCondition(sceneType, ecNodeInfo, ecNodeType), false);
919
920 HpaeNodeInfo micRefNodeInfo;
921 EXPECT_EQ(capturerManager->CheckMicRefCondition(sceneType, micRefNodeInfo), false);
922 }
923 } // namespace HPAE
924 } // namespace AudioStandard
925 } // namespace OHOS