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 "audio_errors.h"
17 #include "audio_concurrency_service_unit_test.h"
18
19 using namespace testing::ext;
20
21 namespace OHOS {
22 namespace AudioStandard {
23
SetUpTestCase(void)24 void AudioConcurrencyServiceUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)25 void AudioConcurrencyServiceUnitTest::TearDownTestCase(void) {}
SetUp(void)26 void AudioConcurrencyServiceUnitTest::SetUp(void) {}
TearDown(void)27 void AudioConcurrencyServiceUnitTest::TearDown(void) {}
28
29 /**
30 * @tc.name : Test AudioInputThread.
31 * @tc.number: AudioConcurrencyService_001.
32 * @tc.desc : Test OnRemoteDied.
33 */
34 HWTEST_F(AudioConcurrencyServiceUnitTest, AudioConcurrencyService_001, TestSize.Level1)
35 {
36 std::shared_ptr<AudioConcurrencyService> service = std::make_shared<AudioConcurrencyService>();
37 uint32_t sessionID = 0;
38 auto deathRecipient = std::make_shared<AudioConcurrencyService::AudioConcurrencyDeathRecipient>(service, sessionID);
39 deathRecipient->OnRemoteDied(nullptr);
40 EXPECT_NE(deathRecipient, nullptr);
41 }
42
43 /**
44 * @tc.name : Test AudioInputThread.
45 * @tc.number: AudioConcurrencyService_002.
46 * @tc.desc : Test UnsetAudioConcurrencyCallback.
47 */
48 HWTEST_F(AudioConcurrencyServiceUnitTest, AudioConcurrencyService_002, TestSize.Level1)
49 {
50 uint32_t sessionID = 0;
51 std::shared_ptr<AudioConcurrencyService> audioConcurrencyService = std::make_shared<AudioConcurrencyService>();
52 auto result = audioConcurrencyService->UnsetAudioConcurrencyCallback(sessionID);
53 EXPECT_EQ(result, ERR_INVALID_PARAM);
54 }
55
56 /**
57 * @tc.name : Test AudioInputThread.
58 * @tc.number: AudioConcurrencyService_003.
59 * @tc.desc : Test ActivateAudioConcurrency.
60 */
61 HWTEST_F(AudioConcurrencyServiceUnitTest, AudioConcurrencyService_003, TestSize.Level1)
62 {
63 std::vector<std::shared_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
64 std::vector<std::shared_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
65 auto audioConcurrencyService = std::make_shared<AudioConcurrencyService>();
66 auto result = audioConcurrencyService->ActivateAudioConcurrency(AudioPipeType::PIPE_TYPE_CALL_IN,
67 audioRendererChangeInfos, audioCapturerChangeInfos);
68 EXPECT_EQ(result, SUCCESS);
69 }
70
71 /**
72 * @tc.name : Test AudioInputThread.
73 * @tc.number: AudioConcurrencyService_004.
74 * @tc.desc : Test ActivateAudioConcurrency.
75 */
76 HWTEST_F(AudioConcurrencyServiceUnitTest, AudioConcurrencyService_004, TestSize.Level1)
77 {
78 std::vector<std::shared_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
79 std::vector<std::shared_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
80 auto audioConcurrencyService = std::make_shared<AudioConcurrencyService>();
81
82 auto audioRendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
83 audioRendererChangeInfo->rendererInfo.pipeType = PIPE_TYPE_OFFLOAD;
84 audioRendererChangeInfos.push_back(audioRendererChangeInfo);
85
86 std::pair<AudioPipeType, AudioPipeType> pair;
87 audioConcurrencyService->concurrencyCfgMap_.insert({pair, ConcurrencyAction::PLAY_BOTH});
88
89 auto result = audioConcurrencyService->ActivateAudioConcurrency(AudioPipeType::PIPE_TYPE_OFFLOAD,
90 audioRendererChangeInfos, audioCapturerChangeInfos);
91 EXPECT_EQ(result, SUCCESS);
92 }
93
94 /**
95 * @tc.name : Test AudioInputThread.
96 * @tc.number: AudioConcurrencyService_005.
97 * @tc.desc : Test ActivateAudioConcurrency.
98 */
99 HWTEST_F(AudioConcurrencyServiceUnitTest, AudioConcurrencyService_005, TestSize.Level1)
100 {
101 std::vector<std::shared_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
102 std::vector<std::shared_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
103 auto audioConcurrencyService = std::make_shared<AudioConcurrencyService>();
104
105 auto audioRendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
106 audioRendererChangeInfo->rendererInfo.pipeType = PIPE_TYPE_CALL_OUT;
107 audioRendererChangeInfos.push_back(audioRendererChangeInfo);
108
109 std::pair<AudioPipeType, AudioPipeType> pair;
110 audioConcurrencyService->concurrencyCfgMap_.insert({pair, ConcurrencyAction::PLAY_BOTH});
111
112 auto result = audioConcurrencyService->ActivateAudioConcurrency(AudioPipeType::PIPE_TYPE_CALL_OUT,
113 audioRendererChangeInfos, audioCapturerChangeInfos);
114 EXPECT_EQ(result, SUCCESS);
115 }
116
117 /**
118 * @tc.name : Test AudioInputThread.
119 * @tc.number: AudioConcurrencyService_006.
120 * @tc.desc : Test ActivateAudioConcurrency.
121 */
122 HWTEST_F(AudioConcurrencyServiceUnitTest, AudioConcurrencyService_006, TestSize.Level1)
123 {
124 std::vector<std::shared_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
125 std::vector<std::shared_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
126 auto audioConcurrencyService = std::make_shared<AudioConcurrencyService>();
127
128 auto audioRendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
129 audioRendererChangeInfo->rendererInfo.pipeType = PIPE_TYPE_NORMAL_OUT;
130 audioRendererChangeInfos.push_back(audioRendererChangeInfo);
131
132 std::pair<AudioPipeType, AudioPipeType> pair;
133 audioConcurrencyService->concurrencyCfgMap_.insert({pair, ConcurrencyAction::PLAY_BOTH});
134
135 auto result = audioConcurrencyService->ActivateAudioConcurrency(AudioPipeType::PIPE_TYPE_CALL_OUT,
136 audioRendererChangeInfos, audioCapturerChangeInfos);
137 EXPECT_EQ(result, SUCCESS);
138 }
139
140 /**
141 * @tc.name : Test AudioInputThread.
142 * @tc.number: AudioConcurrencyService_007.
143 * @tc.desc : Test ActivateAudioConcurrency.
144 */
145 HWTEST_F(AudioConcurrencyServiceUnitTest, AudioConcurrencyService_007, TestSize.Level1)
146 {
147 std::vector<std::shared_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
148 std::vector<std::shared_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
149 auto audioConcurrencyService = std::make_shared<AudioConcurrencyService>();
150
151 auto audioRendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
152 audioRendererChangeInfo->rendererInfo.pipeType = PIPE_TYPE_NORMAL_OUT;
153 audioRendererChangeInfos.push_back(audioRendererChangeInfo);
154
155 std::pair<AudioPipeType, AudioPipeType> pair = std::make_pair(audioRendererChangeInfo->rendererInfo.pipeType,
156 AudioPipeType::PIPE_TYPE_MULTICHANNEL);
157 audioConcurrencyService->concurrencyCfgMap_.insert({pair, ConcurrencyAction::CONCEDE_EXISTING});
158
159 audioConcurrencyService->handler_ = std::make_shared<AudioPolicyServerHandler>();
160 auto result = audioConcurrencyService->ActivateAudioConcurrency(AudioPipeType::PIPE_TYPE_MULTICHANNEL,
161 audioRendererChangeInfos, audioCapturerChangeInfos);
162 EXPECT_EQ(result, SUCCESS);
163 }
164
165 /**
166 * @tc.name : Test AudioInputThread.
167 * @tc.number: AudioConcurrencyService_008.
168 * @tc.desc : Test ActivateAudioConcurrency.
169 */
170 HWTEST_F(AudioConcurrencyServiceUnitTest, AudioConcurrencyService_008, TestSize.Level1)
171 {
172 std::vector<std::shared_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
173 std::vector<std::shared_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
174 auto audioConcurrencyService = std::make_shared<AudioConcurrencyService>();
175
176 auto audioRendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
177 audioRendererChangeInfo->rendererInfo.pipeType = PIPE_TYPE_NORMAL_OUT;
178 audioRendererChangeInfos.push_back(audioRendererChangeInfo);
179
180 std::pair<AudioPipeType, AudioPipeType> pair = std::make_pair(audioRendererChangeInfo->rendererInfo.pipeType,
181 AudioPipeType::PIPE_TYPE_MULTICHANNEL);
182 audioConcurrencyService->concurrencyCfgMap_.insert({pair, ConcurrencyAction::CONCEDE_EXISTING});
183
184 audioConcurrencyService->handler_ = nullptr;
185 auto result = audioConcurrencyService->ActivateAudioConcurrency(AudioPipeType::PIPE_TYPE_MULTICHANNEL,
186 audioRendererChangeInfos, audioCapturerChangeInfos);
187 EXPECT_EQ(result, SUCCESS);
188 }
189
190 /**
191 * @tc.name : Test AudioInputThread.
192 * @tc.number: AudioConcurrencyService_009.
193 * @tc.desc : Test ActivateAudioConcurrency.
194 */
195 HWTEST_F(AudioConcurrencyServiceUnitTest, AudioConcurrencyService_009, TestSize.Level1)
196 {
197 std::vector<std::shared_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
198 std::vector<std::shared_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
199 auto audioConcurrencyService = std::make_shared<AudioConcurrencyService>();
200
201 auto audioRendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
202 audioRendererChangeInfo->rendererInfo.pipeType = PIPE_TYPE_NORMAL_OUT;
203 audioRendererChangeInfos.push_back(audioRendererChangeInfo);
204
205 std::pair<AudioPipeType, AudioPipeType> pair = std::make_pair(audioRendererChangeInfo->rendererInfo.pipeType,
206 AudioPipeType::PIPE_TYPE_MULTICHANNEL);
207 audioConcurrencyService->concurrencyCfgMap_.insert({pair, ConcurrencyAction::PLAY_BOTH});
208
209 audioConcurrencyService->handler_ = std::make_shared<AudioPolicyServerHandler>();
210 auto result = audioConcurrencyService->ActivateAudioConcurrency(AudioPipeType::PIPE_TYPE_MULTICHANNEL,
211 audioRendererChangeInfos, audioCapturerChangeInfos);
212 EXPECT_EQ(result, SUCCESS);
213
214 audioConcurrencyService->handler_ = nullptr;
215 result = audioConcurrencyService->ActivateAudioConcurrency(AudioPipeType::PIPE_TYPE_MULTICHANNEL,
216 audioRendererChangeInfos, audioCapturerChangeInfos);
217 EXPECT_EQ(result, SUCCESS);
218 }
219
220 /**
221 * @tc.name : Test AudioInputThread.
222 * @tc.number: AudioConcurrencyService_010.
223 * @tc.desc : Test ActivateAudioConcurrency.
224 */
225 HWTEST_F(AudioConcurrencyServiceUnitTest, AudioConcurrencyService_010, TestSize.Level1)
226 {
227 std::vector<std::shared_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
228 std::vector<std::shared_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
229 auto audioConcurrencyService = std::make_shared<AudioConcurrencyService>();
230
231 auto audioCapturerChangeInfo = std::make_shared<AudioCapturerChangeInfo>();
232 audioCapturerChangeInfo->capturerInfo.pipeType = PIPE_TYPE_CALL_IN;
233 audioCapturerChangeInfos.push_back(audioCapturerChangeInfo);
234
235 std::pair<AudioPipeType, AudioPipeType> pair = std::make_pair(audioCapturerChangeInfo->capturerInfo.pipeType,
236 AudioPipeType::PIPE_TYPE_CALL_IN);
237 audioConcurrencyService->concurrencyCfgMap_.insert({pair, ConcurrencyAction::PLAY_BOTH});
238
239 audioConcurrencyService->handler_ = std::make_shared<AudioPolicyServerHandler>();
240 auto result = audioConcurrencyService->ActivateAudioConcurrency(AudioPipeType::PIPE_TYPE_CALL_IN,
241 audioRendererChangeInfos, audioCapturerChangeInfos);
242 EXPECT_EQ(result, SUCCESS);
243
244 audioConcurrencyService->handler_ = nullptr;
245 result = audioConcurrencyService->ActivateAudioConcurrency(AudioPipeType::PIPE_TYPE_CALL_IN,
246 audioRendererChangeInfos, audioCapturerChangeInfos);
247 EXPECT_EQ(result, SUCCESS);
248 }
249
250 /**
251 * @tc.name : Test AudioInputThread.
252 * @tc.number: AudioConcurrencyService_011.
253 * @tc.desc : Test ActivateAudioConcurrency.
254 */
255 HWTEST_F(AudioConcurrencyServiceUnitTest, AudioConcurrencyService_011, TestSize.Level1)
256 {
257 std::vector<std::shared_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
258 std::vector<std::shared_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
259 auto audioConcurrencyService = std::make_shared<AudioConcurrencyService>();
260
261 auto audioCapturerChangeInfo = std::make_shared<AudioCapturerChangeInfo>();
262 audioCapturerChangeInfo->capturerInfo.pipeType = PIPE_TYPE_CALL_IN;
263 audioCapturerChangeInfos.push_back(audioCapturerChangeInfo);
264
265 std::pair<AudioPipeType, AudioPipeType> pair = std::make_pair(audioCapturerChangeInfo->capturerInfo.pipeType,
266 AudioPipeType::PIPE_TYPE_CALL_IN);
267 audioConcurrencyService->concurrencyCfgMap_.insert({pair, ConcurrencyAction::CONCEDE_EXISTING});
268
269 audioConcurrencyService->handler_ = nullptr;
270 auto result = audioConcurrencyService->ActivateAudioConcurrency(AudioPipeType::PIPE_TYPE_CALL_IN,
271 audioRendererChangeInfos, audioCapturerChangeInfos);
272 EXPECT_EQ(result, SUCCESS);
273 }
274
275 /**
276 * @tc.name : Test AudioInputThread.
277 * @tc.number: AudioConcurrencyService_012.
278 * @tc.desc : Test ActivateAudioConcurrency.
279 */
280 HWTEST_F(AudioConcurrencyServiceUnitTest, AudioConcurrencyService_012, TestSize.Level1)
281 {
282 std::vector<std::shared_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
283 std::vector<std::shared_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
284 auto audioConcurrencyService = std::make_shared<AudioConcurrencyService>();
285
286 auto audioCapturerChangeInfo = std::make_shared<AudioCapturerChangeInfo>();
287 audioCapturerChangeInfo->capturerInfo.pipeType = PIPE_TYPE_CALL_IN;
288 audioCapturerChangeInfos.push_back(audioCapturerChangeInfo);
289
290 std::pair<AudioPipeType, AudioPipeType> pair = std::make_pair(audioCapturerChangeInfo->capturerInfo.pipeType,
291 AudioPipeType::PIPE_TYPE_CALL_IN);
292 audioConcurrencyService->concurrencyCfgMap_.insert({pair, ConcurrencyAction::CONCEDE_EXISTING});
293
294 audioConcurrencyService->handler_ = std::make_shared<AudioPolicyServerHandler>();
295 auto result = audioConcurrencyService->ActivateAudioConcurrency(AudioPipeType::PIPE_TYPE_CALL_IN,
296 audioRendererChangeInfos, audioCapturerChangeInfos);
297 EXPECT_EQ(result, ERR_CONCEDE_INCOMING_STREAM);
298 }
299
300 /**
301 * @tc.name : Test AudioInputThread.
302 * @tc.number: AudioConcurrencyService_013.
303 * @tc.desc : Test ActivateAudioConcurrency.
304 */
305 HWTEST_F(AudioConcurrencyServiceUnitTest, AudioConcurrencyService_013, TestSize.Level1)
306 {
307 std::vector<std::shared_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
308 std::vector<std::shared_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
309 auto audioConcurrencyService = std::make_shared<AudioConcurrencyService>();
310
311 auto audioCapturerChangeInfo = std::make_shared<AudioCapturerChangeInfo>();
312 audioCapturerChangeInfo->capturerInfo.pipeType = PIPE_TYPE_LOWLATENCY_OUT;
313 audioCapturerChangeInfos.push_back(audioCapturerChangeInfo);
314
315 std::pair<AudioPipeType, AudioPipeType> pair = std::make_pair(audioCapturerChangeInfo->capturerInfo.pipeType,
316 AudioPipeType::PIPE_TYPE_CALL_IN);
317 audioConcurrencyService->concurrencyCfgMap_.insert({pair, ConcurrencyAction::CONCEDE_EXISTING});
318
319 audioConcurrencyService->handler_ = std::make_shared<AudioPolicyServerHandler>();
320 auto result = audioConcurrencyService->ActivateAudioConcurrency(AudioPipeType::PIPE_TYPE_CALL_IN,
321 audioRendererChangeInfos, audioCapturerChangeInfos);
322 EXPECT_EQ(result, SUCCESS);
323 }
324
325 /**
326 * @tc.name : Test AudioInputThread.
327 * @tc.number: AudioConcurrencyService_014.
328 * @tc.desc : Test ActivateAudioConcurrency.
329 */
330 HWTEST_F(AudioConcurrencyServiceUnitTest, AudioConcurrencyService_014, TestSize.Level1)
331 {
332 std::vector<std::shared_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
333 std::vector<std::shared_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
334 auto audioConcurrencyService = std::make_shared<AudioConcurrencyService>();
335
336 auto audioCapturerChangeInfo = std::make_shared<AudioCapturerChangeInfo>();
337 audioCapturerChangeInfo->capturerInfo.pipeType = PIPE_TYPE_CALL_IN;
338 audioCapturerChangeInfos.push_back(audioCapturerChangeInfo);
339
340 std::pair<AudioPipeType, AudioPipeType> pair = std::make_pair(audioCapturerChangeInfo->capturerInfo.pipeType,
341 AudioPipeType::PIPE_TYPE_LOWLATENCY_OUT);
342 audioConcurrencyService->concurrencyCfgMap_.insert({pair, ConcurrencyAction::CONCEDE_EXISTING});
343
344 audioConcurrencyService->handler_ = std::make_shared<AudioPolicyServerHandler>();
345 auto result = audioConcurrencyService->ActivateAudioConcurrency(AudioPipeType::PIPE_TYPE_LOWLATENCY_OUT,
346 audioRendererChangeInfos, audioCapturerChangeInfos);
347 EXPECT_EQ(result, SUCCESS);
348 }
349
350 /**
351 * @tc.name : Test AudioInputThread.
352 * @tc.number: AudioConcurrencyService_015.
353 * @tc.desc : Test ActivateAudioConcurrency.
354 */
355 HWTEST_F(AudioConcurrencyServiceUnitTest, AudioConcurrencyService_015, TestSize.Level1)
356 {
357 std::vector<std::shared_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
358 std::vector<std::shared_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
359 auto audioConcurrencyService = std::make_shared<AudioConcurrencyService>();
360
361 auto audioCapturerChangeInfo = std::make_shared<AudioCapturerChangeInfo>();
362 audioCapturerChangeInfo->capturerInfo.pipeType = PIPE_TYPE_LOWLATENCY_OUT;
363 audioCapturerChangeInfos.push_back(audioCapturerChangeInfo);
364
365 std::pair<AudioPipeType, AudioPipeType> pair = std::make_pair(audioCapturerChangeInfo->capturerInfo.pipeType,
366 AudioPipeType::PIPE_TYPE_LOWLATENCY_OUT);
367 audioConcurrencyService->concurrencyCfgMap_.insert({pair, ConcurrencyAction::CONCEDE_EXISTING});
368
369 audioConcurrencyService->handler_ = std::make_shared<AudioPolicyServerHandler>();
370 auto result = audioConcurrencyService->ActivateAudioConcurrency(AudioPipeType::PIPE_TYPE_LOWLATENCY_OUT,
371 audioRendererChangeInfos, audioCapturerChangeInfos);
372 EXPECT_EQ(result, SUCCESS);
373 }
374 } // namespace AudioStandard
375 } // namespace OHOS