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 "test_case_common.h"
18 #include "hpae_inner_capturer_manager.h"
19 #include <string>
20 #include "audio_errors.h"
21 #include <thread>
22 #include <chrono>
23
24 using namespace OHOS;
25 using namespace AudioStandard;
26 using namespace HPAE;
27 using namespace testing::ext;
28 using namespace testing;
29 namespace OHOS {
30 namespace AudioStandard {
31 namespace HPAE {
32 const uint32_t DEFAULT_SESSION_ID = 123456;
33 const float FRAME_LENGTH_IN_SECOND = 0.02;
34 std::string g_rootPath = "/data/";
35
36
GetInCapSinkInfo()37 static HpaeSinkInfo GetInCapSinkInfo()
38 {
39 HpaeSinkInfo sinkInfo;
40 sinkInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
41 sinkInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
42 sinkInfo.adapterName = DEFAULT_TEST_DEVICE_CLASS;
43 sinkInfo.filePath = g_rootPath + "constructHpaeInnerCapturerManagerTest.pcm";
44 sinkInfo.samplingRate = SAMPLE_RATE_48000;
45 sinkInfo.frameLen = SAMPLE_RATE_48000 * FRAME_LENGTH_IN_SECOND;
46 sinkInfo.format = SAMPLE_F32LE;
47 sinkInfo.channels = STEREO;
48 sinkInfo.deviceType = DEVICE_TYPE_SPEAKER;
49 return sinkInfo;
50 }
51
52 class HpaeInnerCapturerManagerUnitTest : public testing::Test {
53 public:
54 void SetUp();
55 void TearDown();
56 std::shared_ptr<HpaeInnerCapturerManager> hpaeInnerCapturerManager_ = nullptr;
57 };
58
SetUp(void)59 void HpaeInnerCapturerManagerUnitTest::SetUp(void)
60 {
61 HpaeSinkInfo sinkInfo = GetInCapSinkInfo();
62 hpaeInnerCapturerManager_ = std::make_shared<HPAE::HpaeInnerCapturerManager>(sinkInfo);
63 }
64
TearDown(void)65 void HpaeInnerCapturerManagerUnitTest::TearDown(void)
66 {
67 hpaeInnerCapturerManager_->DeInit();
68 hpaeInnerCapturerManager_ = nullptr;
69 }
70
GetInCapPlayStreamInfo()71 static HpaeStreamInfo GetInCapPlayStreamInfo()
72 {
73 HpaeStreamInfo streamInfo;
74 streamInfo.channels = STEREO;
75 streamInfo.samplingRate = SAMPLE_RATE_44100;
76 streamInfo.frameLen = SAMPLE_RATE_44100 * FRAME_LENGTH_IN_SECOND;
77 streamInfo.format = SAMPLE_S16LE;
78 streamInfo.sessionId = DEFAULT_SESSION_ID + 1;
79 streamInfo.streamType = STREAM_MUSIC;
80 streamInfo.streamClassType = HPAE_STREAM_CLASS_TYPE_PLAY;
81 streamInfo.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE;
82 return streamInfo;
83 }
84
GetInCapRecordStreamInfo()85 static HpaeStreamInfo GetInCapRecordStreamInfo()
86 {
87 HpaeStreamInfo streamInfo;
88 streamInfo.channels = STEREO;
89 streamInfo.samplingRate = SAMPLE_RATE_44100;
90 streamInfo.frameLen = SAMPLE_RATE_44100 * FRAME_LENGTH_IN_SECOND;
91 streamInfo.format = SAMPLE_S16LE;
92 streamInfo.sessionId = DEFAULT_SESSION_ID;
93 streamInfo.streamType = STREAM_MUSIC;
94 streamInfo.streamClassType = HPAE_STREAM_CLASS_TYPE_RECORD;
95 streamInfo.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE;
96 return streamInfo;
97 }
98
WaitForMsgProcessing(std::shared_ptr<HpaeInnerCapturerManager> & hpaeInnerCapturerManager)99 static void WaitForMsgProcessing(std::shared_ptr<HpaeInnerCapturerManager>& hpaeInnerCapturerManager)
100 {
101 int waitCount = 0;
102 const int32_t waitCountThd = 5; // 5ms
103 while (hpaeInnerCapturerManager->IsMsgProcessing()) {
104 std::this_thread::sleep_for(std::chrono::milliseconds(20)); // 20ms frameLen, need optimize
105 waitCount++;
106 if (waitCount >= waitCountThd) {
107 break;
108 }
109 }
110 std::this_thread::sleep_for(std::chrono::milliseconds(40)); // 40ms wait time, need optimize
111 EXPECT_EQ(hpaeInnerCapturerManager->IsMsgProcessing(), false);
112 EXPECT_EQ(waitCount < waitCountThd, true);
113 }
114
115 /**
116 * @tc.name : Test Construct
117 * @tc.type : FUNC
118 * @tc.number: Construct_001
119 * @tc.desc : Test Construct when config in vaild.
120 */
121 HWTEST_F(HpaeInnerCapturerManagerUnitTest, Construct_001, TestSize.Level1)
122 {
123 EXPECT_NE(hpaeInnerCapturerManager_, nullptr);
124 EXPECT_EQ(hpaeInnerCapturerManager_->Init(), SUCCESS);
125 WaitForMsgProcessing(hpaeInnerCapturerManager_);
126 HpaeSinkInfo sinkInfo = GetInCapSinkInfo();
127 HpaeSinkInfo dstSinkInfo = hpaeInnerCapturerManager_->GetSinkInfo();
128 EXPECT_EQ(dstSinkInfo.deviceNetId == sinkInfo.deviceNetId, true);
129 EXPECT_EQ(dstSinkInfo.deviceClass == sinkInfo.deviceClass, true);
130 EXPECT_EQ(dstSinkInfo.adapterName == sinkInfo.adapterName, true);
131 EXPECT_EQ(dstSinkInfo.frameLen == sinkInfo.frameLen, true);
132 EXPECT_EQ(dstSinkInfo.samplingRate == sinkInfo.samplingRate, true);
133 EXPECT_EQ(dstSinkInfo.format == sinkInfo.format, true);
134 EXPECT_EQ(dstSinkInfo.channels == sinkInfo.channels, true);
135 EXPECT_EQ(dstSinkInfo.deviceType == sinkInfo.deviceType, true);
136 }
137
138 /**
139 * @tc.name : Test Init
140 * @tc.type : FUNC
141 * @tc.number: Init_001
142 * @tc.desc : Test Init.
143 */
144 HWTEST_F(HpaeInnerCapturerManagerUnitTest, Init_001, TestSize.Level1)
145 {
146 EXPECT_NE(hpaeInnerCapturerManager_, nullptr);
147 EXPECT_EQ(hpaeInnerCapturerManager_->Init(), SUCCESS);
148 WaitForMsgProcessing(hpaeInnerCapturerManager_);
149 EXPECT_EQ(hpaeInnerCapturerManager_->IsInit(), true);
150 }
151
152 /**
153 * @tc.name : Test DeInit
154 * @tc.type : FUNC
155 * @tc.number: DeInit_001
156 * @tc.desc : Test DeInit.
157 */
158 HWTEST_F(HpaeInnerCapturerManagerUnitTest, DeInit_001, TestSize.Level1)
159 {
160 EXPECT_EQ(hpaeInnerCapturerManager_->Init(), SUCCESS);
161 WaitForMsgProcessing(hpaeInnerCapturerManager_);
162 EXPECT_EQ(hpaeInnerCapturerManager_->DeInit(), SUCCESS);
163 WaitForMsgProcessing(hpaeInnerCapturerManager_);
164 EXPECT_EQ(hpaeInnerCapturerManager_->IsInit(), false);
165 EXPECT_EQ(hpaeInnerCapturerManager_->DeInit(), SUCCESS);
166 WaitForMsgProcessing(hpaeInnerCapturerManager_);
167 EXPECT_EQ(hpaeInnerCapturerManager_->IsInit(), false);
168 }
169
170 /**
171 * @tc.name : Test CreateStream
172 * @tc.type : FUNC
173 * @tc.number: CreateStream_001
174 * @tc.desc : Test CreateRendererStream when config in vaild.
175 */
176 HWTEST_F(HpaeInnerCapturerManagerUnitTest, CreateStream_001, TestSize.Level1)
177 {
178 EXPECT_EQ(hpaeInnerCapturerManager_->Init(), SUCCESS);
179 WaitForMsgProcessing(hpaeInnerCapturerManager_);
180 EXPECT_EQ(hpaeInnerCapturerManager_->IsInit(), true);
181 HpaeStreamInfo streamInfo = GetInCapPlayStreamInfo();
182 EXPECT_EQ(hpaeInnerCapturerManager_->CreateStream(streamInfo), SUCCESS);
183 WaitForMsgProcessing(hpaeInnerCapturerManager_);
184 HpaeSinkInputInfo sinkInputInfo;
185 EXPECT_EQ(hpaeInnerCapturerManager_->GetSinkInputInfo(streamInfo.sessionId, sinkInputInfo), SUCCESS);
186 }
187
188 /**
189 * @tc.name : Test CreateStream
190 * @tc.type : FUNC
191 * @tc.number: CreateStream_002
192 * @tc.desc : Test CreateCapturerStream when config in vaild.
193 */
194 HWTEST_F(HpaeInnerCapturerManagerUnitTest, CreateStream_002, TestSize.Level1)
195 {
196 EXPECT_EQ(hpaeInnerCapturerManager_->Init(), SUCCESS);
197 WaitForMsgProcessing(hpaeInnerCapturerManager_);
198 EXPECT_EQ(hpaeInnerCapturerManager_->IsInit(), true);
199 HpaeStreamInfo streamInfo = GetInCapRecordStreamInfo();
200 EXPECT_EQ(hpaeInnerCapturerManager_->CreateStream(streamInfo), SUCCESS);
201 WaitForMsgProcessing(hpaeInnerCapturerManager_);
202 HpaeSourceOutputInfo sourceOutoputInfo;
203 EXPECT_EQ(hpaeInnerCapturerManager_->GetSourceOutputInfo(streamInfo.sessionId, sourceOutoputInfo), SUCCESS);
204 }
205
206 /**
207 * @tc.name : Test DestroyStream
208 * @tc.type : FUNC
209 * @tc.number: DestroyStream_001
210 * @tc.desc : Test DestroyRendererStream when config in vaild.
211 */
212 HWTEST_F(HpaeInnerCapturerManagerUnitTest, DestroyStream_001, TestSize.Level1)
213 {
214 EXPECT_EQ(hpaeInnerCapturerManager_->Init(), SUCCESS);
215 WaitForMsgProcessing(hpaeInnerCapturerManager_);
216 EXPECT_EQ(hpaeInnerCapturerManager_->IsInit(), true);
217 HpaeStreamInfo streamInfo = GetInCapPlayStreamInfo();
218 EXPECT_EQ(hpaeInnerCapturerManager_->CreateStream(streamInfo), SUCCESS);
219 WaitForMsgProcessing(hpaeInnerCapturerManager_);
220 EXPECT_EQ(hpaeInnerCapturerManager_->Start(streamInfo.sessionId), SUCCESS);
221 WaitForMsgProcessing(hpaeInnerCapturerManager_);
222 EXPECT_EQ(hpaeInnerCapturerManager_->DestroyStream(streamInfo.sessionId) == SUCCESS, true);
223 WaitForMsgProcessing(hpaeInnerCapturerManager_);
224 HpaeSinkInputInfo sinkInputInfo;
225 EXPECT_EQ(hpaeInnerCapturerManager_->GetSinkInputInfo(streamInfo.sessionId,
226 sinkInputInfo) == ERR_INVALID_OPERATION, true);
227 }
228
229 /**
230 * @tc.name : Test DestroyStream
231 * @tc.type : FUNC
232 * @tc.number: DestroyStream_002
233 * @tc.desc : Test DestroyCapturerStream when config in vaild.
234 */
235 HWTEST_F(HpaeInnerCapturerManagerUnitTest, DestroyStream_002, TestSize.Level1)
236 {
237 EXPECT_EQ(hpaeInnerCapturerManager_->Init(), SUCCESS);
238 WaitForMsgProcessing(hpaeInnerCapturerManager_);
239 HpaeStreamInfo streamInfo = GetInCapRecordStreamInfo();
240 EXPECT_EQ(hpaeInnerCapturerManager_->CreateStream(streamInfo), SUCCESS);
241 WaitForMsgProcessing(hpaeInnerCapturerManager_);
242 EXPECT_EQ(hpaeInnerCapturerManager_->DestroyStream(streamInfo.sessionId) == SUCCESS, true);
243 WaitForMsgProcessing(hpaeInnerCapturerManager_);
244 HpaeSourceOutputInfo sourceOutoputInfo;
245 EXPECT_EQ(hpaeInnerCapturerManager_->GetSourceOutputInfo(streamInfo.sessionId, sourceOutoputInfo)
246 == ERR_INVALID_OPERATION, SUCCESS);
247 }
248
249 /**
250 * @tc.name : Test StreamStartPauseFlushChange_001
251 * @tc.type : FUNC
252 * @tc.number: StreamStartPauseFlushChange_001
253 * @tc.desc : Test StreamStartPauseFlushChange when config in vaild.
254 */
255 HWTEST_F(HpaeInnerCapturerManagerUnitTest, StreamStartPauseFlushChange_001, TestSize.Level1)
256 {
257 EXPECT_EQ(hpaeInnerCapturerManager_->Init(), SUCCESS);
258 WaitForMsgProcessing(hpaeInnerCapturerManager_);
259 HpaeStreamInfo recordStreamInfo = GetInCapRecordStreamInfo();
260 EXPECT_EQ(hpaeInnerCapturerManager_->CreateStream(recordStreamInfo), SUCCESS);
261 WaitForMsgProcessing(hpaeInnerCapturerManager_);
262 EXPECT_EQ(hpaeInnerCapturerManager_->Start(recordStreamInfo.sessionId), SUCCESS);
263 WaitForMsgProcessing(hpaeInnerCapturerManager_);
264 HpaeSourceOutputInfo sourceOutoputInfo;
265
266 HpaeStreamInfo playStreamInfo = GetInCapPlayStreamInfo();
267 EXPECT_EQ(hpaeInnerCapturerManager_->CreateStream(playStreamInfo), SUCCESS);
268 WaitForMsgProcessing(hpaeInnerCapturerManager_);
269 std::shared_ptr<WriteFixedDataCb> writeInPlayDataCb = std::make_shared<WriteFixedDataCb>(SAMPLE_S16LE);
270 EXPECT_EQ(hpaeInnerCapturerManager_->RegisterWriteCallback(playStreamInfo.sessionId, writeInPlayDataCb), SUCCESS);
271 EXPECT_EQ(hpaeInnerCapturerManager_->Start(playStreamInfo.sessionId), SUCCESS);
272 WaitForMsgProcessing(hpaeInnerCapturerManager_);
273 EXPECT_EQ(hpaeInnerCapturerManager_->SetOffloadPolicy(playStreamInfo.sessionId, 0), SUCCESS);
274 WaitForMsgProcessing(hpaeInnerCapturerManager_);
275 hpaeInnerCapturerManager_->SetSpeed(playStreamInfo.sessionId, 2.0f); // 2.0f test
276 WaitForMsgProcessing(hpaeInnerCapturerManager_);
277 HpaeSinkInputInfo sinkInputInfo;
278
279 EXPECT_EQ(hpaeInnerCapturerManager_->IsRunning(), true);
280 WaitForMsgProcessing(hpaeInnerCapturerManager_);
281 EXPECT_EQ(hpaeInnerCapturerManager_->Pause(recordStreamInfo.sessionId) == SUCCESS, true);
282 WaitForMsgProcessing(hpaeInnerCapturerManager_);
283 EXPECT_EQ(hpaeInnerCapturerManager_->IsRunning(), false);
284 WaitForMsgProcessing(hpaeInnerCapturerManager_);
285 EXPECT_EQ(hpaeInnerCapturerManager_->Pause(playStreamInfo.sessionId) == SUCCESS, true);
286 WaitForMsgProcessing(hpaeInnerCapturerManager_);
287 EXPECT_EQ(hpaeInnerCapturerManager_->IsRunning(), false);
288 WaitForMsgProcessing(hpaeInnerCapturerManager_);
289 EXPECT_EQ(hpaeInnerCapturerManager_->Flush(recordStreamInfo.sessionId) == SUCCESS, true);
290 WaitForMsgProcessing(hpaeInnerCapturerManager_);
291 EXPECT_EQ(hpaeInnerCapturerManager_->Flush(playStreamInfo.sessionId) == SUCCESS, true);
292 WaitForMsgProcessing(hpaeInnerCapturerManager_);
293 EXPECT_EQ(hpaeInnerCapturerManager_->GetSinkInputInfo(playStreamInfo.sessionId, sinkInputInfo) == SUCCESS, true);
294 EXPECT_EQ(hpaeInnerCapturerManager_->GetSourceOutputInfo(recordStreamInfo.sessionId, sourceOutoputInfo), SUCCESS);
295 EXPECT_EQ(sourceOutoputInfo.capturerSessionInfo.state, HPAE_SESSION_PAUSED);
296 EXPECT_EQ(sinkInputInfo.rendererSessionInfo.state, HPAE_SESSION_PAUSED);
297 EXPECT_EQ(hpaeInnerCapturerManager_->DestroyStream(recordStreamInfo.sessionId) == SUCCESS, true);
298 WaitForMsgProcessing(hpaeInnerCapturerManager_);
299 EXPECT_EQ(hpaeInnerCapturerManager_->DestroyStream(playStreamInfo.sessionId) == SUCCESS, true);
300 }
301
302 /**
303 * @tc.name : Test StreamStartStopDrainChange_001
304 * @tc.type : FUNC
305 * @tc.number: StreamStartStopDrainChange_001
306 * @tc.desc : Test StreamStartStopDrainChange when config in vaild.
307 */
308 HWTEST_F(HpaeInnerCapturerManagerUnitTest, StreamStartStopDrainChange_001, TestSize.Level1)
309 {
310 EXPECT_EQ(hpaeInnerCapturerManager_->Init(), SUCCESS);
311 WaitForMsgProcessing(hpaeInnerCapturerManager_);
312 HpaeStreamInfo recordStreamInfo;
313 recordStreamInfo.channels = STEREO;
314 recordStreamInfo.samplingRate = SAMPLE_RATE_44100;
315 recordStreamInfo.frameLen = SAMPLE_RATE_44100 * FRAME_LENGTH_IN_SECOND;
316 recordStreamInfo.format = SAMPLE_S16LE;
317 recordStreamInfo.sessionId = DEFAULT_SESSION_ID;
318 recordStreamInfo.streamType = STREAM_MUSIC;
319 recordStreamInfo.streamClassType = HPAE_STREAM_CLASS_TYPE_RECORD;
320 recordStreamInfo.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE;
321 EXPECT_EQ(hpaeInnerCapturerManager_->CreateStream(recordStreamInfo), SUCCESS);
322 WaitForMsgProcessing(hpaeInnerCapturerManager_);
323 EXPECT_EQ(hpaeInnerCapturerManager_->Start(recordStreamInfo.sessionId), SUCCESS);
324 WaitForMsgProcessing(hpaeInnerCapturerManager_);
325 HpaeSourceOutputInfo sourceOutoputInfo;
326
327 HpaeStreamInfo playStreamInfo = GetInCapPlayStreamInfo();
328 EXPECT_EQ(hpaeInnerCapturerManager_->CreateStream(playStreamInfo), SUCCESS);
329 WaitForMsgProcessing(hpaeInnerCapturerManager_);
330 std::shared_ptr<WriteFixedDataCb> writeInPlayDataCb = std::make_shared<WriteFixedDataCb>(SAMPLE_S16LE);
331 EXPECT_EQ(hpaeInnerCapturerManager_->RegisterWriteCallback(playStreamInfo.sessionId, writeInPlayDataCb), SUCCESS);
332 EXPECT_EQ(hpaeInnerCapturerManager_->Start(playStreamInfo.sessionId), SUCCESS);
333 WaitForMsgProcessing(hpaeInnerCapturerManager_);
334 HpaeSinkInputInfo sinkInputInfo;
335
336 EXPECT_EQ(hpaeInnerCapturerManager_->Drain(recordStreamInfo.sessionId) == SUCCESS, true);
337 WaitForMsgProcessing(hpaeInnerCapturerManager_);
338 EXPECT_EQ(hpaeInnerCapturerManager_->Drain(playStreamInfo.sessionId) == SUCCESS, true);
339 WaitForMsgProcessing(hpaeInnerCapturerManager_);
340 EXPECT_EQ(hpaeInnerCapturerManager_->IsRunning(), true);
341 WaitForMsgProcessing(hpaeInnerCapturerManager_);
342 EXPECT_EQ(hpaeInnerCapturerManager_->Stop(recordStreamInfo.sessionId) == SUCCESS, true);
343 WaitForMsgProcessing(hpaeInnerCapturerManager_);
344 EXPECT_EQ(hpaeInnerCapturerManager_->Stop(playStreamInfo.sessionId) == SUCCESS, true);
345 WaitForMsgProcessing(hpaeInnerCapturerManager_);
346 EXPECT_EQ(hpaeInnerCapturerManager_->IsRunning(), false);
347 WaitForMsgProcessing(hpaeInnerCapturerManager_);
348 EXPECT_EQ(hpaeInnerCapturerManager_->GetSinkInputInfo(playStreamInfo.sessionId, sinkInputInfo) == SUCCESS, true);
349 EXPECT_EQ(hpaeInnerCapturerManager_->GetSourceOutputInfo(recordStreamInfo.sessionId, sourceOutoputInfo), SUCCESS);
350 EXPECT_EQ(sourceOutoputInfo.capturerSessionInfo.state, HPAE_SESSION_STOPPED);
351 EXPECT_EQ(sinkInputInfo.rendererSessionInfo.state, HPAE_SESSION_STOPPED);
352 EXPECT_EQ(hpaeInnerCapturerManager_->DestroyStream(recordStreamInfo.sessionId) == SUCCESS, true);
353 WaitForMsgProcessing(hpaeInnerCapturerManager_);
354 EXPECT_EQ(hpaeInnerCapturerManager_->DestroyStream(playStreamInfo.sessionId) == SUCCESS, true);
355 }
356
357 /**
358 * @tc.name : Test StreamStartStopDump_001
359 * @tc.type : FUNC
360 * @tc.number: StreamStartStopDump_001
361 * @tc.desc : Test StreamStartStop when config in vaild.
362 */
363 HWTEST_F(HpaeInnerCapturerManagerUnitTest, StreamStartStopDump_001, TestSize.Level1)
364 {
365 EXPECT_EQ(hpaeInnerCapturerManager_->Init(), SUCCESS);
366 WaitForMsgProcessing(hpaeInnerCapturerManager_);
367 HpaeStreamInfo recordStreamInfo;
368 recordStreamInfo.channels = STEREO;
369 recordStreamInfo.samplingRate = SAMPLE_RATE_44100;
370 recordStreamInfo.frameLen = SAMPLE_RATE_44100 * FRAME_LENGTH_IN_SECOND;
371 recordStreamInfo.format = SAMPLE_S16LE;
372 recordStreamInfo.sessionId = DEFAULT_SESSION_ID;
373 recordStreamInfo.streamType = STREAM_MUSIC;
374 recordStreamInfo.streamClassType = HPAE_STREAM_CLASS_TYPE_RECORD;
375 recordStreamInfo.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE;
376 EXPECT_EQ(hpaeInnerCapturerManager_->CreateStream(recordStreamInfo), SUCCESS);
377 WaitForMsgProcessing(hpaeInnerCapturerManager_);
378 EXPECT_EQ(hpaeInnerCapturerManager_->Start(recordStreamInfo.sessionId), SUCCESS);
379 WaitForMsgProcessing(hpaeInnerCapturerManager_);
380 HpaeSourceOutputInfo sourceOutoputInfo;
381
382 HpaeStreamInfo playStreamInfo = GetInCapPlayStreamInfo();
383 EXPECT_EQ(hpaeInnerCapturerManager_->CreateStream(playStreamInfo), SUCCESS);
384 WaitForMsgProcessing(hpaeInnerCapturerManager_);
385 std::shared_ptr<WriteFixedDataCb> writeInPlayDataCb = std::make_shared<WriteFixedDataCb>(SAMPLE_S16LE);
386 EXPECT_EQ(hpaeInnerCapturerManager_->RegisterWriteCallback(playStreamInfo.sessionId, writeInPlayDataCb), SUCCESS);
387 EXPECT_EQ(hpaeInnerCapturerManager_->Start(playStreamInfo.sessionId), SUCCESS);
388 WaitForMsgProcessing(hpaeInnerCapturerManager_);
389 HpaeSinkInputInfo sinkInputInfo;
390
391 EXPECT_EQ(hpaeInnerCapturerManager_->IsRunning(), true);
392 WaitForMsgProcessing(hpaeInnerCapturerManager_);
393 EXPECT_EQ(hpaeInnerCapturerManager_->Stop(playStreamInfo.sessionId) == SUCCESS, true);
394 WaitForMsgProcessing(hpaeInnerCapturerManager_);
395 EXPECT_EQ(hpaeInnerCapturerManager_->DumpSinkInfo() == SUCCESS, true);
396 WaitForMsgProcessing(hpaeInnerCapturerManager_);
397 WaitForMsgProcessing(hpaeInnerCapturerManager_);
398 EXPECT_EQ(hpaeInnerCapturerManager_->Stop(recordStreamInfo.sessionId) == SUCCESS, true);
399 WaitForMsgProcessing(hpaeInnerCapturerManager_);
400 EXPECT_EQ(hpaeInnerCapturerManager_->DestroyStream(recordStreamInfo.sessionId) == SUCCESS, true);
401 WaitForMsgProcessing(hpaeInnerCapturerManager_);
402 EXPECT_EQ(hpaeInnerCapturerManager_->DestroyStream(playStreamInfo.sessionId) == SUCCESS, true);
403 }
404
405 /**
406 * @tc.name : Test AddNodeToSink_001
407 * @tc.type : FUNC
408 * @tc.number: AddNodeToSink_001
409 * @tc.desc : Test AddNodeToSink when config in vaild.
410 */
411 HWTEST_F(HpaeInnerCapturerManagerUnitTest, AddNodeToSink_001, TestSize.Level1)
412 {
413 EXPECT_EQ(hpaeInnerCapturerManager_->Init(), SUCCESS);
414 WaitForMsgProcessing(hpaeInnerCapturerManager_);
415 HpaeStreamInfo recordStreamInfo = GetInCapRecordStreamInfo();
416 EXPECT_EQ(hpaeInnerCapturerManager_->CreateStream(recordStreamInfo), SUCCESS);
417 WaitForMsgProcessing(hpaeInnerCapturerManager_);
418 EXPECT_EQ(hpaeInnerCapturerManager_->Start(recordStreamInfo.sessionId), SUCCESS);
419 WaitForMsgProcessing(hpaeInnerCapturerManager_);
420
421 HpaeStreamInfo playStreamInfo = GetInCapPlayStreamInfo();
422 EXPECT_EQ(hpaeInnerCapturerManager_->CreateStream(playStreamInfo), SUCCESS);
423 WaitForMsgProcessing(hpaeInnerCapturerManager_);
424 EXPECT_EQ(hpaeInnerCapturerManager_->Start(playStreamInfo.sessionId), SUCCESS);
425 WaitForMsgProcessing(hpaeInnerCapturerManager_);
426 HpaeStreamInfo playSencondStreamInfo = GetInCapPlayStreamInfo();
427 ++playSencondStreamInfo.sessionId;
428 EXPECT_EQ(hpaeInnerCapturerManager_->CreateStream(playSencondStreamInfo), SUCCESS);
429 WaitForMsgProcessing(hpaeInnerCapturerManager_);
430 EXPECT_EQ(hpaeInnerCapturerManager_->Start(playSencondStreamInfo.sessionId), SUCCESS);
431 WaitForMsgProcessing(hpaeInnerCapturerManager_);
432 HpaeNodeInfo playSencondNodeInfo;
433 playSencondNodeInfo.sessionId = playSencondStreamInfo.sessionId + 1;
434 playSencondNodeInfo.channels = STEREO;
435 playSencondNodeInfo.format = SAMPLE_S16LE;
436 playSencondNodeInfo.frameLen = SAMPLE_RATE_44100 * FRAME_LENGTH_IN_SECOND;
437 playSencondNodeInfo.samplingRate = SAMPLE_RATE_44100;
438 playSencondNodeInfo.sceneType = HPAE_SCENE_EFFECT_NONE;
439 playSencondNodeInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
440 playSencondNodeInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
441 std::shared_ptr<HpaeSinkInputNode> HpaeSinkInputSencondNode =
442 std::make_shared<HpaeSinkInputNode>(playSencondNodeInfo);
443 EXPECT_EQ(HpaeSinkInputSencondNode != nullptr, true);
444 EXPECT_EQ(hpaeInnerCapturerManager_->DestroyStream(playStreamInfo.sessionId) == SUCCESS, true);
445 WaitForMsgProcessing(hpaeInnerCapturerManager_);
446 hpaeInnerCapturerManager_->AddSingleNodeToSinkInner(HpaeSinkInputSencondNode, false);
447 WaitForMsgProcessing(hpaeInnerCapturerManager_);
448 EXPECT_EQ(hpaeInnerCapturerManager_->SuspendStreamManager(true), SUCCESS);
449 WaitForMsgProcessing(hpaeInnerCapturerManager_);
450 EXPECT_EQ(hpaeInnerCapturerManager_->AddNodeToSink(HpaeSinkInputSencondNode), SUCCESS);
451 WaitForMsgProcessing(hpaeInnerCapturerManager_);
452 EXPECT_EQ(hpaeInnerCapturerManager_->SuspendStreamManager(false), SUCCESS);
453 WaitForMsgProcessing(hpaeInnerCapturerManager_);
454 EXPECT_EQ(hpaeInnerCapturerManager_->DestroyStream(playSencondNodeInfo.sessionId) == SUCCESS, true);
455 WaitForMsgProcessing(hpaeInnerCapturerManager_);
456 EXPECT_EQ(hpaeInnerCapturerManager_->DestroyStream(playSencondStreamInfo.sessionId) == SUCCESS, true);
457 WaitForMsgProcessing(hpaeInnerCapturerManager_);
458 EXPECT_EQ(hpaeInnerCapturerManager_->DestroyStream(recordStreamInfo.sessionId) == SUCCESS, true);
459 }
460
461 /**
462 * @tc.name : Test SetMute_001
463 * @tc.type : FUNC
464 * @tc.number: SetMute_001
465 * @tc.desc : Test SetMute when config in vaild.
466 */
467 HWTEST_F(HpaeInnerCapturerManagerUnitTest, SetMute_001, TestSize.Level1)
468 {
469 EXPECT_EQ(hpaeInnerCapturerManager_->SetMute(true), SUCCESS);
470 WaitForMsgProcessing(hpaeInnerCapturerManager_);
471 EXPECT_EQ(hpaeInnerCapturerManager_->Init(), SUCCESS);
472 WaitForMsgProcessing(hpaeInnerCapturerManager_);
473 HpaeStreamInfo recordStreamInfo = GetInCapRecordStreamInfo();
474 EXPECT_EQ(hpaeInnerCapturerManager_->CreateStream(recordStreamInfo), SUCCESS);
475 WaitForMsgProcessing(hpaeInnerCapturerManager_);
476 EXPECT_EQ(hpaeInnerCapturerManager_->Start(recordStreamInfo.sessionId), SUCCESS);
477 WaitForMsgProcessing(hpaeInnerCapturerManager_);
478
479 EXPECT_EQ(hpaeInnerCapturerManager_->SetMute(true), SUCCESS);
480 WaitForMsgProcessing(hpaeInnerCapturerManager_);
481 EXPECT_EQ(hpaeInnerCapturerManager_->SetMute(false), SUCCESS);
482 WaitForMsgProcessing(hpaeInnerCapturerManager_);
483 }
484
485 /**
486 * @tc.name : Test OnFadeDone_001
487 * @tc.type : FUNC
488 * @tc.number: OnFadeDone_001
489 * @tc.desc : Test OnFadeDone when config in vaild.
490 */
491 HWTEST_F(HpaeInnerCapturerManagerUnitTest, OnFadeDone_001, TestSize.Level1)
492 {
493 EXPECT_EQ(hpaeInnerCapturerManager_->Init(), SUCCESS);
494 WaitForMsgProcessing(hpaeInnerCapturerManager_);
495 HpaeStreamInfo recordStreamInfo = GetInCapRecordStreamInfo();
496 EXPECT_EQ(hpaeInnerCapturerManager_->CreateStream(recordStreamInfo), SUCCESS);
497 WaitForMsgProcessing(hpaeInnerCapturerManager_);
498 EXPECT_EQ(hpaeInnerCapturerManager_->Start(recordStreamInfo.sessionId), SUCCESS);
499 WaitForMsgProcessing(hpaeInnerCapturerManager_);
500
501 HpaeStreamInfo playStreamInfo = GetInCapPlayStreamInfo();
502 EXPECT_EQ(hpaeInnerCapturerManager_->CreateStream(playStreamInfo), SUCCESS);
503 WaitForMsgProcessing(hpaeInnerCapturerManager_);
504 std::shared_ptr<WriteFixedDataCb> writeInPlayDataCb = std::make_shared<WriteFixedDataCb>(SAMPLE_S16LE);
505 EXPECT_EQ(hpaeInnerCapturerManager_->RegisterWriteCallback(playStreamInfo.sessionId, writeInPlayDataCb), SUCCESS);
506 EXPECT_EQ(hpaeInnerCapturerManager_->Start(playStreamInfo.sessionId), SUCCESS);
507 WaitForMsgProcessing(hpaeInnerCapturerManager_);
508 hpaeInnerCapturerManager_->OnFadeDone(playStreamInfo.sessionId, OPERATION_STOPPED);
509 }
510
511 /**
512 * @tc.name : Test GetThreadName_001
513 * @tc.type : FUNC
514 * @tc.number: GetThreadName_001
515 * @tc.desc : Test GetThreadName
516 */
517 HWTEST_F(HpaeInnerCapturerManagerUnitTest, GetThreadName_001, TestSize.Level1)
518 {
519 HpaeSinkInfo sinkInfo = GetInCapSinkInfo();
520 sinkInfo.deviceName = "InnerCap1";
521 hpaeInnerCapturerManager_ = std::make_shared<HPAE::HpaeInnerCapturerManager>(sinkInfo);
522 EXPECT_EQ(hpaeInnerCapturerManager_->Init(), SUCCESS);
523 WaitForMsgProcessing(hpaeInnerCapturerManager_);
524 std::string threadName = hpaeInnerCapturerManager_->GetThreadName();
525 EXPECT_EQ(threadName, "InnerCap1");
526
527 sinkInfo.deviceName = "InnerCap";
528 hpaeInnerCapturerManager_ = std::make_shared<HPAE::HpaeInnerCapturerManager>(sinkInfo);
529 EXPECT_EQ(hpaeInnerCapturerManager_->Init(), SUCCESS);
530 WaitForMsgProcessing(hpaeInnerCapturerManager_);
531 threadName = hpaeInnerCapturerManager_->GetThreadName();
532 EXPECT_EQ(threadName, "InnerCap");
533
534 sinkInfo.deviceName = "RemoteCastInnerCapturer";
535 hpaeInnerCapturerManager_ = std::make_shared<HPAE::HpaeInnerCapturerManager>(sinkInfo);
536 EXPECT_EQ(hpaeInnerCapturerManager_->Init(), SUCCESS);
537 WaitForMsgProcessing(hpaeInnerCapturerManager_);
538 threadName = hpaeInnerCapturerManager_->GetThreadName();
539 EXPECT_EQ(threadName, "RemoteCast");
540 }
541
542 /**
543 * @tc.name : Test SendRequestInner_001
544 * @tc.type : FUNC
545 * @tc.number: SendRequestInner_001
546 * @tc.desc : Test SendRequestInner when config in vaild.
547 */
548 HWTEST_F(HpaeInnerCapturerManagerUnitTest, SendRequestInner_001, TestSize.Level1)
549 {
__anonc1b0a0770102() 550 auto request = []() {
551 };
552 hpaeInnerCapturerManager_->SendRequestInner(request);
553 WaitForMsgProcessing(hpaeInnerCapturerManager_);
554 EXPECT_EQ(hpaeInnerCapturerManager_->Init(), SUCCESS);
555 WaitForMsgProcessing(hpaeInnerCapturerManager_);
556 hpaeInnerCapturerManager_->SendRequestInner(request);
557 WaitForMsgProcessing(hpaeInnerCapturerManager_);
558 }
559
560 /**
561 * @tc.name : Test Other_001
562 * @tc.type : FUNC
563 * @tc.number: Other_001
564 * @tc.desc : Test Other when config in vaild.
565 */
566 HWTEST_F(HpaeInnerCapturerManagerUnitTest, Other_001, TestSize.Level1)
567 {
568 EXPECT_EQ(hpaeInnerCapturerManager_->Init(), SUCCESS);
569 WaitForMsgProcessing(hpaeInnerCapturerManager_);
570 HpaeStreamInfo recordStreamInfo = GetInCapRecordStreamInfo();
571 EXPECT_EQ(hpaeInnerCapturerManager_->CreateStream(recordStreamInfo), SUCCESS);
572 WaitForMsgProcessing(hpaeInnerCapturerManager_);
573 EXPECT_EQ(hpaeInnerCapturerManager_->Start(recordStreamInfo.sessionId), SUCCESS);
574 WaitForMsgProcessing(hpaeInnerCapturerManager_);
575
576 HpaeStreamInfo playStreamInfo = GetInCapPlayStreamInfo();
577 EXPECT_EQ(hpaeInnerCapturerManager_->CreateStream(playStreamInfo), SUCCESS);
578 WaitForMsgProcessing(hpaeInnerCapturerManager_);
579 std::shared_ptr<WriteFixedDataCb> writeInPlayDataCb = std::make_shared<WriteFixedDataCb>(SAMPLE_S16LE);
580 EXPECT_EQ(hpaeInnerCapturerManager_->RegisterWriteCallback(playStreamInfo.sessionId, writeInPlayDataCb), SUCCESS);
581 EXPECT_EQ(hpaeInnerCapturerManager_->Start(playStreamInfo.sessionId), SUCCESS);
582 WaitForMsgProcessing(hpaeInnerCapturerManager_);
583
584 std::vector<SinkInput> sinkInputs;
585 sinkInputs = hpaeInnerCapturerManager_->GetAllSinkInputsInfo();
586 std::vector<SourceOutput> sourceOutputs;
587 sourceOutputs = hpaeInnerCapturerManager_->GetAllSourceOutputsInfo();
588 std::string config = hpaeInnerCapturerManager_->GetDeviceHDFDumpInfo();
589 WaitForMsgProcessing(hpaeInnerCapturerManager_);
590 int32_t testVariable = 1;
591 EXPECT_EQ(hpaeInnerCapturerManager_->SetClientVolume(playStreamInfo.sessionId, 1.0f), SUCCESS);
592 EXPECT_EQ(hpaeInnerCapturerManager_->SetRate(playStreamInfo.sessionId, testVariable), SUCCESS);
593 EXPECT_EQ(hpaeInnerCapturerManager_->SetAudioEffectMode(playStreamInfo.sessionId, testVariable), SUCCESS);
594 EXPECT_EQ(hpaeInnerCapturerManager_->GetAudioEffectMode(playStreamInfo.sessionId, testVariable), SUCCESS);
595 EXPECT_EQ(hpaeInnerCapturerManager_->SetPrivacyType(playStreamInfo.sessionId, testVariable), SUCCESS);
596 EXPECT_EQ(hpaeInnerCapturerManager_->GetPrivacyType(playStreamInfo.sessionId, testVariable), SUCCESS);
597 EXPECT_EQ(hpaeInnerCapturerManager_->GetWritableSize(playStreamInfo.sessionId), SUCCESS);
598 EXPECT_EQ(hpaeInnerCapturerManager_->UpdateSpatializationState(playStreamInfo.sessionId, true, true), SUCCESS);
599 EXPECT_EQ(hpaeInnerCapturerManager_->UpdateMaxLength(playStreamInfo.sessionId, testVariable), SUCCESS);
600 }
601
602 /**
603 * @tc.name : Test ReloadRenderManager_001
604 * @tc.type : FUNC
605 * @tc.number: ReloadRenderManager_001
606 * @tc.desc : Test ReloadRenderManager.
607 */
608 HWTEST_F(HpaeInnerCapturerManagerUnitTest, ReloadRenderManager_001, TestSize.Level1)
609 {
610 EXPECT_EQ(hpaeInnerCapturerManager_->Init(), SUCCESS);
611 WaitForMsgProcessing(hpaeInnerCapturerManager_);
612 HpaeStreamInfo playStreamInfo = GetInCapPlayStreamInfo();
613 ++playStreamInfo.sessionId;
614 EXPECT_EQ(hpaeInnerCapturerManager_->CreateStream(playStreamInfo), SUCCESS);
615 WaitForMsgProcessing(hpaeInnerCapturerManager_);
616 HpaeSinkInfo sinkInfo = GetInCapSinkInfo();
617 EXPECT_EQ(hpaeInnerCapturerManager_->ReloadRenderManager(sinkInfo, false), SUCCESS);
618 WaitForMsgProcessing(hpaeInnerCapturerManager_);
619 EXPECT_EQ(hpaeInnerCapturerManager_->ReloadRenderManager(sinkInfo, true), SUCCESS);
620 WaitForMsgProcessing(hpaeInnerCapturerManager_);
621 EXPECT_EQ(hpaeInnerCapturerManager_->DeInit(), SUCCESS);
622 EXPECT_EQ(hpaeInnerCapturerManager_->ReloadRenderManager(sinkInfo, true), SUCCESS);
623 WaitForMsgProcessing(hpaeInnerCapturerManager_);
624 EXPECT_EQ(hpaeInnerCapturerManager_->DeInit(), SUCCESS);
625 }
626 } // namespace HPAE
627 } // namespace OHOS::AudioStandard
628 } // namespace OHOS