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_device_lock_unit_test.h"
17
18 using namespace testing::ext;
19
20 namespace OHOS {
21 namespace AudioStandard {
22
23 static int32_t NUM_5 = 5;
24 static int32_t NUM_20 = 20;
25
SetUpTestCase(void)26 void AudioDeviceLockUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)27 void AudioDeviceLockUnitTest::TearDownTestCase(void) {}
SetUp(void)28 void AudioDeviceLockUnitTest::SetUp(void) {}
TearDown(void)29 void AudioDeviceLockUnitTest::TearDown(void) {}
30
31 /**
32 * @tc.name : Test AudioDeviceLock.
33 * @tc.number: AudioDeviceLock_001
34 * @tc.desc : Test GetHasDpFlag interface.
35 */
36 HWTEST_F(AudioDeviceLockUnitTest, AudioDeviceLock_001, TestSize.Level1)
37 {
38 auto audioDeviceLock = std::make_shared<AudioDeviceLock>();
39 EXPECT_NE(audioDeviceLock, nullptr);
40
41 AudioMode mode = AudioMode::AUDIO_MODE_RECORD;
42 AudioStreamChangeInfo streamChangeInfo;
43 sptr<IRemoteObject> object = nullptr;
44 int32_t apiVersion = 0;
45
46 auto ret = audioDeviceLock->RegisterTracker(mode, streamChangeInfo, object, apiVersion);
47 EXPECT_NE(ret, SUCCESS);
48 }
49
50 /**
51 * @tc.name : Test AudioDeviceLock.
52 * @tc.number: AudioDeviceLock_002
53 * @tc.desc : Test GetHasDpFlag interface.
54 */
55 HWTEST_F(AudioDeviceLockUnitTest, AudioDeviceLock_002, TestSize.Level1)
56 {
57 auto audioDeviceLock = std::make_shared<AudioDeviceLock>();
58 EXPECT_NE(audioDeviceLock, nullptr);
59
60 AudioMode mode = AudioMode::AUDIO_MODE_RECORD;
61 AudioStreamChangeInfo streamChangeInfo;
62 sptr<IRemoteObject> object = nullptr;
63 int32_t apiVersion = NUM_5;
64
65 auto ret = audioDeviceLock->RegisterTracker(mode, streamChangeInfo, object, apiVersion);
66 EXPECT_NE(ret, SUCCESS);
67 }
68
69 /**
70 * @tc.name : Test AudioDeviceLock.
71 * @tc.number: AudioDeviceLock_003
72 * @tc.desc : Test GetHasDpFlag interface.
73 */
74 HWTEST_F(AudioDeviceLockUnitTest, AudioDeviceLock_003, TestSize.Level1)
75 {
76 auto audioDeviceLock = std::make_shared<AudioDeviceLock>();
77 EXPECT_NE(audioDeviceLock, nullptr);
78
79 AudioMode mode = AudioMode::AUDIO_MODE_RECORD;
80 AudioStreamChangeInfo streamChangeInfo;
81 sptr<IRemoteObject> object = nullptr;
82 int32_t apiVersion = NUM_20;
83
84 auto ret = audioDeviceLock->RegisterTracker(mode, streamChangeInfo, object, apiVersion);
85 EXPECT_NE(ret, SUCCESS);
86 }
87
88 /**
89 * @tc.name : Test AudioDeviceLock.
90 * @tc.number: AudioDeviceLock_004
91 * @tc.desc : Test GetHasDpFlag interface.
92 */
93 HWTEST_F(AudioDeviceLockUnitTest, AudioDeviceLock_004, TestSize.Level1)
94 {
95 auto audioDeviceLock = std::make_shared<AudioDeviceLock>();
96 EXPECT_NE(audioDeviceLock, nullptr);
97
98 AudioMode mode = AudioMode::AUDIO_MODE_PLAYBACK;
99 AudioStreamChangeInfo streamChangeInfo;
100 sptr<IRemoteObject> object = nullptr;
101 int32_t apiVersion = 0;
102
103 auto ret = audioDeviceLock->RegisterTracker(mode, streamChangeInfo, object, apiVersion);
104 EXPECT_NE(ret, SUCCESS);
105 }
106
107 /**
108 * @tc.name : Test AudioDeviceLock.
109 * @tc.number: AudioDeviceLock_005
110 * @tc.desc : Test GetHasDpFlag interface.
111 */
112 HWTEST_F(AudioDeviceLockUnitTest, AudioDeviceLock_005, TestSize.Level1)
113 {
114 auto audioDeviceLock = std::make_shared<AudioDeviceLock>();
115 EXPECT_NE(audioDeviceLock, nullptr);
116
117 RendererState rendererState = RENDERER_RUNNING;
118 uint32_t sessionId = NUM_5;
119
120 audioDeviceLock->audioA2dpOffloadManager_ = std::make_shared<AudioA2dpOffloadManager>();
121 EXPECT_NE(audioDeviceLock->audioA2dpOffloadManager_, nullptr);
122
123
124 audioDeviceLock->audioA2dpOffloadManager_->audioA2dpOffloadFlag_.currentOffloadConnectionState_ =
125 CONNECTION_STATUS_CONNECTING;
126 audioDeviceLock->audioA2dpOffloadManager_->connectionTriggerSessionIds_ = {NUM_20};
127
128 audioDeviceLock->SendA2dpConnectedWhileRunning(rendererState, sessionId);
129 }
130
131 /**
132 * @tc.name : Test AudioDeviceLock.
133 * @tc.number: AudioDeviceLock_006
134 * @tc.desc : Test GetHasDpFlag interface.
135 */
136 HWTEST_F(AudioDeviceLockUnitTest, AudioDeviceLock_006, TestSize.Level1)
137 {
138 auto audioDeviceLock = std::make_shared<AudioDeviceLock>();
139 EXPECT_NE(audioDeviceLock, nullptr);
140
141 RendererState rendererState = RENDERER_RUNNING;
142 uint32_t sessionId = NUM_5;
143
144 audioDeviceLock->audioA2dpOffloadManager_ = nullptr;
145
146 audioDeviceLock->SendA2dpConnectedWhileRunning(rendererState, sessionId);
147 }
148
149 /**
150 * @tc.name : Test AudioDeviceLock.
151 * @tc.number: AudioDeviceLock_007
152 * @tc.desc : Test GetHasDpFlag interface.
153 */
154 HWTEST_F(AudioDeviceLockUnitTest, AudioDeviceLock_007, TestSize.Level1)
155 {
156 auto audioDeviceLock = std::make_shared<AudioDeviceLock>();
157 EXPECT_NE(audioDeviceLock, nullptr);
158
159 RendererState rendererState = RENDERER_NEW;
160 uint32_t sessionId = NUM_5;
161
162 audioDeviceLock->audioA2dpOffloadManager_ = nullptr;
163
164 audioDeviceLock->SendA2dpConnectedWhileRunning(rendererState, sessionId);
165 }
166
167 /**
168 * @tc.name : Test AudioDeviceLock.
169 * @tc.number: AudioDeviceLock_008
170 * @tc.desc : Test GetHasDpFlag interface.
171 */
172 HWTEST_F(AudioDeviceLockUnitTest, AudioDeviceLock_008, TestSize.Level1)
173 {
174 auto audioDeviceLock = std::make_shared<AudioDeviceLock>();
175 EXPECT_NE(audioDeviceLock, nullptr);
176
177 AudioMode mode = AudioMode::AUDIO_MODE_RECORD;
178 AudioStreamChangeInfo streamChangeInfo;
179 streamChangeInfo.audioCapturerChangeInfo.capturerState = CAPTURER_RELEASED;
180 streamChangeInfo.audioCapturerChangeInfo.capturerInfo.sourceType = SOURCE_TYPE_VOICE_RECOGNITION;
181
182 audioDeviceLock->HandleAudioCaptureState(mode, streamChangeInfo);
183 }
184
185 /**
186 * @tc.name : Test AudioDeviceLock.
187 * @tc.number: AudioDeviceLock_009
188 * @tc.desc : Test GetHasDpFlag interface.
189 */
190 HWTEST_F(AudioDeviceLockUnitTest, AudioDeviceLock_009, TestSize.Level1)
191 {
192 auto audioDeviceLock = std::make_shared<AudioDeviceLock>();
193 EXPECT_NE(audioDeviceLock, nullptr);
194
195 AudioMode mode = AudioMode::AUDIO_MODE_RECORD;
196 AudioStreamChangeInfo streamChangeInfo;
197 streamChangeInfo.audioCapturerChangeInfo.capturerState = CAPTURER_RELEASED;
198 streamChangeInfo.audioCapturerChangeInfo.capturerInfo.sourceType = SOURCE_TYPE_MIC;
199
200 audioDeviceLock->HandleAudioCaptureState(mode, streamChangeInfo);
201 }
202
203 /**
204 * @tc.name : Test AudioDeviceLock.
205 * @tc.number: AudioDeviceLock_010
206 * @tc.desc : Test GetHasDpFlag interface.
207 */
208 HWTEST_F(AudioDeviceLockUnitTest, AudioDeviceLock_010, TestSize.Level1)
209 {
210 auto audioDeviceLock = std::make_shared<AudioDeviceLock>();
211 EXPECT_NE(audioDeviceLock, nullptr);
212
213 AudioMode mode = AudioMode::AUDIO_MODE_RECORD;
214 AudioStreamChangeInfo streamChangeInfo;
215 streamChangeInfo.audioCapturerChangeInfo.capturerState = CAPTURER_STOPPED;
216 streamChangeInfo.audioCapturerChangeInfo.capturerInfo.sourceType = SOURCE_TYPE_VOICE_RECOGNITION;
217
218 audioDeviceLock->HandleAudioCaptureState(mode, streamChangeInfo);
219 }
220
221 /**
222 * @tc.name : Test AudioDeviceLock.
223 * @tc.number: AudioDeviceLock_011
224 * @tc.desc : Test GetHasDpFlag interface.
225 */
226 HWTEST_F(AudioDeviceLockUnitTest, AudioDeviceLock_011, TestSize.Level1)
227 {
228 auto audioDeviceLock = std::make_shared<AudioDeviceLock>();
229 EXPECT_NE(audioDeviceLock, nullptr);
230
231 AudioMode mode = AudioMode::AUDIO_MODE_RECORD;
232 AudioStreamChangeInfo streamChangeInfo;
233 streamChangeInfo.audioCapturerChangeInfo.capturerState = CAPTURER_NEW;
234
235 audioDeviceLock->HandleAudioCaptureState(mode, streamChangeInfo);
236 }
237
238 /**
239 * @tc.name : Test AudioDeviceLock.
240 * @tc.number: AudioDeviceLock_012
241 * @tc.desc : Test GetHasDpFlag interface.
242 */
243 HWTEST_F(AudioDeviceLockUnitTest, AudioDeviceLock_012, TestSize.Level1)
244 {
245 auto audioDeviceLock = std::make_shared<AudioDeviceLock>();
246 EXPECT_NE(audioDeviceLock, nullptr);
247
248 AudioMode mode = AudioMode::AUDIO_MODE_PLAYBACK;
249 AudioStreamChangeInfo streamChangeInfo;
250 streamChangeInfo.audioCapturerChangeInfo.capturerState = CAPTURER_NEW;
251
252 audioDeviceLock->HandleAudioCaptureState(mode, streamChangeInfo);
253 }
254
255 /**
256 * @tc.name : Test AudioDeviceLock.
257 * @tc.number: AudioDeviceLock_013
258 * @tc.desc : Test GetHasDpFlag interface.
259 */
260 HWTEST_F(AudioDeviceLockUnitTest, AudioDeviceLock_013, TestSize.Level1)
261 {
262 auto audioDeviceLock = std::make_shared<AudioDeviceLock>();
263 EXPECT_NE(audioDeviceLock, nullptr);
264
265 AudioMode mode = AudioMode::AUDIO_MODE_PLAYBACK;
266 AudioStreamChangeInfo streamChangeInfo;
267 streamChangeInfo.audioRendererChangeInfo.rendererState = RENDERER_PREPARED;
268
269 auto ret = audioDeviceLock->UpdateTracker(mode, streamChangeInfo);
270 EXPECT_EQ(ret, SUCCESS);
271 }
272
273 /**
274 * @tc.name : Test AudioDeviceLock.
275 * @tc.number: AudioDeviceLock_014
276 * @tc.desc : Test GetHasDpFlag interface.
277 */
278 HWTEST_F(AudioDeviceLockUnitTest, AudioDeviceLock_014, TestSize.Level1)
279 {
280 auto audioDeviceLock = std::make_shared<AudioDeviceLock>();
281 EXPECT_NE(audioDeviceLock, nullptr);
282
283 AudioMode mode = AudioMode::AUDIO_MODE_PLAYBACK;
284 AudioStreamChangeInfo streamChangeInfo;
285 streamChangeInfo.audioRendererChangeInfo.rendererState = RENDERER_NEW;
286
287 auto ret = audioDeviceLock->UpdateTracker(mode, streamChangeInfo);
288 EXPECT_EQ(ret, SUCCESS);
289 }
290
291 /**
292 * @tc.name : Test AudioDeviceLock.
293 * @tc.number: AudioDeviceLock_015
294 * @tc.desc : Test GetHasDpFlag interface.
295 */
296 HWTEST_F(AudioDeviceLockUnitTest, AudioDeviceLock_015, TestSize.Level1)
297 {
298 auto audioDeviceLock = std::make_shared<AudioDeviceLock>();
299 EXPECT_NE(audioDeviceLock, nullptr);
300
301 AudioMode mode = AudioMode::AUDIO_MODE_PLAYBACK;
302 AudioStreamChangeInfo streamChangeInfo;
303 streamChangeInfo.audioRendererChangeInfo.rendererState = RENDERER_NEW;
304
305 auto ret = audioDeviceLock->UpdateTracker(mode, streamChangeInfo);
306 EXPECT_EQ(ret, SUCCESS);
307 }
308
309 /**
310 * @tc.name : Test AudioDeviceLock.
311 * @tc.number: AudioDeviceLock_016
312 * @tc.desc : Test GetHasDpFlag interface.
313 */
314 HWTEST_F(AudioDeviceLockUnitTest, AudioDeviceLock_016, TestSize.Level1)
315 {
316 auto audioDeviceLock = std::make_shared<AudioDeviceLock>();
317 EXPECT_NE(audioDeviceLock, nullptr);
318
319 AudioMode mode = AudioMode::AUDIO_MODE_PLAYBACK;
320 AudioStreamChangeInfo streamChangeInfo;
321 streamChangeInfo.audioRendererChangeInfo.rendererState = RENDERER_INVALID;
322
323 auto ret = audioDeviceLock->UpdateTracker(mode, streamChangeInfo);
324 EXPECT_EQ(ret, SUCCESS);
325 }
326
327 /**
328 * @tc.name : Test AudioDeviceLock.
329 * @tc.number: AudioDeviceLock_017
330 * @tc.desc : Test GetHasDpFlag interface.
331 */
332 HWTEST_F(AudioDeviceLockUnitTest, AudioDeviceLock_017, TestSize.Level1)
333 {
334 auto audioDeviceLock = std::make_shared<AudioDeviceLock>();
335 EXPECT_NE(audioDeviceLock, nullptr);
336
337 AudioMode mode = AudioMode::AUDIO_MODE_PLAYBACK;
338 AudioStreamChangeInfo streamChangeInfo;
339 streamChangeInfo.audioRendererChangeInfo.rendererState = RENDERER_STOPPED;
340
341 audioDeviceLock->audioA2dpOffloadManager_ = std::make_shared<AudioA2dpOffloadManager>();
342 EXPECT_NE(audioDeviceLock->audioA2dpOffloadManager_, nullptr);
343
344 auto ret = audioDeviceLock->UpdateTracker(mode, streamChangeInfo);
345 EXPECT_EQ(ret, SUCCESS);
346 }
347
348 /**
349 * @tc.name : Test AudioDeviceLock.
350 * @tc.number: AudioDeviceLock_018
351 * @tc.desc : Test GetHasDpFlag interface.
352 */
353 HWTEST_F(AudioDeviceLockUnitTest, AudioDeviceLock_018, TestSize.Level1)
354 {
355 auto audioDeviceLock = std::make_shared<AudioDeviceLock>();
356 EXPECT_NE(audioDeviceLock, nullptr);
357
358 AudioMode mode = AudioMode::AUDIO_MODE_PLAYBACK;
359 AudioStreamChangeInfo streamChangeInfo;
360 streamChangeInfo.audioRendererChangeInfo.rendererState = RENDERER_STOPPED;
361
362 audioDeviceLock->audioA2dpOffloadManager_ = nullptr;
363
364 auto ret = audioDeviceLock->UpdateTracker(mode, streamChangeInfo);
365 EXPECT_EQ(ret, SUCCESS);
366 }
367
368 /**
369 * @tc.name : Test AudioDeviceLock.
370 * @tc.number: AudioDeviceLock_019
371 * @tc.desc : Test GetHasDpFlag interface.
372 */
373 HWTEST_F(AudioDeviceLockUnitTest, AudioDeviceLock_019, TestSize.Level1)
374 {
375 auto audioDeviceLock = std::make_shared<AudioDeviceLock>();
376 EXPECT_NE(audioDeviceLock, nullptr);
377
378 pid_t uid = PIPE_TYPE_OFFLOAD;
379
380 audioDeviceLock->RegisteredTrackerClientDied(uid);
381 EXPECT_NE(audioDeviceLock->streamCollector_.ExistStreamForPipe(PIPE_TYPE_OFFLOAD), true);
382 }
383
384 /**
385 * @tc.name : AudioDeviceLock_020
386 * @tc.desc : Test GetHasDpFlag interface.
387 */
388 HWTEST_F(AudioDeviceLockUnitTest, AudioDeviceLock_020, TestSize.Level1)
389 {
390 auto audioDeviceLock = std::make_shared<AudioDeviceLock>();
391 EXPECT_NE(audioDeviceLock, nullptr);
392
393 AudioDeviceDescriptor updatedDesc;
394 updatedDesc.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP;
395 updatedDesc.connectState_ = CONNECTED;
396 bool isConnected = true;
397
398 audioDeviceLock->OnDeviceStatusUpdated(updatedDesc, isConnected);
399 EXPECT_NE(audioDeviceLock, nullptr);
400 }
401
402 /**
403 * @tc.name : AudioDeviceLock_021
404 * @tc.desc : Test GetHasDpFlag interface.
405 */
406 HWTEST_F(AudioDeviceLockUnitTest, AudioDeviceLock_021, TestSize.Level1)
407 {
408 auto audioDeviceLock = std::make_shared<AudioDeviceLock>();
409 EXPECT_NE(audioDeviceLock, nullptr);
410
411 AudioDeviceDescriptor updatedDesc;
412 updatedDesc.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP;
413 updatedDesc.connectState_ = CONNECTED;
414 bool isConnected = false;
415
416 audioDeviceLock->OnDeviceStatusUpdated(updatedDesc, isConnected);
417 EXPECT_NE(audioDeviceLock, nullptr);
418 }
419
420 /**
421 * @tc.name : AudioDeviceLock_022
422 * @tc.desc : Test GetHasDpFlag interface.
423 */
424 HWTEST_F(AudioDeviceLockUnitTest, AudioDeviceLock_022, TestSize.Level1)
425 {
426 auto audioDeviceLock = std::make_shared<AudioDeviceLock>();
427 EXPECT_NE(audioDeviceLock, nullptr);
428
429 AudioDeviceDescriptor updatedDesc;
430 updatedDesc.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP;
431 updatedDesc.connectState_ = VIRTUAL_CONNECTED;
432 bool isConnected = false;
433
434 audioDeviceLock->OnDeviceStatusUpdated(updatedDesc, isConnected);
435 EXPECT_NE(audioDeviceLock, nullptr);
436 }
437
438 /**
439 * @tc.name : AudioDeviceLock_023
440 * @tc.desc : Test GetHasDpFlag interface.
441 */
442 HWTEST_F(AudioDeviceLockUnitTest, AudioDeviceLock_023, TestSize.Level1)
443 {
444 auto audioDeviceLock = std::make_shared<AudioDeviceLock>();
445 EXPECT_NE(audioDeviceLock, nullptr);
446
447 AudioDeviceDescriptor updatedDesc;
448 updatedDesc.deviceType_ = DEVICE_TYPE_BLUETOOTH_SCO;
449 updatedDesc.connectState_ = VIRTUAL_CONNECTED;
450 bool isConnected = false;
451
452 audioDeviceLock->OnDeviceStatusUpdated(updatedDesc, isConnected);
453 EXPECT_NE(audioDeviceLock, nullptr);
454 }
455
456 /**
457 * @tc.name : AudioDeviceLock_024
458 * @tc.desc : Test GetHasDpFlag interface.
459 */
460 HWTEST_F(AudioDeviceLockUnitTest, AudioDeviceLock_024, TestSize.Level1)
461 {
462 auto audioDeviceLock = std::make_shared<AudioDeviceLock>();
463 EXPECT_NE(audioDeviceLock, nullptr);
464
465 AudioDeviceDescriptor updatedDesc;
466 updatedDesc.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP_IN;
467 updatedDesc.connectState_ = CONNECTED;
468 bool isConnected = true;
469
470 audioDeviceLock->OnDeviceStatusUpdated(updatedDesc, isConnected);
471 EXPECT_NE(audioDeviceLock, nullptr);
472 }
473
474 /**
475 * @tc.name : AudioDeviceLock_025
476 * @tc.desc : Test GetHasDpFlag interface.
477 */
478 HWTEST_F(AudioDeviceLockUnitTest, AudioDeviceLock_025, TestSize.Level1)
479 {
480 auto audioDeviceLock = std::make_shared<AudioDeviceLock>();
481 EXPECT_NE(audioDeviceLock, nullptr);
482
483 AudioDeviceDescriptor updatedDesc;
484 updatedDesc.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP_IN;
485 updatedDesc.connectState_ = CONNECTED;
486 bool isConnected = false;
487
488 audioDeviceLock->OnDeviceStatusUpdated(updatedDesc, isConnected);
489 EXPECT_NE(audioDeviceLock, nullptr);
490 }
491
492 /**
493 * @tc.name : AudioDeviceLock_026
494 * @tc.desc : Test GetHasDpFlag interface.
495 */
496 HWTEST_F(AudioDeviceLockUnitTest, AudioDeviceLock_026, TestSize.Level1)
497 {
498 auto audioDeviceLock = std::make_shared<AudioDeviceLock>();
499 EXPECT_NE(audioDeviceLock, nullptr);
500
501 AudioDeviceDescriptor updatedDesc;
502 updatedDesc.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP_IN;
503 updatedDesc.connectState_ = VIRTUAL_CONNECTED;
504 bool isConnected = false;
505
506 audioDeviceLock->OnDeviceStatusUpdated(updatedDesc, isConnected);
507 EXPECT_NE(audioDeviceLock, nullptr);
508 }
509
510 /**
511 * @tc.name : AudioDeviceLock_027
512 * @tc.desc : Test GetHasDpFlag interface.
513 */
514 HWTEST_F(AudioDeviceLockUnitTest, AudioDeviceLock_027, TestSize.Level1)
515 {
516 auto audioDeviceLock = std::make_shared<AudioDeviceLock>();
517 EXPECT_NE(audioDeviceLock, nullptr);
518
519 std::vector<std::shared_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos =
520 {std::make_shared<AudioRendererChangeInfo>()};
521 bool hasBTPermission = true;
522 bool hasSystemPermission = true;
523
524 auto ret = audioDeviceLock->GetCurrentRendererChangeInfos(audioRendererChangeInfos,
525 hasBTPermission, hasSystemPermission);
526 EXPECT_NE(ret, true);
527 }
528 } // namespace AudioStandard
529 } // namespace OHOS