1 /*
2 * Copyright (c) 2024 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 "audio_errors.h"
17 #include "audio_service_log.h"
18 #include "audio_info.h"
19 #include "audio_ring_cache.h"
20 #include "audio_process_config.h"
21 #include "linear_pos_time_model.h"
22 #include "oh_audio_buffer.h"
23 #include <gtest/gtest.h>
24 #include "pa_renderer_stream_impl.h"
25 #include "policy_handler.h"
26 #include "pa_adapter_manager.h"
27 #include "audio_capturer_private.h"
28 #include "audio_system_manager.h"
29
30 using namespace testing::ext;
31 namespace OHOS {
32 namespace AudioStandard {
33 const int32_t CAPTURER_FLAG = 10;
34
35 class PaRendererStreamUnitTestP2 : public ::testing::Test {
36 public:
37 void SetUp();
38 void TearDown();
39 std::shared_ptr<PaRendererStreamImpl> CreatePaRendererStreamImpl();
40 };
SetUp(void)41 void PaRendererStreamUnitTestP2::SetUp(void)
42 {
43 // input testcase setup step，setup invoked before each testcases
44 }
45
TearDown(void)46 void PaRendererStreamUnitTestP2::TearDown(void)
47 {
48 // input testcase teardown step，teardown invoked after each testcases
49 }
50
51 #ifdef HAS_FEATURE_INNERCAPTURER
LoadPaPort()52 void LoadPaPort()
53 {
54 AudioPlaybackCaptureConfig checkConfig;
55 int32_t checkInnerCapId = 0;
56 AudioSystemManager::GetInstance()->CheckCaptureLimit(checkConfig, checkInnerCapId);
57 }
58
ReleasePaPort()59 void ReleasePaPort()
60 {
61 AudioSystemManager::GetInstance()->ReleaseCaptureLimit(1);
62 }
63 #endif
64
GetInnerCapConfig()65 static AudioProcessConfig GetInnerCapConfig()
66 {
67 AudioProcessConfig config;
68 config.appInfo.appUid = CAPTURER_FLAG;
69 config.appInfo.appPid = CAPTURER_FLAG;
70 config.streamInfo.format = SAMPLE_S32LE;
71 config.streamInfo.samplingRate = SAMPLE_RATE_48000;
72 config.streamInfo.channels = STEREO;
73 config.streamInfo.channelLayout = AudioChannelLayout::CH_LAYOUT_STEREO;
74 config.audioMode = AudioMode::AUDIO_MODE_PLAYBACK;
75 config.streamType = AudioStreamType::STREAM_MUSIC;
76 config.deviceType = DEVICE_TYPE_USB_HEADSET;
77 config.innerCapId = 1;
78 return config;
79 }
80
CreatePaRendererStreamImpl()81 std::shared_ptr<PaRendererStreamImpl> PaRendererStreamUnitTestP2::CreatePaRendererStreamImpl()
82 {
83 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
84 adapterManager->InitPaContext();
85 AudioProcessConfig processConfig = GetInnerCapConfig();
86 uint32_t sessionId = 123456;
87 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
88 std::shared_ptr<IRendererStream> rendererStream = adapterManager->CreateRendererStream(processConfig, stream);
89 std::shared_ptr<PaRendererStreamImpl> rendererStreamImpl =
90 std::static_pointer_cast<PaRendererStreamImpl>(rendererStream);
91 return rendererStreamImpl;
92 }
93
94 /**
95 * @tc.name : Test GetCurrentPosition.
96 * @tc.type : FUNC
97 * @tc.number: PaRenderer_004
98 * @tc.desc : Test GetCurrentPosition.
99 */
100 HWTEST_F(PaRendererStreamUnitTestP2, PaRenderer_004, TestSize.Level1)
101 {
102 #ifdef HAS_FEATURE_INNERCAPTURER
103 LoadPaPort();
104 #endif
105 auto unit = CreatePaRendererStreamImpl();
106 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
107 adapterManager->InitPaContext();
108 uint32_t sessionId = 123456;
109 AudioProcessConfig processConfig = GetInnerCapConfig();
110 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
111 unit->paStream_ = stream;
112 if (stream == nullptr) {
113 std::cout << "stream is nullptr" << std::endl;
114 }
115 uint64_t framePosition = 0;
116 uint64_t timestamp = 0;
117 uint64_t latency = 0;
118 unit->firstGetPaLatency_ = true;
119 unit->GetCurrentPosition(framePosition, timestamp, latency, Timestamp::MONOTONIC);
120 EXPECT_EQ(false, unit->firstGetPaLatency_);
121 }
122
123 /**
124 * @tc.name : Test GetCurrentPosition.
125 * @tc.type : FUNC
126 * @tc.number: PaRenderer_005
127 * @tc.desc : Test GetCurrentPosition.
128 */
129 HWTEST_F(PaRendererStreamUnitTestP2, PaRenderer_005, TestSize.Level1)
130 {
131 auto unit = CreatePaRendererStreamImpl();
132 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
133 adapterManager->InitPaContext();
134 uint32_t sessionId = 123456;
135 AudioProcessConfig processConfig = GetInnerCapConfig();
136 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
137 unit->paStream_ = stream;
138 if (stream == nullptr) {
139 std::cout << "stream is nullptr" << std::endl;
140 }
141 uint64_t framePosition = 0;
142 uint64_t timestamp = 0;
143 uint64_t latency = 0;
144 unit->offloadEnable_ = true;
145 int32_t ret = unit->GetCurrentPosition(framePosition, timestamp, latency, Timestamp::MONOTONIC);
146 EXPECT_EQ(ret, SUCCESS);
147 }
148
149 /**
150 * @tc.name : Test GetLatency.
151 * @tc.type : FUNC
152 * @tc.number: PaRenderer_006
153 * @tc.desc : Test GetLatency.
154 */
155 HWTEST_F(PaRendererStreamUnitTestP2, PaRenderer_006, TestSize.Level1)
156 {
157 auto unit = CreatePaRendererStreamImpl();
158 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
159 adapterManager->InitPaContext();
160 uint32_t sessionId = 123456;
161 AudioProcessConfig processConfig = GetInnerCapConfig();
162 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
163 unit->paStream_ = stream;
164 if (stream == nullptr) {
165 std::cout << "stream is nullptr" << std::endl;
166 }
167 uint64_t latency = 0;
168 unit->firstGetLatency_= false;
169 int32_t ret = unit->GetLatency(latency);
170 EXPECT_EQ(ret, SUCCESS);
171 }
172
173 /**
174 * @tc.name : Test InitParams.
175 * @tc.type : FUNC
176 * @tc.number: PaRenderer_007
177 * @tc.desc : Test InitParams.
178 */
179 HWTEST_F(PaRendererStreamUnitTestP2, PaRenderer_007, TestSize.Level1)
180 {
181 auto unit = CreatePaRendererStreamImpl();
182 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
183 adapterManager->InitPaContext();
184 uint32_t sessionId = 123456;
185 AudioProcessConfig processConfig = GetInnerCapConfig();
186 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
187 unit->paStream_ = stream;
188 int32_t ret = unit->InitParams();
189 EXPECT_EQ(ret, SUCCESS);
190 }
191
192 /**
193 * @tc.name : Test OffloadSetVolume.
194 * @tc.type : FUNC
195 * @tc.number: PaRenderer_008
196 * @tc.desc : Test OffloadSetVolume.
197 */
198 HWTEST_F(PaRendererStreamUnitTestP2, PaRenderer_008, TestSize.Level1)
199 {
200 auto unit = CreatePaRendererStreamImpl();
201 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
202 adapterManager->InitPaContext();
203 uint32_t sessionId = 123456;
204 AudioProcessConfig processConfig = GetInnerCapConfig();
205 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
206 unit->paStream_ = stream;
207 unit->offloadEnable_ = true;
208 float volume = 0.0f;
209 EXPECT_NE(unit->OffloadSetVolume(volume), SUCCESS);
210 }
211
212 /**
213 * @tc.name : Test SetOffloadMode.
214 * @tc.type : FUNC
215 * @tc.number: PaRenderer_009
216 * @tc.desc : Test SetOffloadMode.
217 */
218 HWTEST_F(PaRendererStreamUnitTestP2, PaRenderer_009, TestSize.Level1)
219 {
220 auto unit = CreatePaRendererStreamImpl();
221 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
222 adapterManager->InitPaContext();
223 uint32_t sessionId = 123456;
224 AudioProcessConfig processConfig = GetInnerCapConfig();
225 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
226 unit->paStream_ = stream;
227 if (stream == nullptr) {
228 std::cout << "stream is nullptr" << std::endl;
229 }
230 int32_t state = 0;
231 bool isAppBack = false;
232 EXPECT_EQ(unit->SetOffloadMode(state, isAppBack), SUCCESS);
233 }
234
235 /**
236 * @tc.name : Test SetOffloadMode.
237 * @tc.type : FUNC
238 * @tc.number: PaRenderer_010
239 * @tc.desc : Test SetOffloadMode.
240 */
241 HWTEST_F(PaRendererStreamUnitTestP2, PaRenderer_010, TestSize.Level1)
242 {
243 auto unit = CreatePaRendererStreamImpl();
244 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
245 adapterManager->InitPaContext();
246 uint32_t sessionId = 123456;
247 AudioProcessConfig processConfig = GetInnerCapConfig();
248 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
249 unit->paStream_ = stream;
250 if (stream == nullptr) {
251 std::cout << "stream is nullptr" << std::endl;
252 }
253 unit->offloadNextStateTargetPolicy_ = OFFLOAD_ACTIVE_FOREGROUND;
254 int32_t state = 0;
255 bool isAppBack = false;
256 EXPECT_EQ(unit->SetOffloadMode(state, isAppBack), SUCCESS);
257 }
258
259 /**
260 * @tc.name : Test SetOffloadMode.
261 * @tc.type : FUNC
262 * @tc.number: PaRenderer_011
263 * @tc.desc : Test SetOffloadMode.
264 */
265 HWTEST_F(PaRendererStreamUnitTestP2, PaRenderer_011, TestSize.Level1)
266 {
267 auto unit = CreatePaRendererStreamImpl();
268 unit->paStream_ = nullptr;
269 unit->offloadNextStateTargetPolicy_ = OFFLOAD_DEFAULT;
270 int32_t state = 0;
271 bool isAppBack = false;
272 EXPECT_EQ(unit->SetOffloadMode(state, isAppBack), ERR_OPERATION_FAILED);
273 }
274 /**
275 * @tc.name : Test OffloadUpdatePolicyInWrite.
276 * @tc.type : FUNC
277 * @tc.number: PaRenderer_012
278 * @tc.desc : Test OffloadUpdatePolicyInWrite.
279 */
280 HWTEST_F(PaRendererStreamUnitTestP2, PaRenderer_012, TestSize.Level1)
281 {
282 auto unit = CreatePaRendererStreamImpl();
283 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
284 adapterManager->InitPaContext();
285 uint32_t sessionId = 123456;
286 AudioProcessConfig processConfig = GetInnerCapConfig();
287 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
288 unit->paStream_ = stream;
289 unit->offloadEnable_ = true;
290 unit->lastOffloadUpdateFinishTime_ = -1;
291 int32_t ret = unit->OffloadUpdatePolicyInWrite();
292 EXPECT_EQ(ret, SUCCESS);
293 }
294
295 /**
296 * @tc.name : Test GetCurrentPosition.
297 * @tc.type : FUNC
298 * @tc.number: PaRenderer_013
299 * @tc.desc : Test GetCurrentPosition.
300 */
301 HWTEST_F(PaRendererStreamUnitTestP2, PaRenderer_013, TestSize.Level1)
302 {
303 auto unit = CreatePaRendererStreamImpl();
304 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
305 adapterManager->InitPaContext();
306 uint32_t sessionId = 123456;
307 AudioProcessConfig processConfig = GetInnerCapConfig();
308 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
309 unit->paStream_ = stream;
310 if (stream == nullptr) {
311 std::cout << "stream is nullptr" << std::endl;
312 }
313 uint64_t framePosition = 0;
314 uint64_t timestamp = 0;
315 uint64_t latency = 0;
316 unit->firstGetPaLatency_ = true;
317 unit->GetCurrentPosition(framePosition, timestamp, latency, Timestamp::MONOTONIC);
318 EXPECT_EQ(false, unit->firstGetPaLatency_);
319 }
320
321 /**
322 * @tc.name : Test GetCurrentPosition.
323 * @tc.type : FUNC
324 * @tc.number: PaRenderer_014
325 * @tc.desc : Test GetCurrentPosition.
326 */
327 HWTEST_F(PaRendererStreamUnitTestP2, PaRenderer_014, TestSize.Level1)
328 {
329 auto unit = CreatePaRendererStreamImpl();
330 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
331 adapterManager->InitPaContext();
332 uint32_t sessionId = 123456;
333 AudioProcessConfig processConfig = GetInnerCapConfig();
334 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
335 unit->paStream_ = stream;
336 if (stream == nullptr) {
337 std::cout << "stream is nullptr" << std::endl;
338 }
339 uint64_t framePosition = 0;
340 uint64_t timestamp = 0;
341 uint64_t latency = 0;
342 unit->offloadEnable_ = true;
343 int32_t ret = unit->GetCurrentPosition(framePosition, timestamp, latency, Timestamp::MONOTONIC);
344 EXPECT_EQ(ret, SUCCESS);
345 }
346
347 /**
348 * @tc.name : Test GetLatency.
349 * @tc.type : FUNC
350 * @tc.number: PaRenderer_015
351 * @tc.desc : Test GetLatency.
352 */
353 HWTEST_F(PaRendererStreamUnitTestP2, PaRenderer_015, TestSize.Level1)
354 {
355 auto unit = CreatePaRendererStreamImpl();
356 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
357 adapterManager->InitPaContext();
358 uint32_t sessionId = 123456;
359 AudioProcessConfig processConfig = GetInnerCapConfig();
360 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
361 unit->paStream_ = stream;
362 uint64_t latency = 0;
363 unit->firstGetLatency_= false;
364 int32_t ret = unit->GetLatency(latency);
365 EXPECT_EQ(ret, SUCCESS);
366 #ifdef HAS_FEATURE_INNERCAPTURER
367 ReleasePaPort();
368 #endif
369 }
370
371 /**
372 * @tc.name : Test
373 * @tc.type : FUNC
374 * @tc.number: PaRenderer_016
375 * @tc.desc : Test PAStreamMovedCb.
376 */
377 HWTEST_F(PaRendererStreamUnitTestP2, PaRenderer_016, TestSize.Level1)
378 {
379 auto unit = CreatePaRendererStreamImpl();
380 std::shared_ptr<PaAdapterManager> adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
381 adapterManager->InitPaContext();
382 uint32_t sessionId = 123456;
383 AudioProcessConfig processConfig = GetInnerCapConfig();
384 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
385 unit->paStream_ = stream;
386 void *userdataRet = nullptr;
387
388 EXPECT_EQ(userdataRet, nullptr);
389 unit->PAStreamMovedCb(stream, userdataRet);
390 unit->PAStreamMovedCb(stream, (void *)1);
391 }
392
393 /**
394 * @tc.name : Test
395 * @tc.type : FUNC
396 * @tc.number: PaRenderer_017
397 * @tc.desc : Test UpdateBufferSize.
398 */
399 HWTEST_F(PaRendererStreamUnitTestP2, PaRenderer_017, TestSize.Level1)
400 {
401 auto unit = CreatePaRendererStreamImpl();
402 uint32_t bufferLength = 10;
403 int32_t ret = unit->UpdateBufferSize(bufferLength);
404 EXPECT_EQ(ret, SUCCESS);
405 }
406 }
407 }