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 #include <gtest/gtest.h>
16 #include <string>
17 #include "test_case_common.h"
18 #include "audio_errors.h"
19 #include "hpae_renderer_manager.h"
20 #include "hpae_offload_renderer_manager.h"
21 #include "hpae_co_buffer_node.h"
22 #include "hpae_inner_capturer_manager.h"
23 #include "audio_effect_chain_manager.h"
24 #include <thread>
25 #include <chrono>
26 #include <cstdio>
27 #include <fstream>
28 #include <streambuf>
29 #include <algorithm>
30
31 using namespace OHOS;
32 using namespace AudioStandard;
33 using namespace HPAE;
34 using namespace testing::ext;
35 using namespace testing;
36 namespace {
37 static std::string g_rootPath = "/data/";
38 constexpr int32_t FRAME_LENGTH_882 = 882;
39 constexpr int32_t FRAME_LENGTH_960 = 960;
40 constexpr int32_t TEST_STREAM_SESSION_ID = 123456;
41 constexpr int32_t TEST_SLEEP_TIME_20 = 20;
42 constexpr int32_t TEST_SLEEP_TIME_40 = 40;
43 constexpr uint32_t INVALID_ID = 99999;
44 constexpr uint32_t LOUDNESS_GAIN = 1.0f;
45 class HpaeRendererManagerTest : public testing::Test {
46 public:
47 void SetUp();
48 void TearDown();
49 };
50
SetUp()51 void HpaeRendererManagerTest::SetUp()
52 {}
53
TearDown()54 void HpaeRendererManagerTest::TearDown()
55 {}
56
TestCheckSinkInputInfo(HpaeSinkInputInfo & sinkInputInfo,const HpaeStreamInfo & streamInfo)57 static void TestCheckSinkInputInfo(HpaeSinkInputInfo &sinkInputInfo, const HpaeStreamInfo &streamInfo)
58 {
59 EXPECT_EQ(sinkInputInfo.nodeInfo.channels == streamInfo.channels, true);
60 EXPECT_EQ(sinkInputInfo.nodeInfo.format == streamInfo.format, true);
61 EXPECT_EQ(sinkInputInfo.nodeInfo.frameLen == streamInfo.frameLen, true);
62 EXPECT_EQ(sinkInputInfo.nodeInfo.sessionId == streamInfo.sessionId, true);
63 EXPECT_EQ(sinkInputInfo.nodeInfo.samplingRate == streamInfo.samplingRate, true);
64 EXPECT_EQ(sinkInputInfo.nodeInfo.streamType == streamInfo.streamType, true);
65 }
66
67 template <class RenderManagerType>
WaitForMsgProcessing(std::shared_ptr<RenderManagerType> & hpaeRendererManager)68 static void WaitForMsgProcessing(std::shared_ptr<RenderManagerType> &hpaeRendererManager)
69 {
70 int waitCount = 0;
71 const int waitCountThd = 5;
72 while (hpaeRendererManager->IsMsgProcessing()) {
73 std::this_thread::sleep_for(std::chrono::milliseconds(TEST_SLEEP_TIME_20));
74 waitCount++;
75 if (waitCount >= waitCountThd) {
76 break;
77 }
78 }
79 std::this_thread::sleep_for(std::chrono::milliseconds(TEST_SLEEP_TIME_40));
80 EXPECT_EQ(hpaeRendererManager->IsMsgProcessing(), false);
81 EXPECT_EQ(waitCount < waitCountThd, true);
82 }
83
84 template <class RenderManagerType>
TestIRendererManagerConstruct()85 void TestIRendererManagerConstruct()
86 {
87 HpaeSinkInfo sinkInfo;
88 sinkInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
89 sinkInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
90 sinkInfo.adapterName = DEFAULT_TEST_DEVICE_CLASS;
91 sinkInfo.filePath = g_rootPath + "constructHpaeRendererManagerTest.pcm";
92 sinkInfo.frameLen = FRAME_LENGTH_960;
93 sinkInfo.samplingRate = SAMPLE_RATE_48000;
94 sinkInfo.format = SAMPLE_F32LE;
95 sinkInfo.channels = STEREO;
96 sinkInfo.deviceType = DEVICE_TYPE_SPEAKER;
97 std::shared_ptr<IHpaeRendererManager> hpaeRendererManager = std::make_shared<RenderManagerType>(sinkInfo);
98 HpaeSinkInfo dstSinkInfo = hpaeRendererManager->GetSinkInfo();
99 EXPECT_EQ(dstSinkInfo.deviceNetId == sinkInfo.deviceNetId, true);
100 EXPECT_EQ(dstSinkInfo.deviceClass == sinkInfo.deviceClass, true);
101 EXPECT_EQ(dstSinkInfo.adapterName == sinkInfo.adapterName, true);
102 EXPECT_EQ(dstSinkInfo.frameLen == sinkInfo.frameLen, true);
103 EXPECT_EQ(dstSinkInfo.samplingRate == sinkInfo.samplingRate, true);
104 EXPECT_EQ(dstSinkInfo.format == sinkInfo.format, true);
105 EXPECT_EQ(dstSinkInfo.channels == sinkInfo.channels, true);
106 EXPECT_EQ(dstSinkInfo.deviceType == sinkInfo.deviceType, true);
107 }
108
109 template <class RenderManagerType>
TestIRendererManagerInit()110 void TestIRendererManagerInit()
111 {
112 HpaeSinkInfo sinkInfo;
113 sinkInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
114 sinkInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
115 sinkInfo.adapterName = DEFAULT_TEST_DEVICE_CLASS;
116 sinkInfo.filePath = g_rootPath + "constructHpaeRendererManagerTest.pcm";
117 sinkInfo.frameLen = FRAME_LENGTH_960;
118 sinkInfo.samplingRate = SAMPLE_RATE_48000;
119 sinkInfo.format = SAMPLE_F32LE;
120 sinkInfo.channels = STEREO;
121 sinkInfo.deviceType = DEVICE_TYPE_SPEAKER;
122 std::shared_ptr<IHpaeRendererManager> hpaeRendererManager = std::make_shared<RenderManagerType>(sinkInfo);
123 EXPECT_EQ(hpaeRendererManager->Init() == SUCCESS, true);
124 WaitForMsgProcessing(hpaeRendererManager);
125 EXPECT_EQ(hpaeRendererManager->IsInit(), true);
126 EXPECT_EQ(hpaeRendererManager->DeInit() == SUCCESS, true);
127 WaitForMsgProcessing(hpaeRendererManager);
128 EXPECT_EQ(hpaeRendererManager->IsInit(), false);
129 EXPECT_EQ(hpaeRendererManager->DeInit() == SUCCESS, true);
130 WaitForMsgProcessing(hpaeRendererManager);
131 EXPECT_EQ(hpaeRendererManager->IsInit(), false);
132 }
133
134 template <class RenderManagerType>
TestRendererManagerCreateStream(std::shared_ptr<RenderManagerType> & hpaeRendererManager,HpaeStreamInfo & streamInfo)135 void TestRendererManagerCreateStream(
136 std::shared_ptr<RenderManagerType> &hpaeRendererManager, HpaeStreamInfo &streamInfo)
137 {
138 streamInfo.channels = STEREO;
139 streamInfo.samplingRate = SAMPLE_RATE_44100;
140 streamInfo.format = SAMPLE_S16LE;
141 streamInfo.frameLen = FRAME_LENGTH_882;
142 streamInfo.sessionId = TEST_STREAM_SESSION_ID;
143 streamInfo.streamType = STREAM_MUSIC;
144 streamInfo.streamClassType = HPAE_STREAM_CLASS_TYPE_PLAY;
145 EXPECT_EQ(hpaeRendererManager->CreateStream(streamInfo) == SUCCESS, true);
146 WaitForMsgProcessing(hpaeRendererManager);
147 HpaeSinkInputInfo sinkInputInfo;
148 int32_t ret = hpaeRendererManager->GetSinkInputInfo(streamInfo.sessionId, sinkInputInfo);
149 EXPECT_EQ(ret == SUCCESS, true);
150 TestCheckSinkInputInfo(sinkInputInfo, streamInfo);
151 }
152
153 template <class RenderManagerType>
TestRenderManagerReload()154 void TestRenderManagerReload()
155 {
156 HpaeSinkInfo sinkInfo;
157 sinkInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
158 sinkInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
159 sinkInfo.adapterName = DEFAULT_TEST_DEVICE_CLASS;
160 sinkInfo.filePath = g_rootPath + "constructHpaeRendererManagerTest.pcm";
161 sinkInfo.frameLen = FRAME_LENGTH_960;
162 sinkInfo.samplingRate = SAMPLE_RATE_48000;
163 sinkInfo.format = SAMPLE_F32LE;
164 sinkInfo.channels = STEREO;
165 sinkInfo.deviceType = DEVICE_TYPE_SPEAKER;
166 std::shared_ptr<IHpaeRendererManager> hpaeRendererManager = std::make_shared<RenderManagerType>(sinkInfo);
167 EXPECT_EQ(hpaeRendererManager->Init() == SUCCESS, true);
168 WaitForMsgProcessing(hpaeRendererManager);
169 EXPECT_EQ(hpaeRendererManager->IsInit(), true);
170
171 HpaeStreamInfo streamInfo;
172 TestRendererManagerCreateStream(hpaeRendererManager, streamInfo);
173
174 EXPECT_EQ(hpaeRendererManager->ReloadRenderManager(sinkInfo, true) == SUCCESS, true);
175 WaitForMsgProcessing(hpaeRendererManager);
176 EXPECT_EQ(hpaeRendererManager->IsInit(), true);
177
178 EXPECT_EQ(hpaeRendererManager->Start(streamInfo.sessionId) == SUCCESS, true);
179 hpaeRendererManager->SetOffloadPolicy(streamInfo.sessionId, 0);
180 WaitForMsgProcessing(hpaeRendererManager);
181
182 hpaeRendererManager->SetSpeed(streamInfo.sessionId, 1.0f);
183 WaitForMsgProcessing(hpaeRendererManager);
184
185 EXPECT_EQ(hpaeRendererManager->DeInit() == SUCCESS, true);
186 EXPECT_EQ(hpaeRendererManager->IsInit(), false);
187
188 EXPECT_EQ(hpaeRendererManager->ReloadRenderManager(sinkInfo, true) == SUCCESS, true);
189 WaitForMsgProcessing(hpaeRendererManager);
190 EXPECT_EQ(hpaeRendererManager->IsInit(), true);
191
192 EXPECT_EQ(hpaeRendererManager->DeInit() == SUCCESS, true);
193 EXPECT_EQ(hpaeRendererManager->IsInit(), false);
194 }
195
196 template <class RenderManagerType>
TestIRendererManagerCreateDestoryStream()197 void TestIRendererManagerCreateDestoryStream()
198 {
199 HpaeSinkInfo sinkInfo;
200 sinkInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
201 sinkInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
202 sinkInfo.adapterName = DEFAULT_TEST_DEVICE_CLASS;
203 sinkInfo.filePath = g_rootPath + "constructHpaeRendererManagerTest.pcm";
204 sinkInfo.frameLen = FRAME_LENGTH_960;
205 sinkInfo.samplingRate = SAMPLE_RATE_48000;
206 sinkInfo.format = SAMPLE_F32LE;
207 sinkInfo.channels = STEREO;
208 sinkInfo.deviceType = DEVICE_TYPE_SPEAKER;
209 std::shared_ptr<IHpaeRendererManager> hpaeRendererManager = std::make_shared<RenderManagerType>(sinkInfo);
210 EXPECT_EQ(hpaeRendererManager->Init() == SUCCESS, true);
211 WaitForMsgProcessing(hpaeRendererManager);
212 EXPECT_EQ(hpaeRendererManager->IsInit(), true);
213 HpaeStreamInfo streamInfo;
214 TestRendererManagerCreateStream(hpaeRendererManager, streamInfo);
215 int32_t ret = hpaeRendererManager->DestroyStream(streamInfo.sessionId);
216 EXPECT_EQ(ret == SUCCESS, true);
217 WaitForMsgProcessing(hpaeRendererManager);
218 HpaeSinkInputInfo sinkInputInfo;
219 ret = hpaeRendererManager->GetSinkInputInfo(streamInfo.sessionId, sinkInputInfo);
220 EXPECT_EQ(ret == ERR_INVALID_OPERATION, true);
221 streamInfo.channels = STEREO;
222 streamInfo.samplingRate = SAMPLE_RATE_48000;
223 streamInfo.format = SAMPLE_F32LE;
224 streamInfo.frameLen = FRAME_LENGTH_960;
225 streamInfo.sessionId = TEST_STREAM_SESSION_ID;
226 streamInfo.streamType = STREAM_MUSIC;
227 streamInfo.streamClassType = HPAE_STREAM_CLASS_TYPE_PLAY;
228 EXPECT_EQ(hpaeRendererManager->CreateStream(streamInfo) == SUCCESS, true);
229 WaitForMsgProcessing(hpaeRendererManager);
230 EXPECT_EQ(hpaeRendererManager->GetSinkInputInfo(streamInfo.sessionId, sinkInputInfo) == SUCCESS, true);
231 TestCheckSinkInputInfo(sinkInputInfo, streamInfo);
232 EXPECT_EQ(sinkInputInfo.rendererSessionInfo.state, HPAE_SESSION_PREPARED);
233 EXPECT_EQ(hpaeRendererManager->DestroyStream(streamInfo.sessionId) == SUCCESS, true);
234 WaitForMsgProcessing(hpaeRendererManager);
235 ret = hpaeRendererManager->GetSinkInputInfo(streamInfo.sessionId, sinkInputInfo);
236 EXPECT_EQ(ret == ERR_INVALID_OPERATION, true);
237 EXPECT_EQ(hpaeRendererManager->DeInit() == SUCCESS, true);
238 WaitForMsgProcessing(hpaeRendererManager);
239 }
240
241 template <class RenderManagerType>
TestIRendererManagerStartPuaseStream()242 static void TestIRendererManagerStartPuaseStream()
243 {
244 HpaeSinkInfo sinkInfo;
245 sinkInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
246 sinkInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
247 sinkInfo.adapterName = DEFAULT_TEST_DEVICE_CLASS;
248 sinkInfo.filePath = g_rootPath + "constructHpaeRendererManagerTest.pcm";
249 sinkInfo.frameLen = FRAME_LENGTH_960;
250 sinkInfo.samplingRate = SAMPLE_RATE_48000;
251 sinkInfo.format = SAMPLE_F32LE;
252 sinkInfo.channels = STEREO;
253 sinkInfo.deviceType = DEVICE_TYPE_SPEAKER;
254 std::shared_ptr<IHpaeRendererManager> hpaeRendererManager = std::make_shared<RenderManagerType>(sinkInfo);
255 EXPECT_EQ(hpaeRendererManager->Init() == SUCCESS, true);
256 WaitForMsgProcessing(hpaeRendererManager);
257 EXPECT_EQ(hpaeRendererManager->IsInit(), true);
258 HpaeStreamInfo streamInfo;
259 TestRendererManagerCreateStream(hpaeRendererManager, streamInfo);
260 HpaeSinkInputInfo sinkInputInfo;
261 std::shared_ptr<WriteFixedDataCb> writeIncDataCb = std::make_shared<WriteFixedDataCb>(SAMPLE_S16LE);
262 EXPECT_EQ(hpaeRendererManager->RegisterWriteCallback(streamInfo.sessionId, writeIncDataCb), SUCCESS);
263 EXPECT_EQ(writeIncDataCb.use_count() == 1, true);
264 EXPECT_EQ(hpaeRendererManager->Start(streamInfo.sessionId) == SUCCESS, true);
265 // offload need enable after start
266 hpaeRendererManager->SetOffloadPolicy(streamInfo.sessionId, 0);
267 hpaeRendererManager->SetSpeed(streamInfo.sessionId, 1.0f);
268 WaitForMsgProcessing(hpaeRendererManager);
269 EXPECT_EQ(hpaeRendererManager->GetSinkInputInfo(streamInfo.sessionId, sinkInputInfo) == SUCCESS, true);
270 EXPECT_EQ(sinkInputInfo.rendererSessionInfo.state, HPAE_SESSION_RUNNING);
271 EXPECT_EQ(hpaeRendererManager->IsRunning(), true);
272 EXPECT_EQ(hpaeRendererManager->Pause(streamInfo.sessionId) == SUCCESS, true);
273 WaitForMsgProcessing(hpaeRendererManager);
274 EXPECT_EQ(hpaeRendererManager->GetSinkInputInfo(streamInfo.sessionId, sinkInputInfo) == SUCCESS, true);
275 EXPECT_EQ(sinkInputInfo.rendererSessionInfo.state, HPAE_SESSION_PAUSED);
276 EXPECT_EQ(hpaeRendererManager->Start(streamInfo.sessionId) == SUCCESS, true);
277 // offload need enable after start
278 hpaeRendererManager->SetOffloadPolicy(streamInfo.sessionId, 0);
279 hpaeRendererManager->SetSpeed(streamInfo.sessionId, 1.0f);
280 WaitForMsgProcessing(hpaeRendererManager);
281 EXPECT_EQ(hpaeRendererManager->GetSinkInputInfo(streamInfo.sessionId, sinkInputInfo) == SUCCESS, true);
282 EXPECT_EQ(sinkInputInfo.rendererSessionInfo.state, HPAE_SESSION_RUNNING);
283 EXPECT_EQ(hpaeRendererManager->IsRunning(), true);
284 EXPECT_EQ(hpaeRendererManager->Stop(streamInfo.sessionId) == SUCCESS, true);
285 WaitForMsgProcessing(hpaeRendererManager);
286 EXPECT_EQ(hpaeRendererManager->GetSinkInputInfo(streamInfo.sessionId, sinkInputInfo) == SUCCESS, true);
287 EXPECT_EQ(sinkInputInfo.rendererSessionInfo.state, HPAE_SESSION_STOPPED);
288 EXPECT_EQ(hpaeRendererManager->DestroyStream(streamInfo.sessionId) == SUCCESS, true);
289 WaitForMsgProcessing(hpaeRendererManager);
290 EXPECT_EQ(
291 hpaeRendererManager->GetSinkInputInfo(streamInfo.sessionId, sinkInputInfo) == ERR_INVALID_OPERATION, true);
292 EXPECT_EQ(hpaeRendererManager->DeInit() == SUCCESS, true);
293 WaitForMsgProcessing(hpaeRendererManager);
294 }
295
296 template <class RenderManagerType>
TestIRendererManagerSetLoudnessGain()297 static void TestIRendererManagerSetLoudnessGain()
298 {
299 HpaeSinkInfo sinkInfo;
300 sinkInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
301 sinkInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
302 sinkInfo.adapterName = DEFAULT_TEST_DEVICE_CLASS;
303 sinkInfo.filePath = g_rootPath + "constructHpaeRendererManagerTest.pcm";
304 sinkInfo.frameLen = FRAME_LENGTH_960;
305 sinkInfo.samplingRate = SAMPLE_RATE_48000;
306 sinkInfo.format = SAMPLE_F32LE;
307 sinkInfo.channels = STEREO;
308 sinkInfo.deviceType = DEVICE_TYPE_SPEAKER;
309 std::shared_ptr<IHpaeRendererManager> hpaeRendererManager = std::make_shared<RenderManagerType>(sinkInfo);
310
311 EXPECT_EQ(hpaeRendererManager->Init() == SUCCESS, true);
312 WaitForMsgProcessing(hpaeRendererManager);
313 EXPECT_EQ(hpaeRendererManager->IsInit(), true);
314 // test SetLoundessGain when session is created but not connected
315 HpaeStreamInfo streamInfo;
316 streamInfo.channels = STEREO;
317 streamInfo.samplingRate = SAMPLE_RATE_48000;
318 streamInfo.format = SAMPLE_F32LE;
319 streamInfo.frameLen = FRAME_LENGTH_960;
320 streamInfo.sessionId = TEST_STREAM_SESSION_ID;
321 streamInfo.streamType = STREAM_MUSIC;
322 streamInfo.streamClassType = HPAE_STREAM_CLASS_TYPE_PLAY;
323
324 EXPECT_EQ(hpaeRendererManager->CreateStream(streamInfo) == SUCCESS, true);
325 WaitForMsgProcessing(hpaeRendererManager);
326 // test set loundess gain before start
327 EXPECT_EQ(hpaeRendererManager->SetLoudnessGain(streamInfo.sessionId, LOUDNESS_GAIN) == SUCCESS, true);
328 WaitForMsgProcessing(hpaeRendererManager);
329
330 EXPECT_EQ(hpaeRendererManager->Start(streamInfo.sessionId) == SUCCESS, true);
331 WaitForMsgProcessing(hpaeRendererManager);
332
333 // test set loudness gain after start
334 EXPECT_EQ(hpaeRendererManager->SetLoudnessGain(streamInfo.sessionId, LOUDNESS_GAIN) == SUCCESS, true);
335 WaitForMsgProcessing(hpaeRendererManager);
336
337 EXPECT_EQ(hpaeRendererManager->DeInit() == SUCCESS, true);
338 EXPECT_EQ(hpaeRendererManager->IsInit(), false);
339 }
340
341 HWTEST_F(HpaeRendererManagerTest, constructHpaeRendererManagerTest, TestSize.Level0)
342 {
343 TestIRendererManagerConstruct<HpaeRendererManager>();
344 std::cout << "test offload" << std::endl;
345 TestIRendererManagerConstruct<HpaeOffloadRendererManager>();
346 }
347
348 HWTEST_F(HpaeRendererManagerTest, HpaeRendererManagerInitTest, TestSize.Level1)
349 {
350 TestIRendererManagerInit<HpaeRendererManager>();
351 std::cout << "test offload" << std::endl;
352 TestIRendererManagerInit<HpaeOffloadRendererManager>();
353 }
354
355 HWTEST_F(HpaeRendererManagerTest, HpaeRendererManagerReloadTest, TestSize.Level1)
356 {
357 TestRenderManagerReload<HpaeRendererManager>();
358 std::cout << "test offload" << std::endl;
359 TestRenderManagerReload<HpaeOffloadRendererManager>();
360 }
361
362 HWTEST_F(HpaeRendererManagerTest, HpaeRendererManagerCreateDestoryStreamTest, TestSize.Level1)
363 {
364 TestIRendererManagerCreateDestoryStream<HpaeRendererManager>();
365 std::cout << "test offload" << std::endl;
366 TestIRendererManagerCreateDestoryStream<HpaeOffloadRendererManager>();
367 }
368
369 HWTEST_F(HpaeRendererManagerTest, HpaeRendererManagerStartPuaseStreamTest, TestSize.Level1)
370 {
371 TestIRendererManagerStartPuaseStream<HpaeRendererManager>();
372 std::cout << "test offload" << std::endl;
373 TestIRendererManagerStartPuaseStream<HpaeOffloadRendererManager>();
374 }
375
376 template <class RenderManagerType>
HpaeRendererManagerCreateStream(std::shared_ptr<RenderManagerType> & hpaeRendererManager,HpaeStreamInfo & streamInfo)377 static void HpaeRendererManagerCreateStream(
378 std::shared_ptr<RenderManagerType> &hpaeRendererManager, HpaeStreamInfo &streamInfo)
379 {
380 streamInfo.channels = STEREO;
381 streamInfo.samplingRate = SAMPLE_RATE_44100;
382 streamInfo.format = SAMPLE_S16LE;
383 streamInfo.frameLen = FRAME_LENGTH_882;
384 streamInfo.streamType = STREAM_MUSIC;
385 streamInfo.streamClassType = HPAE_STREAM_CLASS_TYPE_PLAY;
386 EXPECT_EQ(hpaeRendererManager->CreateStream(streamInfo) == SUCCESS, true);
387 WaitForMsgProcessing(hpaeRendererManager);
388 HpaeSinkInputInfo sinkInputInfo;
389 int32_t ret = hpaeRendererManager->GetSinkInputInfo(streamInfo.sessionId, sinkInputInfo);
390 EXPECT_EQ(ret == SUCCESS, true);
391 TestCheckSinkInputInfo(sinkInputInfo, streamInfo);
392 }
393
394 HWTEST_F(HpaeRendererManagerTest, HpaeRendererManagerCreateStreamTest_001, TestSize.Level1)
395 {
396 HpaeSinkInfo sinkInfo;
397 sinkInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
398 sinkInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
399 sinkInfo.adapterName = DEFAULT_TEST_DEVICE_CLASS;
400 sinkInfo.filePath = g_rootPath + "constructHpaeRendererManagerTest.pcm";
401 sinkInfo.frameLen = FRAME_LENGTH_960;
402 sinkInfo.samplingRate = SAMPLE_RATE_48000;
403 sinkInfo.format = SAMPLE_F32LE;
404 sinkInfo.channels = STEREO;
405 sinkInfo.deviceType = DEVICE_TYPE_SPEAKER;
406 sinkInfo.deviceName = "MCH_Speaker";
407 sinkInfo.lib = "libmodule-split-stream-sink.z.so";
408 std::shared_ptr<IHpaeRendererManager> hpaeRendererManager = std::make_shared<HpaeRendererManager>(sinkInfo);
409
410 EXPECT_EQ(hpaeRendererManager->DestroyStream(INVALID_ID) == SUCCESS, false);
411 EXPECT_EQ(hpaeRendererManager->Init() == SUCCESS, true);
412 WaitForMsgProcessing(hpaeRendererManager);
413 EXPECT_EQ(hpaeRendererManager->IsInit(), true);
414 HpaeStreamInfo streamInfo;
415 streamInfo.sessionId = 1;
416 HpaeRendererManagerCreateStream(hpaeRendererManager, streamInfo);
417
418 EXPECT_EQ(hpaeRendererManager->DestroyStream(INVALID_ID) == SUCCESS, true);
419 EXPECT_EQ(hpaeRendererManager->DestroyStream(streamInfo.sessionId) == SUCCESS, true);
420 WaitForMsgProcessing(hpaeRendererManager);
421 EXPECT_EQ(hpaeRendererManager->DeInit() == SUCCESS, true);
422 WaitForMsgProcessing(hpaeRendererManager);
423 }
424
425 HWTEST_F(HpaeRendererManagerTest, HpaeRendererManagerCreateStreamTest_002, TestSize.Level1)
426 {
427 HpaeSinkInfo sinkInfo;
428 sinkInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
429 sinkInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
430 sinkInfo.adapterName = DEFAULT_TEST_DEVICE_CLASS;
431 sinkInfo.filePath = g_rootPath + "constructHpaeRendererManagerTest.pcm";
432 sinkInfo.frameLen = FRAME_LENGTH_960;
433 sinkInfo.samplingRate = SAMPLE_RATE_48000;
434 sinkInfo.format = SAMPLE_F32LE;
435 sinkInfo.channels = STEREO;
436 sinkInfo.deviceType = DEVICE_TYPE_SPEAKER;
437 sinkInfo.deviceName = "MCH_Speaker";
438 sinkInfo.lib = "libmodule-split-stream-sink.z.so";
439 std::shared_ptr<IHpaeRendererManager> hpaeRendererManager = std::make_shared<HpaeRendererManager>(sinkInfo);
440
441 EXPECT_EQ(hpaeRendererManager->DestroyStream(INVALID_ID) == SUCCESS, false);
442 EXPECT_EQ(hpaeRendererManager->Init() == SUCCESS, true);
443
444 std::shared_ptr<IHpaeRendererManager> hpaeRendererManagerNew = std::make_shared<HpaeRendererManager>(sinkInfo);
445 EXPECT_EQ(hpaeRendererManagerNew->DestroyStream(INVALID_ID) == SUCCESS, false);
446 EXPECT_EQ(hpaeRendererManagerNew->Init() == SUCCESS, true);
447
448 WaitForMsgProcessing(hpaeRendererManager);
449 WaitForMsgProcessing(hpaeRendererManagerNew);
450 EXPECT_EQ(hpaeRendererManager->IsInit(), true);
451 EXPECT_EQ(hpaeRendererManagerNew->IsInit(), true);
452 HpaeStreamInfo streamInfo;
453 streamInfo.sessionId = 1;
454 HpaeRendererManagerCreateStream(hpaeRendererManager, streamInfo);
455 HpaeRendererManagerCreateStream(hpaeRendererManagerNew, streamInfo);
456
457 EXPECT_EQ(hpaeRendererManager->DestroyStream(INVALID_ID) == SUCCESS, true);
458 EXPECT_EQ(hpaeRendererManager->DestroyStream(streamInfo.sessionId) == SUCCESS, true);
459 WaitForMsgProcessing(hpaeRendererManager);
460 EXPECT_EQ(hpaeRendererManagerNew->DestroyStream(INVALID_ID) == SUCCESS, true);
461 EXPECT_EQ(hpaeRendererManagerNew->DestroyStream(streamInfo.sessionId) == SUCCESS, true);
462 WaitForMsgProcessing(hpaeRendererManagerNew);
463 EXPECT_EQ(hpaeRendererManager->DeInit() == SUCCESS, true);
464 WaitForMsgProcessing(hpaeRendererManager);
465 EXPECT_EQ(hpaeRendererManagerNew->DeInit() == SUCCESS, true);
466 WaitForMsgProcessing(hpaeRendererManagerNew);
467 }
468
469
470 HWTEST_F(HpaeRendererManagerTest, HpaeRendererManagerTransStreamUsage, TestSize.Level1)
471 {
472 HpaeSinkInfo sinkInfo;
473 sinkInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
474 sinkInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
475 sinkInfo.adapterName = DEFAULT_TEST_DEVICE_CLASS;
476 sinkInfo.filePath = g_rootPath + "constructHpaeRendererManagerTest.pcm";
477 sinkInfo.frameLen = FRAME_LENGTH_960;
478 sinkInfo.samplingRate = SAMPLE_RATE_48000;
479 sinkInfo.format = SAMPLE_F32LE;
480 sinkInfo.channels = STEREO;
481 sinkInfo.deviceType = DEVICE_TYPE_SPEAKER;
482 sinkInfo.lib = "libmodule-split-stream-sink.z.so";
483 std::shared_ptr<IHpaeRendererManager> hpaeRendererManager = std::make_shared<HpaeRendererManager>(sinkInfo);
484
485 EXPECT_EQ(hpaeRendererManager->Init() == SUCCESS, true);
486 WaitForMsgProcessing(hpaeRendererManager);
487 EXPECT_EQ(hpaeRendererManager->IsInit(), true);
488 HpaeStreamInfo streamInfo;
489 streamInfo.sessionId = 1;
490 TestRendererManagerCreateStream(hpaeRendererManager, streamInfo);
491
492 HpaeSinkInputInfo sinkInputInfo;
493 std::shared_ptr<WriteFixedDataCb> writeIncDataCb = std::make_shared<WriteFixedDataCb>(SAMPLE_S16LE);
494 EXPECT_EQ(hpaeRendererManager->RegisterWriteCallback(streamInfo.sessionId, writeIncDataCb), SUCCESS);
495 EXPECT_EQ(writeIncDataCb.use_count() == 1, true);
496 EXPECT_EQ(hpaeRendererManager->Start(streamInfo.sessionId) == SUCCESS, true);
497 // offload need enable after start
498 hpaeRendererManager->SetOffloadPolicy(streamInfo.sessionId, 0);
499 WaitForMsgProcessing(hpaeRendererManager);
500 EXPECT_EQ(hpaeRendererManager->GetSinkInputInfo(streamInfo.sessionId, sinkInputInfo) == SUCCESS, true);
501 EXPECT_EQ(sinkInputInfo.rendererSessionInfo.state, HPAE_SESSION_RUNNING);
502 EXPECT_EQ(hpaeRendererManager->IsRunning(), true);
503 EXPECT_EQ(hpaeRendererManager->Pause(streamInfo.sessionId) == SUCCESS, true);
504 WaitForMsgProcessing(hpaeRendererManager);
505 EXPECT_EQ(hpaeRendererManager->GetSinkInputInfo(streamInfo.sessionId, sinkInputInfo) == SUCCESS, true);
506 EXPECT_EQ(sinkInputInfo.rendererSessionInfo.state, HPAE_SESSION_PAUSED);
507 EXPECT_EQ(hpaeRendererManager->Start(streamInfo.sessionId) == SUCCESS, true);
508 // offload need enable after start
509 hpaeRendererManager->SetOffloadPolicy(streamInfo.sessionId, 0);
510 hpaeRendererManager->SetSpeed(streamInfo.sessionId, 1.0f);
511 WaitForMsgProcessing(hpaeRendererManager);
512 EXPECT_EQ(hpaeRendererManager->GetSinkInputInfo(streamInfo.sessionId, sinkInputInfo) == SUCCESS, true);
513 EXPECT_EQ(sinkInputInfo.rendererSessionInfo.state, HPAE_SESSION_RUNNING);
514 EXPECT_EQ(hpaeRendererManager->IsRunning(), true);
515 EXPECT_EQ(hpaeRendererManager->Stop(streamInfo.sessionId) == SUCCESS, true);
516 WaitForMsgProcessing(hpaeRendererManager);
517 EXPECT_EQ(hpaeRendererManager->GetSinkInputInfo(streamInfo.sessionId, sinkInputInfo) == SUCCESS, true);
518 EXPECT_EQ(sinkInputInfo.rendererSessionInfo.state, HPAE_SESSION_STOPPED);
519 EXPECT_EQ(hpaeRendererManager->DestroyStream(streamInfo.sessionId) == SUCCESS, true);
520 WaitForMsgProcessing(hpaeRendererManager);
521 EXPECT_EQ(hpaeRendererManager->GetSinkInputInfo(streamInfo.sessionId, sinkInputInfo), ERR_INVALID_OPERATION);
522 EXPECT_EQ(hpaeRendererManager->DeInit() == SUCCESS, true);
523 WaitForMsgProcessing(hpaeRendererManager);
524 }
525
526 /**
527 * @tc.name : Test MoveAllStream
528 * @tc.type : FUNC
529 * @tc.number: MoveAllStream_001
530 * @tc.desc : Test MoveAllStream when sink is initialized.
531 */
532 HWTEST_F(HpaeRendererManagerTest, MoveAllStream_001, TestSize.Level1)
533 {
534 HpaeSinkInfo sinkInfo;
535 sinkInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
536 sinkInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
537 sinkInfo.adapterName = DEFAULT_TEST_DEVICE_CLASS;
538 sinkInfo.filePath = g_rootPath + "constructHpaeRendererManagerTest.pcm";
539 sinkInfo.frameLen = FRAME_LENGTH_960;
540 sinkInfo.samplingRate = SAMPLE_RATE_48000;
541 sinkInfo.format = SAMPLE_F32LE;
542 sinkInfo.channels = STEREO;
543 sinkInfo.deviceType = DEVICE_TYPE_SPEAKER;
544
545 std::shared_ptr<IHpaeRendererManager> hpaeRendererManager = std::make_shared<HpaeRendererManager>(sinkInfo);
546 EXPECT_EQ(hpaeRendererManager->Init(), SUCCESS);
547 WaitForMsgProcessing(hpaeRendererManager);
548 EXPECT_EQ(hpaeRendererManager->IsInit(), true);
549
550 std::string newSinkName = "test_new_sink";
551 std::vector<uint32_t> sessionIds = {1, 2, 3};
552 MoveSessionType moveType = MOVE_ALL;
553
554 int32_t ret = hpaeRendererManager->MoveAllStream(newSinkName, sessionIds, moveType);
555 EXPECT_EQ(ret, SUCCESS);
556 WaitForMsgProcessing(hpaeRendererManager);
557
558 EXPECT_EQ(hpaeRendererManager->DeInit() == SUCCESS, true);
559 EXPECT_EQ(hpaeRendererManager->IsInit(), false);
560 }
561
562 /**
563 * @tc.name : Test MoveAllStream
564 * @tc.type : FUNC
565 * @tc.number: MoveAllStream_002
566 * @tc.desc : Test MoveAllStream when sink is not initialized.
567 */
568 HWTEST_F(HpaeRendererManagerTest, MoveAllStream_002, TestSize.Level0)
569 {
570 HpaeSinkInfo sinkInfo;
571 sinkInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
572 sinkInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
573 sinkInfo.adapterName = DEFAULT_TEST_DEVICE_CLASS;
574 sinkInfo.filePath = g_rootPath + "constructHpaeRendererManagerTest.pcm";
575 sinkInfo.frameLen = FRAME_LENGTH_960;
576 sinkInfo.samplingRate = SAMPLE_RATE_48000;
577 sinkInfo.format = SAMPLE_F32LE;
578 sinkInfo.channels = STEREO;
579 sinkInfo.deviceType = DEVICE_TYPE_SPEAKER;
580
581 std::shared_ptr<IHpaeRendererManager> hpaeRendererManager = std::make_shared<HpaeRendererManager>(sinkInfo);
582 EXPECT_EQ(hpaeRendererManager->IsInit(), false);
583
584 std::string newSinkName = "test_new_sink";
585 std::vector<uint32_t> sessionIds = {4, 5, 6};
586 MoveSessionType moveType = MOVE_ALL;
587
588 int32_t ret = hpaeRendererManager->MoveAllStream(newSinkName, sessionIds, moveType);
589 EXPECT_EQ(ret, SUCCESS);
590 WaitForMsgProcessing(hpaeRendererManager);
591 }
592
593 /**
594 * @tc.name : Test MoveStreamSync
595 * @tc.type : FUNC
596 * @tc.number: MoveStreamSync_001
597 * @tc.desc : Test MoveStreamSync when sessionId doesn't exist in sinkInputNodeMap_.
598 */
599 HWTEST_F(HpaeRendererManagerTest, MoveStreamSync_001, TestSize.Level1)
600 {
601 HpaeSinkInfo sinkInfo;
602 sinkInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
603 sinkInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
604 sinkInfo.adapterName = DEFAULT_TEST_DEVICE_CLASS;
605 sinkInfo.filePath = g_rootPath + "constructHpaeRendererManagerTest.pcm";
606 sinkInfo.frameLen = FRAME_LENGTH_960;
607 sinkInfo.samplingRate = SAMPLE_RATE_48000;
608 sinkInfo.format = SAMPLE_F32LE;
609 sinkInfo.channels = STEREO;
610 sinkInfo.deviceType = DEVICE_TYPE_SPEAKER;
611
612 std::shared_ptr<HpaeRendererManager> hpaeRendererManager = std::make_shared<HpaeRendererManager>(sinkInfo);
613 EXPECT_EQ(hpaeRendererManager->Init(), SUCCESS);
614 WaitForMsgProcessing(hpaeRendererManager);
615 EXPECT_EQ(hpaeRendererManager->IsInit(), true);
616 HpaeStreamInfo streamInfo;
617 streamInfo.sessionId = TEST_STREAM_SESSION_ID;
618 HpaeRendererManagerCreateStream(hpaeRendererManager, streamInfo);
619
620 uint32_t invalidSessionId = 999; // Assuming this ID doesn't exist
621 std::string sinkName = "valid_sink_name";
622 hpaeRendererManager->MoveStreamSync(invalidSessionId, sinkName);
623
624 EXPECT_EQ(hpaeRendererManager->DeInit() == SUCCESS, true);
625 EXPECT_EQ(hpaeRendererManager->IsInit(), false);
626 }
627
628 /**
629 * @tc.name : Test MoveStreamSync
630 * @tc.type : FUNC
631 * @tc.number: MoveStreamSync_002
632 * @tc.desc : Test MoveStreamSync when sinkName is empty.
633 */
634 HWTEST_F(HpaeRendererManagerTest, MoveStreamSync_002, TestSize.Level1)
635 {
636 HpaeSinkInfo sinkInfo;
637 sinkInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
638 sinkInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
639 sinkInfo.adapterName = DEFAULT_TEST_DEVICE_CLASS;
640 sinkInfo.filePath = g_rootPath + "constructHpaeRendererManagerTest.pcm";
641 sinkInfo.frameLen = FRAME_LENGTH_960;
642 sinkInfo.samplingRate = SAMPLE_RATE_48000;
643 sinkInfo.format = SAMPLE_F32LE;
644 sinkInfo.channels = STEREO;
645 sinkInfo.deviceType = DEVICE_TYPE_SPEAKER;
646
647 std::shared_ptr<HpaeRendererManager> hpaeRendererManager = std::make_shared<HpaeRendererManager>(sinkInfo);
648 EXPECT_EQ(hpaeRendererManager->Init(), SUCCESS);
649 WaitForMsgProcessing(hpaeRendererManager);
650 EXPECT_EQ(hpaeRendererManager->IsInit(), true);
651
652 HpaeStreamInfo streamInfo;
653 streamInfo.sessionId = TEST_STREAM_SESSION_ID;
654 HpaeRendererManagerCreateStream(hpaeRendererManager, streamInfo);
655
656 std::string emptySinkName;
657 hpaeRendererManager->MoveStreamSync(TEST_STREAM_SESSION_ID, emptySinkName);
658
659 EXPECT_EQ(hpaeRendererManager->DeInit() == SUCCESS, true);
660 EXPECT_EQ(hpaeRendererManager->IsInit(), false);
661 }
662
663 /**
664 * @tc.name : Test MoveStreamSync
665 * @tc.type : FUNC
666 * @tc.number: MoveStreamSync_003
667 * @tc.desc : Test MoveStreamSync when session is in HPAE_SESSION_STOPPING state.
668 */
669 HWTEST_F(HpaeRendererManagerTest, MoveStreamSync_003, TestSize.Level1)
670 {
671 HpaeSinkInfo sinkInfo;
672 sinkInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
673 sinkInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
674 sinkInfo.adapterName = DEFAULT_TEST_DEVICE_CLASS;
675 sinkInfo.filePath = g_rootPath + "constructHpaeRendererManagerTest.pcm";
676 sinkInfo.frameLen = FRAME_LENGTH_960;
677 sinkInfo.samplingRate = SAMPLE_RATE_48000;
678 sinkInfo.format = SAMPLE_F32LE;
679 sinkInfo.channels = STEREO;
680 sinkInfo.deviceType = DEVICE_TYPE_SPEAKER;
681
682 std::shared_ptr<HpaeRendererManager> hpaeRendererManager = std::make_shared<HpaeRendererManager>(sinkInfo);
683 EXPECT_EQ(hpaeRendererManager->Init(), SUCCESS);
684 WaitForMsgProcessing(hpaeRendererManager);
685 EXPECT_EQ(hpaeRendererManager->IsInit(), true);
686
687 HpaeStreamInfo streamInfo;
688 streamInfo.sessionId = TEST_STREAM_SESSION_ID;
689 HpaeRendererManagerCreateStream(hpaeRendererManager, streamInfo);
690
691 EXPECT_EQ(hpaeRendererManager->Pause(TEST_STREAM_SESSION_ID), SUCCESS);
692 WaitForMsgProcessing(hpaeRendererManager);
693
694 std::string sinkName = "valid_sink_name";
695 hpaeRendererManager->MoveStreamSync(TEST_STREAM_SESSION_ID, sinkName);
696
697 EXPECT_EQ(hpaeRendererManager->DeInit() == SUCCESS, true);
698 EXPECT_EQ(hpaeRendererManager->IsInit(), false);
699 }
700
701 /**
702 * @tc.name : Test MoveStreamSync
703 * @tc.type : FUNC
704 * @tc.number: MoveStreamSync_004
705 * @tc.desc : Test MoveStreamSync when session is in HPAE_SESSION_PAUSING state.
706 */
707 HWTEST_F(HpaeRendererManagerTest, MoveStreamSync_004, TestSize.Level1)
708 {
709 HpaeSinkInfo sinkInfo;
710 sinkInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
711 sinkInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
712 sinkInfo.adapterName = DEFAULT_TEST_DEVICE_CLASS;
713 sinkInfo.filePath = g_rootPath + "constructHpaeRendererManagerTest.pcm";
714 sinkInfo.frameLen = FRAME_LENGTH_960;
715 sinkInfo.samplingRate = SAMPLE_RATE_48000;
716 sinkInfo.format = SAMPLE_F32LE;
717 sinkInfo.channels = STEREO;
718 sinkInfo.deviceType = DEVICE_TYPE_SPEAKER;
719
720 std::shared_ptr<HpaeRendererManager> hpaeRendererManager = std::make_shared<HpaeRendererManager>(sinkInfo);
721 EXPECT_EQ(hpaeRendererManager->Init(), SUCCESS);
722 WaitForMsgProcessing(hpaeRendererManager);
723 EXPECT_EQ(hpaeRendererManager->IsInit(), true);
724
725 HpaeStreamInfo streamInfo;
726 streamInfo.sessionId = TEST_STREAM_SESSION_ID;
727 HpaeRendererManagerCreateStream(hpaeRendererManager, streamInfo);
728 EXPECT_EQ(hpaeRendererManager->Stop(TEST_STREAM_SESSION_ID), SUCCESS);
729 WaitForMsgProcessing(hpaeRendererManager);
730
731 std::string sinkName = "valid_sink_name";
732 hpaeRendererManager->MoveStreamSync(TEST_STREAM_SESSION_ID, sinkName);
733
734 EXPECT_EQ(hpaeRendererManager->DeInit() == SUCCESS, true);
735 EXPECT_EQ(hpaeRendererManager->IsInit(), false);
736 }
737
738 /**
739 * @tc.name : Test CreateDefaultProcessCluster
740 * @tc.type : FUNC
741 * @tc.number: CreateDefaultProcessCluster_001
742 * @tc.desc : Verify function creates new default cluster when none exists.
743 */
744 HWTEST_F(HpaeRendererManagerTest, CreateDefaultProcessCluster_001, TestSize.Level0)
745 {
746 HpaeSinkInfo sinkInfo;
747 std::shared_ptr<HpaeRendererManager> hpaeRendererManager = std::make_shared<HpaeRendererManager>(sinkInfo);
748 EXPECT_NE(hpaeRendererManager, nullptr);
749 HpaeNodeInfo nodeInfo;
750 hpaeRendererManager->CreateDefaultProcessCluster(nodeInfo);
751 }
752
753 /**
754 * @tc.name : Test CreateDefaultProcessCluster
755 * @tc.type : FUNC
756 * @tc.number: CreateDefaultProcessCluster_002
757 * @tc.desc : Verify function reuses existing default cluster.
758 */
759 HWTEST_F(HpaeRendererManagerTest, CreateDefaultProcessCluster_002, TestSize.Level0)
760 {
761 HpaeSinkInfo sinkInfo;
762 std::shared_ptr<HpaeRendererManager> hpaeRendererManager = std::make_shared<HpaeRendererManager>(sinkInfo);
763 EXPECT_NE(hpaeRendererManager, nullptr);
764
765 HpaeNodeInfo defaultNodeInfo;
766 HpaeNodeInfo nodeInfo;
767 hpaeRendererManager->CreateDefaultProcessCluster(defaultNodeInfo);
768 hpaeRendererManager->CreateDefaultProcessCluster(nodeInfo);
769 }
770
771 /**
772 * @tc.name: ReloadRenderManager
773 * @tc.type: FUNC
774 * @tc.number: ReloadRenderManager_001
775 * @tc.desc: Test basic reload functionality
776 */
777 HWTEST_F(HpaeRendererManagerTest, ReloadRenderManager_001, TestSize.Level1)
778 {
779 HpaeSinkInfo sinkInfo;
780 sinkInfo.deviceName = "test_device";
781 sinkInfo.deviceClass = "test_class";
782
783 std::shared_ptr<IHpaeRendererManager> hpaeRendererManager = std::make_shared<HpaeRendererManager>(sinkInfo);
784
785 int32_t ret = hpaeRendererManager->ReloadRenderManager(sinkInfo);
786 WaitForMsgProcessing(hpaeRendererManager);
787 EXPECT_EQ(ret, SUCCESS);
788 }
789
790 /**
791 * @tc.name: CreateRendererManager
792 * @tc.type: FUNC
793 * @tc.number: CreateRendererManager_001
794 * @tc.desc: Test CreateRendererManager
795 */
796 HWTEST_F(HpaeRendererManagerTest, CreateRendererManager_001, TestSize.Level0)
797 {
798 HpaeSinkInfo sinkInfo;
799 sinkInfo.deviceClass = "remote_offload";
800 std::shared_ptr<IHpaeRendererManager> hpaeRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
801 EXPECT_NE(hpaeRendererManager, nullptr);
802 sinkInfo.deviceClass = "offload";
803 hpaeRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
804 EXPECT_NE(hpaeRendererManager, nullptr);
805 sinkInfo.deviceClass = "test";
806 hpaeRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
807 EXPECT_NE(hpaeRendererManager, nullptr);
808 }
809
810 /**
811 * @tc.name: StartWithSyncId
812 * @tc.type: FUNC
813 * @tc.number: StartWithSyncId_001
814 * @tc.desc: Test StartWithSyncId
815 */
816 HWTEST_F(HpaeRendererManagerTest, StartWithSyncId_001, TestSize.Level0)
817 {
818 HpaeSinkInfo sinkInfo;
819 sinkInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
820 sinkInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
821 sinkInfo.adapterName = DEFAULT_TEST_DEVICE_CLASS;
822 sinkInfo.filePath = g_rootPath + "constructHpaeRendererManagerTest.pcm";
823 sinkInfo.frameLen = FRAME_LENGTH_960;
824 sinkInfo.samplingRate = SAMPLE_RATE_48000;
825 sinkInfo.format = SAMPLE_F32LE;
826 sinkInfo.channels = STEREO;
827 sinkInfo.deviceType = DEVICE_TYPE_SPEAKER;
828 std::shared_ptr<IHpaeRendererManager> hpaeRendererManager = std::make_shared<HpaeRendererManager>(sinkInfo);
829
830 EXPECT_EQ(hpaeRendererManager->Init() == SUCCESS, true);
831 WaitForMsgProcessing(hpaeRendererManager);
832 EXPECT_EQ(hpaeRendererManager->IsInit(), true);
833 // test SetLoundessGain when session is created but not connected
834 HpaeStreamInfo streamInfo;
835 streamInfo.channels = STEREO;
836 streamInfo.samplingRate = SAMPLE_RATE_48000;
837 streamInfo.format = SAMPLE_F32LE;
838 streamInfo.frameLen = FRAME_LENGTH_960;
839 streamInfo.sessionId = TEST_STREAM_SESSION_ID;
840 streamInfo.streamType = STREAM_MUSIC;
841 streamInfo.streamClassType = HPAE_STREAM_CLASS_TYPE_PLAY;
842 int32_t syncId = 123;
843 EXPECT_EQ(hpaeRendererManager->CreateStream(streamInfo) == SUCCESS, true);
844 WaitForMsgProcessing(hpaeRendererManager);
845
846 EXPECT_EQ(hpaeRendererManager->StartWithSyncId(streamInfo.sessionId, syncId) == SUCCESS, true);
847 WaitForMsgProcessing(hpaeRendererManager);
848
849 EXPECT_EQ(hpaeRendererManager->DeInit() == SUCCESS, true);
850 EXPECT_EQ(hpaeRendererManager->IsInit(), false);
851 }
852
GetBtSpeakerSinkInfo(HpaeSinkInfo & sinkInfo)853 static void GetBtSpeakerSinkInfo(HpaeSinkInfo &sinkInfo)
854 {
855 sinkInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
856 sinkInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
857 sinkInfo.adapterName = DEFAULT_TEST_DEVICE_CLASS;
858 sinkInfo.filePath = g_rootPath + "constructHpaeRendererManagerTest.pcm";
859 sinkInfo.frameLen = FRAME_LENGTH_960;
860 sinkInfo.samplingRate = SAMPLE_RATE_48000;
861 sinkInfo.format = SAMPLE_F32LE;
862 sinkInfo.channels = STEREO;
863 sinkInfo.deviceType = DEVICE_TYPE_BLUETOOTH_A2DP;
864 sinkInfo.deviceName = "Bt_Speaker";
865 }
866
867 /**
868 * @tc.name : Test UpdateCollaborativeState
869 * @tc.type : FUNC
870 * @tc.number: UpdateCollaborativeState_001
871 * @tc.desc : Test UpdateCollaborativeState before stream is created.
872 */
873 HWTEST_F(HpaeRendererManagerTest, UpdateCollaborativeState_001, TestSize.Level1)
874 {
875 HpaeSinkInfo sinkInfo;
876 GetBtSpeakerSinkInfo(sinkInfo);
877 std::shared_ptr<IHpaeRendererManager> hpaeRendererManager = std::make_shared<HpaeRendererManager>(sinkInfo);
878 EXPECT_EQ(hpaeRendererManager->Init(), SUCCESS);
879 WaitForMsgProcessing(hpaeRendererManager);
880 EXPECT_EQ(hpaeRendererManager->IsInit(), true);
881 EXPECT_EQ(hpaeRendererManager->UpdateCollaborativeState(true), SUCCESS);
882 HpaeStreamInfo streamInfo;
883 streamInfo.sessionId = 1;
884 streamInfo.effectInfo.effectScene = SCENE_MUSIC;
885 streamInfo.effectInfo.effectMode = EFFECT_DEFAULT;
886 TestRendererManagerCreateStream(hpaeRendererManager, streamInfo);
887 std::shared_ptr<WriteFixedDataCb> writeIncDataCb = std::make_shared<WriteFixedDataCb>(SAMPLE_S16LE);
888 EXPECT_EQ(hpaeRendererManager->RegisterWriteCallback(streamInfo.sessionId, writeIncDataCb), SUCCESS);
889 EXPECT_EQ(writeIncDataCb.use_count() == 1, true);
890 EXPECT_EQ(hpaeRendererManager->Start(streamInfo.sessionId), SUCCESS);
891 WaitForMsgProcessing(hpaeRendererManager);
892 HpaeSinkInputInfo sinkInputInfo;
893 EXPECT_EQ(hpaeRendererManager->GetSinkInputInfo(streamInfo.sessionId, sinkInputInfo), SUCCESS);
894 EXPECT_EQ(sinkInputInfo.rendererSessionInfo.state, HPAE_SESSION_RUNNING);
895 EXPECT_EQ(hpaeRendererManager->IsRunning(), true);
896 EXPECT_EQ(hpaeRendererManager->Pause(streamInfo.sessionId), SUCCESS);
897 WaitForMsgProcessing(hpaeRendererManager);
898 EXPECT_EQ(hpaeRendererManager->GetSinkInputInfo(streamInfo.sessionId, sinkInputInfo), SUCCESS);
899 EXPECT_EQ(sinkInputInfo.rendererSessionInfo.state, HPAE_SESSION_PAUSED);
900 EXPECT_EQ(hpaeRendererManager->Start(streamInfo.sessionId), SUCCESS);
901 WaitForMsgProcessing(hpaeRendererManager);
902 EXPECT_EQ(hpaeRendererManager->GetSinkInputInfo(streamInfo.sessionId, sinkInputInfo), SUCCESS);
903 EXPECT_EQ(sinkInputInfo.rendererSessionInfo.state, HPAE_SESSION_RUNNING);
904 EXPECT_EQ(hpaeRendererManager->IsRunning(), true);
905 EXPECT_EQ(hpaeRendererManager->Stop(streamInfo.sessionId), SUCCESS);
906 WaitForMsgProcessing(hpaeRendererManager);
907 EXPECT_EQ(hpaeRendererManager->GetSinkInputInfo(streamInfo.sessionId, sinkInputInfo), SUCCESS);
908 EXPECT_EQ(sinkInputInfo.rendererSessionInfo.state, HPAE_SESSION_STOPPED);
909 EXPECT_EQ(hpaeRendererManager->DestroyStream(streamInfo.sessionId), SUCCESS);
910 WaitForMsgProcessing(hpaeRendererManager);
911 EXPECT_EQ(hpaeRendererManager->GetSinkInputInfo(streamInfo.sessionId, sinkInputInfo), ERR_INVALID_OPERATION);
912 EXPECT_EQ(hpaeRendererManager->UpdateCollaborativeState(false), SUCCESS);
913 WaitForMsgProcessing(hpaeRendererManager);
914
915 EXPECT_EQ(hpaeRendererManager->DeInit() == SUCCESS, true);
916 EXPECT_EQ(hpaeRendererManager->IsInit(), false);
917 }
918
919 /**
920 * @tc.name : Test UpdateCollaborativeState
921 * @tc.type : FUNC
922 * @tc.number: UpdateCollaborativeState_002
923 * @tc.desc : Test UpdateCollaborativeState after stream is created.
924 */
925 HWTEST_F(HpaeRendererManagerTest, UpdateCollaborativeState_002, TestSize.Level1)
926 {
927 HpaeSinkInfo sinkInfo;
928 GetBtSpeakerSinkInfo(sinkInfo);
929 std::shared_ptr<IHpaeRendererManager> hpaeRendererManager = std::make_shared<HpaeRendererManager>(sinkInfo);
930 EXPECT_EQ(hpaeRendererManager->Init(), SUCCESS);
931 WaitForMsgProcessing(hpaeRendererManager);
932 EXPECT_EQ(hpaeRendererManager->IsInit(), true);
933 HpaeStreamInfo streamInfo;
934 streamInfo.sessionId = 1;
935 streamInfo.effectInfo.effectScene = SCENE_MUSIC;
936 streamInfo.effectInfo.effectMode = EFFECT_DEFAULT;
937 TestRendererManagerCreateStream(hpaeRendererManager, streamInfo);
938 std::shared_ptr<WriteFixedDataCb> writeIncDataCb = std::make_shared<WriteFixedDataCb>(SAMPLE_S16LE);
939 EXPECT_EQ(hpaeRendererManager->RegisterWriteCallback(streamInfo.sessionId, writeIncDataCb), SUCCESS);
940 EXPECT_EQ(writeIncDataCb.use_count() == 1, true);
941 EXPECT_EQ(hpaeRendererManager->Start(streamInfo.sessionId), SUCCESS);
942 WaitForMsgProcessing(hpaeRendererManager);
943 HpaeSinkInputInfo sinkInputInfo;
944 EXPECT_EQ(hpaeRendererManager->GetSinkInputInfo(streamInfo.sessionId, sinkInputInfo), SUCCESS);
945 EXPECT_EQ(sinkInputInfo.rendererSessionInfo.state, HPAE_SESSION_RUNNING);
946 EXPECT_EQ(hpaeRendererManager->IsRunning(), true);
947 EXPECT_EQ(hpaeRendererManager->UpdateCollaborativeState(true), SUCCESS);
948 EXPECT_EQ(hpaeRendererManager->Pause(streamInfo.sessionId), SUCCESS);
949 WaitForMsgProcessing(hpaeRendererManager);
950 EXPECT_EQ(hpaeRendererManager->GetSinkInputInfo(streamInfo.sessionId, sinkInputInfo), SUCCESS);
951 EXPECT_EQ(sinkInputInfo.rendererSessionInfo.state, HPAE_SESSION_PAUSED);
952 EXPECT_EQ(hpaeRendererManager->Start(streamInfo.sessionId), SUCCESS);
953 EXPECT_EQ(hpaeRendererManager->UpdateCollaborativeState(false), SUCCESS);
954 WaitForMsgProcessing(hpaeRendererManager);
955 EXPECT_EQ(hpaeRendererManager->GetSinkInputInfo(streamInfo.sessionId, sinkInputInfo), SUCCESS);
956 EXPECT_EQ(sinkInputInfo.rendererSessionInfo.state, HPAE_SESSION_RUNNING);
957 EXPECT_EQ(hpaeRendererManager->IsRunning(), true);
958 EXPECT_EQ(hpaeRendererManager->Stop(streamInfo.sessionId), SUCCESS);
959 WaitForMsgProcessing(hpaeRendererManager);
960 EXPECT_EQ(hpaeRendererManager->GetSinkInputInfo(streamInfo.sessionId, sinkInputInfo), SUCCESS);
961 EXPECT_EQ(sinkInputInfo.rendererSessionInfo.state, HPAE_SESSION_STOPPED);
962 EXPECT_EQ(hpaeRendererManager->DestroyStream(streamInfo.sessionId), SUCCESS);
963 WaitForMsgProcessing(hpaeRendererManager);
964 EXPECT_EQ(hpaeRendererManager->GetSinkInputInfo(streamInfo.sessionId, sinkInputInfo), ERR_INVALID_OPERATION);
965
966 EXPECT_EQ(hpaeRendererManager->DeInit() == SUCCESS, true);
967 EXPECT_EQ(hpaeRendererManager->IsInit(), false);
968 }
969
970 /**
971 * @tc.name : Test ConnectCoBufferNode
972 * @tc.type : FUNC
973 * @tc.number: ConnectCoBufferNode_001
974 * @tc.desc : Test ConnectCoBufferNode when config in vaild.
975 */
976 HWTEST_F(HpaeRendererManagerTest, ConnectCoBufferNode_001, TestSize.Level1)
977 {
978 HpaeSinkInfo sinkInfo;
979 sinkInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
980 sinkInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
981 sinkInfo.adapterName = DEFAULT_TEST_DEVICE_CLASS;
982 sinkInfo.filePath = g_rootPath + "constructHpaeRendererManagerTest.pcm";
983 sinkInfo.frameLen = FRAME_LENGTH_960;
984 sinkInfo.samplingRate = SAMPLE_RATE_48000;
985 sinkInfo.format = SAMPLE_F32LE;
986 sinkInfo.channels = STEREO;
987 sinkInfo.deviceType = DEVICE_TYPE_SPEAKER;
988 std::shared_ptr<IHpaeRendererManager> hpaeRendererManager = std::make_shared<HpaeRendererManager>(sinkInfo);
989 EXPECT_EQ(hpaeRendererManager->Init(), SUCCESS);
990 WaitForMsgProcessing(hpaeRendererManager);
991 HpaeNodeInfo nodeInfo;
992 nodeInfo.samplingRate = SAMPLE_RATE_48000;
993 nodeInfo.format = SAMPLE_F32LE;
994 nodeInfo.channels = STEREO;
995 nodeInfo.frameLen = FRAME_LENGTH_960;
996 nodeInfo.channelLayout = CH_LAYOUT_STEREO;
997 std::shared_ptr<HpaeCoBufferNode> coBufferNode = std::make_shared<HpaeCoBufferNode>();
998 EXPECT_NE(coBufferNode, nullptr);
999 coBufferNode->SetNodeInfo(nodeInfo);
1000 int32_t ret = hpaeRendererManager->ConnectCoBufferNode(coBufferNode);
1001 EXPECT_EQ(ret, SUCCESS);
1002 WaitForMsgProcessing(hpaeRendererManager);
1003 EXPECT_EQ(hpaeRendererManager->IsRunning(), true);
1004 ret = hpaeRendererManager->DisConnectCoBufferNode(coBufferNode);
1005 EXPECT_EQ(ret, SUCCESS);
1006 WaitForMsgProcessing(hpaeRendererManager);
1007
1008 EXPECT_EQ(hpaeRendererManager->DeInit() == SUCCESS, true);
1009 EXPECT_EQ(hpaeRendererManager->IsInit(), false);
1010 }
1011
1012 HWTEST_F(HpaeRendererManagerTest, HpaeRendererSetLoudnessGain_001, TestSize.Level0)
1013 {
1014 std::cout << "test renderer manager" << std::endl;
1015 TestIRendererManagerSetLoudnessGain<HpaeRendererManager>();
1016 std::cout << "test offload" << std::endl;
1017 TestIRendererManagerSetLoudnessGain<HpaeOffloadRendererManager>();
1018 std::cout << "test innercapture manager" << std::endl;
1019 TestIRendererManagerSetLoudnessGain<HpaeInnerCapturerManager>();
1020 }
1021
1022 /**
1023 * @tc.name: RefreshProcessClusterByDevice
1024 * @tc.type: FUNC
1025 * @tc.number: RefreshProcessClusterByDevice_001
1026 * @tc.desc: Test RefreshProcessClusterByDevice
1027 */
1028 HWTEST_F(HpaeRendererManagerTest, RefreshProcessClusterByDevice_001, TestSize.Level0)
1029 {
1030 HpaeSinkInfo sinkInfo;
1031 sinkInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
1032 sinkInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
1033 sinkInfo.adapterName = DEFAULT_TEST_DEVICE_CLASS;
1034 sinkInfo.filePath = g_rootPath + "constructHpaeRendererManagerTest.pcm";
1035 sinkInfo.frameLen = FRAME_LENGTH_960;
1036 sinkInfo.samplingRate = SAMPLE_RATE_48000;
1037 sinkInfo.format = SAMPLE_F32LE;
1038 sinkInfo.channels = STEREO;
1039 sinkInfo.deviceType = DEVICE_TYPE_SPEAKER;
1040 std::shared_ptr<HpaeRendererManager> hpaeRendererManager = std::make_shared<HpaeRendererManager>(sinkInfo);
1041 EXPECT_EQ(hpaeRendererManager->Init(), SUCCESS);
1042 WaitForMsgProcessing(hpaeRendererManager);
1043 EXPECT_EQ(hpaeRendererManager->IsInit(), true);
1044
1045 HpaeNodeInfo nodeInfo;
1046 nodeInfo.sessionId = 10001;
1047 nodeInfo.effectInfo.effectScene = SCENE_MUSIC;
1048 nodeInfo.effectInfo.effectMode = EFFECT_NONE;
1049 nodeInfo.sceneType = HPAE_SCENE_MUSIC;
1050 hpaeRendererManager->sinkInputNodeMap_[nodeInfo.sessionId] = std::make_shared<HpaeSinkInputNode>(nodeInfo);
1051 hpaeRendererManager->sessionNodeMap_[nodeInfo.sessionId].bypass = true;
1052 AudioEffectChainManager::GetInstance()->spkOffloadEnabled_ = false;
1053 AudioEffectChainManager::GetInstance()->btOffloadEnabled_ = false;
1054 int32_t ret = hpaeRendererManager->RefreshProcessClusterByDevice();
1055 EXPECT_EQ(ret == SUCCESS, true);
1056 WaitForMsgProcessing(hpaeRendererManager);
1057 EXPECT_EQ(hpaeRendererManager->DeInit() == SUCCESS, true);
1058 EXPECT_EQ(hpaeRendererManager->IsInit(), false);
1059 }
1060
1061 /**
1062 * @tc.name: RefreshProcessClusterByDevice
1063 * @tc.type: FUNC
1064 * @tc.number: RefreshProcessClusterByDevice_002
1065 * @tc.desc: Test RefreshProcessClusterByDevice
1066 */
1067 HWTEST_F(HpaeRendererManagerTest, RefreshProcessClusterByDevice_002, TestSize.Level0)
1068 {
1069 HpaeSinkInfo sinkInfo;
1070 sinkInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
1071 sinkInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
1072 sinkInfo.adapterName = DEFAULT_TEST_DEVICE_CLASS;
1073 sinkInfo.filePath = g_rootPath + "constructHpaeRendererManagerTest.pcm";
1074 sinkInfo.frameLen = FRAME_LENGTH_960;
1075 sinkInfo.samplingRate = SAMPLE_RATE_48000;
1076 sinkInfo.format = SAMPLE_F32LE;
1077 sinkInfo.channels = STEREO;
1078 sinkInfo.deviceType = DEVICE_TYPE_SPEAKER;
1079 std::shared_ptr<HpaeRendererManager> hpaeRendererManager = std::make_shared<HpaeRendererManager>(sinkInfo);
1080 EXPECT_EQ(hpaeRendererManager->Init(), SUCCESS);
1081 WaitForMsgProcessing(hpaeRendererManager);
1082 EXPECT_EQ(hpaeRendererManager->IsInit(), true);
1083
1084 HpaeNodeInfo nodeInfo;
1085 nodeInfo.sessionId = 10002;
1086 nodeInfo.effectInfo.effectScene = SCENE_MUSIC;
1087 nodeInfo.effectInfo.effectMode = EFFECT_NONE;
1088 nodeInfo.sceneType = HPAE_SCENE_MUSIC;
1089 hpaeRendererManager->sinkInputNodeMap_[nodeInfo.sessionId] = std::make_shared<HpaeSinkInputNode>(nodeInfo);
1090 hpaeRendererManager->sessionNodeMap_[nodeInfo.sessionId].bypass = false;
1091 AudioEffectChainManager::GetInstance()->spkOffloadEnabled_ = false;
1092 AudioEffectChainManager::GetInstance()->btOffloadEnabled_ = false;
1093 int32_t ret = hpaeRendererManager->RefreshProcessClusterByDevice();
1094 EXPECT_EQ(ret == SUCCESS, true);
1095 WaitForMsgProcessing(hpaeRendererManager);
1096 EXPECT_EQ(hpaeRendererManager->DeInit() == SUCCESS, true);
1097 EXPECT_EQ(hpaeRendererManager->IsInit(), false);
1098 }
1099
1100 /**
1101 * @tc.name: RefreshProcessClusterByDevice
1102 * @tc.type: FUNC
1103 * @tc.number: RefreshProcessClusterByDevice_003
1104 * @tc.desc: Test RefreshProcessClusterByDevice
1105 */
1106 HWTEST_F(HpaeRendererManagerTest, RefreshProcessClusterByDevice_003, TestSize.Level0)
1107 {
1108 HpaeSinkInfo sinkInfo;
1109 sinkInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
1110 sinkInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
1111 sinkInfo.adapterName = DEFAULT_TEST_DEVICE_CLASS;
1112 sinkInfo.filePath = g_rootPath + "constructHpaeRendererManagerTest.pcm";
1113 sinkInfo.frameLen = FRAME_LENGTH_960;
1114 sinkInfo.samplingRate = SAMPLE_RATE_48000;
1115 sinkInfo.format = SAMPLE_F32LE;
1116 sinkInfo.channels = STEREO;
1117 sinkInfo.deviceType = DEVICE_TYPE_SPEAKER;
1118 std::shared_ptr<HpaeRendererManager> hpaeRendererManager = std::make_shared<HpaeRendererManager>(sinkInfo);
1119 EXPECT_EQ(hpaeRendererManager->Init(), SUCCESS);
1120 WaitForMsgProcessing(hpaeRendererManager);
1121 EXPECT_EQ(hpaeRendererManager->IsInit(), true);
1122
1123 HpaeNodeInfo nodeInfo;
1124 nodeInfo.sessionId = 10003;
1125 nodeInfo.effectInfo.effectScene = SCENE_MUSIC;
1126 nodeInfo.effectInfo.effectMode = EFFECT_NONE;
1127 nodeInfo.sceneType = HPAE_SCENE_MUSIC;
1128 hpaeRendererManager->sinkInputNodeMap_[nodeInfo.sessionId] = std::make_shared<HpaeSinkInputNode>(nodeInfo);
1129 hpaeRendererManager->sessionNodeMap_[nodeInfo.sessionId].bypass = true;
1130 AudioEffectChainManager::GetInstance()->spkOffloadEnabled_ = true;
1131 AudioEffectChainManager::GetInstance()->btOffloadEnabled_ = true;
1132 int32_t ret = hpaeRendererManager->RefreshProcessClusterByDevice();
1133 EXPECT_EQ(ret == SUCCESS, true);
1134 WaitForMsgProcessing(hpaeRendererManager);
1135 EXPECT_EQ(hpaeRendererManager->DeInit() == SUCCESS, true);
1136 EXPECT_EQ(hpaeRendererManager->IsInit(), false);
1137 }
1138
1139 /**
1140 * @tc.name: RefreshProcessClusterByDevice
1141 * @tc.type: FUNC
1142 * @tc.number: RefreshProcessClusterByDevice_004
1143 * @tc.desc: Test RefreshProcessClusterByDevice
1144 */
1145 HWTEST_F(HpaeRendererManagerTest, RefreshProcessClusterByDevice_004, TestSize.Level0)
1146 {
1147 HpaeSinkInfo sinkInfo;
1148 sinkInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
1149 sinkInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
1150 sinkInfo.adapterName = DEFAULT_TEST_DEVICE_CLASS;
1151 sinkInfo.filePath = g_rootPath + "constructHpaeRendererManagerTest.pcm";
1152 sinkInfo.frameLen = FRAME_LENGTH_960;
1153 sinkInfo.samplingRate = SAMPLE_RATE_48000;
1154 sinkInfo.format = SAMPLE_F32LE;
1155 sinkInfo.channels = STEREO;
1156 sinkInfo.deviceType = DEVICE_TYPE_SPEAKER;
1157 std::shared_ptr<HpaeRendererManager> hpaeRendererManager = std::make_shared<HpaeRendererManager>(sinkInfo);
1158 EXPECT_EQ(hpaeRendererManager->Init(), SUCCESS);
1159 WaitForMsgProcessing(hpaeRendererManager);
1160 EXPECT_EQ(hpaeRendererManager->IsInit(), true);
1161
1162 HpaeNodeInfo nodeInfo;
1163 nodeInfo.sessionId = 10004;
1164 nodeInfo.effectInfo.effectScene = SCENE_MUSIC;
1165 nodeInfo.effectInfo.effectMode = EFFECT_NONE;
1166 nodeInfo.sceneType = HPAE_SCENE_MUSIC;
1167 hpaeRendererManager->sinkInputNodeMap_[nodeInfo.sessionId] = std::make_shared<HpaeSinkInputNode>(nodeInfo);
1168 hpaeRendererManager->sessionNodeMap_[nodeInfo.sessionId].bypass = false;
1169 AudioEffectChainManager::GetInstance()->spkOffloadEnabled_ = true;
1170 AudioEffectChainManager::GetInstance()->btOffloadEnabled_ = true;
1171 int32_t ret = hpaeRendererManager->RefreshProcessClusterByDevice();
1172 EXPECT_EQ(ret == SUCCESS, true);
1173 WaitForMsgProcessing(hpaeRendererManager);
1174 EXPECT_EQ(hpaeRendererManager->DeInit() == SUCCESS, true);
1175 EXPECT_EQ(hpaeRendererManager->IsInit(), false);
1176 }
1177 } // namespace